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(); }