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

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
class_mapper_base::adopt_untyped(const abstract_mapper_base &child) {
    _children.push_back(&child);
    if (! child.can_be_all_null())  forbid_all_null();
}