void
sql::write_update(
const binomen &table,
const abstract_mapper_base &dest,
const abstract_mapper_base &src,
optional<column_id> excluded
) {
vector<const column_mapper *> src_columns;
src.for_each_column([&](const column_mapper &c) {
src_columns.push_back(&c);
});
auto src_column_iter = src_columns.begin();
write("UPDATE ");
write_quoted(table);
write(" SET ");
comma_separated_list_scope list_scope(*this);
dest.for_each_persistent_column([&](const persistent_column_mapper &p) {
if (p.id() != excluded) {
list_scope.start_item();
write_quoted(p.name());
write(" = ");
write_evaluation(**src_column_iter++);
}
});
}
void
table_base::rename_field_impl(const abstract_mapper_base &before, const abstract_mapper_base &after) const {
if (_is_open)
throw table_open_exception();
const column_id_set my_columns = _value_mapper.column_ids();
if (! (
is_subset(before.column_ids(), my_columns)
|| is_subset(after.column_ids(), my_columns)
))
throw outside_table_exception(_binomen);
vector<string> names_before;
vector<string> names_after;
before.for_each_persistent_column([&](const persistent_column_mapper &p) { names_before.push_back(p.name()); } );
after.for_each_persistent_column([&](const persistent_column_mapper &p) { names_after.push_back(p.name()); } );
const size_t n = names_before.size();
assert(names_after.size() == n);
transaction txn(_database);
unique_ptr<sql> cmd;
for (size_t i = 0; i < n; i++) {
cmd = _database.make_sql();
cmd->write_rename_column(_binomen, names_before[i], names_after[i]);
_database.get_session()->exec(*cmd);
}
txn.commit();
}
void
table_base::add_field_impl(const abstract_mapper_base &dest, const Src &src) const {
if (_is_open)
throw table_open_exception();
if (! is_subset(dest.column_ids(), _value_mapper.column_ids()))
throw outside_table_exception(_binomen);
const optional<column_id> readback = readback_id();
transaction txn(_database);
unique_ptr<sql> cmd;
cmd = _database.make_sql();
cmd->write_add_columns(_binomen, dest, readback);
_database.get_session()->exec(*cmd);
if (! readback || dest.column_ids() != column_id_set{*readback})
update_with_no_output(dest, src, predicate(true));
cmd = _database.make_sql();
cmd->write_constrain_as_not_null_where_appropriate(_binomen, dest);
_database.get_session()->exec(*cmd);
txn.commit();
}
void
table_base::set_field_type(const abstract_mapper_base &mapper) const {
if (is_open())
throw table_open_exception();
if (! is_subset(mapper.column_ids(), _value_mapper.column_ids()))
throw outside_table_exception(_binomen);
transaction txn(_database);
unique_ptr<sql> cmd;
// In case some fields went from non-optional to optional, and also to avoid duplication
// of abiding non-null constraints, which will be re-added by constrain_as_not_null() below:
//
cmd = _database.make_sql();
cmd->write_unconstrain_as_not_null(_binomen, mapper);
_database.get_session()->exec(*cmd);
cmd = _database.make_sql();
cmd->write_set_columns_types(_binomen, mapper, readback_id());
_database.get_session()->exec(*cmd);
// In case some fields went from optional to non-optional:
//
cmd = _database.make_sql();
cmd->write_constrain_as_not_null_where_appropriate(_binomen, mapper);
_database.get_session()->exec(*cmd);
txn.commit();
}
void
sql::write_titles(const abstract_mapper_base &mapper, optional<column_id> generated_key) {
comma_separated_list_scope list_scope(*this);
mapper.for_each_persistent_column([&](const persistent_column_mapper &p) {
list_scope.start_item();
write_title(p, generated_key);
if (! p.can_be_all_null()) write(" NOT NULL");
});
}
void
sql::write_unconstrain_as_not_null(const binomen &table, const abstract_mapper_base &mapper) {
write_alter_table(table);
comma_separated_list_scope list_scope(*this);
mapper.for_each_persistent_column([&](const persistent_column_mapper &p) {
list_scope.start_item();
write("ALTER COLUMN ");
write_quoted(p.name());
write(" DROP NOT NULL");
});
}
void
table_base::drop_field(const abstract_mapper_base &deletion) const {
if (is_open())
throw table_open_exception();
if (! is_subset(deletion.column_ids(), _value_mapper.column_ids()))
throw outside_table_exception(_binomen);
const unique_ptr<sql> cmd = _database.make_sql();
cmd->write_drop_columns(_binomen, deletion);
_database.get_session()->exec(*cmd);
}
void
sql::write_parenthesized_persistent_column_list(const abstract_mapper_base &mapper, optional<column_id> excluded) {
write("(");
comma_separated_list_scope list_scope(*this);
mapper.for_each_persistent_column(
[&](const persistent_column_mapper &p) {
if (p.id() != excluded) {
list_scope.start_item();
write_quoted(p.name());
}
}
);
write(")");
}
unique_ptr<sql>
table_base::sql_update(
const abstract_mapper_base &dest,
const Src &src,
const abstract_predicate &pred,
const abstract_mapper_base *returning
) const {
if (! is_subset(dest.columns(), _value_mapper.columns()))
throw outside_table_exception(_binomen);
unique_ptr<sql> cmd = _database.make_sql();
cmd->write_update(_binomen, dest, src, readback_id());
if (! a_priori_true(pred)) cmd->write_where(pred);
if (returning != nullptr) cmd->write_returning(*returning);
return cmd;
}
void
sql::write_values(
const abstract_mapper_base &value_mapper,
const row &data,
optional<column_id> excluded
) {
write(" VALUES (");
comma_separated_list_scope list_scope(*this);
value_mapper.for_each_persistent_column(
[&](const persistent_column_mapper &p) {
if (p.id() != excluded) {
list_scope.start_item();
write_value(*data.find_cell(p.name()));
}
}
);
write(")");
}
void
sql::write_update(
const binomen &table,
const abstract_mapper_base &dest,
const row &src,
optional<column_id> excluded
) {
// TODO: factor out the code in common with the other overload
//
write("UPDATE ");
write_quoted(table);
write(" SET ");
comma_separated_list_scope list_scope(*this);
dest.for_each_persistent_column([&](const persistent_column_mapper &p) {
if (p.id() != excluded) {
list_scope.start_item();
write_quoted(p.name());
write(" = ");
write_value(*src.find_cell(p.name()));
}
});
}
void
class_mapper_base::adopt_untyped(const abstract_mapper_base &child) {
_children.push_back(&child);
if (! child.can_be_all_null()) forbid_all_null();
}
