AbstractTable.qc.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
namespace SqlUtil {
 
class AbstractTable : public AbstractSqlUtilBase {
 
public:
 
        const TableOptions = {
            "native_case": Type::Boolean,
            "table_cache": "Tables",
        };
 
 
        const IndexOptions = {
            "index_tablespace": Type::String,
            "replace": Type::Boolean,
        };
 
 
        const ConstraintOptions = IndexOptions;
 
        const CacheOptions = {
            "table_cache": "Tables",
        };
 
 
        const ForeignConstraintOptions = ConstraintOptions + {
            "table_cache": "Tables",
        };
 
 
        const TriggerOptions = AbstractDatabase::CreationOptions;
 
 
        const SelectOptions = {
            "alias": Type::String,
            "comment": Type::String,
            "hint": Type::String,
            "columns": Type::NothingType,
            "where": "hash/list",
            "orderby": "softstringinthashlist",
            "desc": Type::Boolean,
            "limit": Type::Int,
            "offset": Type::Int,
            "join": Type::Hash,
            "groupby": "softstringinthashlist",
            "having": Type::Hash,
            "superquery": Type::Hash,
            "forupdate": Type::Boolean,
        };
 
        const TableOmissionOptions = {
            "indexes": True,
            "foreign_constraints": True,
            "triggers": True,
        };
 
 
        const TableCreationOptions = IndexOptions + AbstractDatabase::CreationOptions + {
            "omit": "softstringlist",
        };
 
 
        const AlignTableOptions = TableCreationOptions + {
            "column_map": Type::Hash,
            "index_map": Type::Hash,
            "constraint_map": Type::Hash,
            "trigger_map": Type::Hash,
            "db_table_cache": "Tables",
            "force": Type::Boolean,
        };
 
 
        const TableDescriptionHashOptions = {
            "columns": Type::Hash,
            "primary_key": Type::Hash,
            "indexes": Type::Hash,
            "triggers": Type::Hash,
            "foreign_constraints": Type::Hash,
            "unique_constraints": Type::Hash,
            //"check_constraints": Type::Hash,
            "table_cache": "Tables",
        };
 
 
        const ColumnDescOptions = {
            "qore_type": Type::String,
            "native_type": Type::String,
            "size": Type::Int,
            "scale": Type::Int,
            "default_value": Type::NothingType,
            "default_value_native": Type::Boolean,
            "comment": Type::String,
            "notnull": Type::Boolean,
            "driver": Type::Hash,
        };
 
 
        const AdditionalColumnDescOptions = {
            "notnull": Type::Boolean,
        };
 
        const ColumnOptions = {};
 
 
        const SqlDataCallbackOptions = {
            "sqlarg_callback": "code",
            "tablecode": "code",
        };
 
 
        const InsertOptions = SqlDataCallbackOptions + {
            "returning": "stringhashlist",
        };
 
 
        const UpsertOptions = {
            "info_callback": "code",
            "commit_block": Type::Int,
            "delete_others": Type::Boolean,
            "omit_update": "softstringlist",
        };
 
 
        const InsertFromIteratorOptions = SqlDataCallbackOptions + {
            "info_callback": "code",
            "commit_block": Type::Int,
        };
 
 
        const UpsertInsertFirst = 1;
 
 
        const UpsertUpdateFirst = 2;
 
 
        const UpsertSelectFirst = 3;
 
 
        const UpsertAuto = 4;
 
 
        const UpsertInsertOnly = 5;
 
 
        const UpsertUpdateOnly = 6;
 
 
        const UpsertStrategyMap = {
            UpsertInsertFirst: "UpsertInsertFirst",
            UpsertUpdateFirst: "UpsertUpdateFirst",
            UpsertSelectFirst: "UpsertSelectFirst",
            UpsertAuto: "UpsertAuto",
            UpsertInsertOnly: "UpsertInsertOnly",
            UpsertUpdateOnly: "UpsertUpdateOnly",
        };
 
 
        const UpsertStrategyDescriptionMap = {
            "UpsertInsertFirst": UpsertInsertFirst,
            "UpsertUpdateFirst": UpsertUpdateFirst,
            "UpsertSelectFirst": UpsertSelectFirst,
            "UpsertAuto": UpsertAuto,
            "UpsertInsertOnly": UpsertInsertOnly,
            "UpsertUpdateOnly": UpsertUpdateOnly,
        };
 
        const UR_Inserted = 1;
 
        const UR_Verified = 2;
 
        const UR_Updated = 3;
 
        const UR_Unchanged = 4;
 
        const UR_Deleted = 5;
 
 
        const UpsertResultMap = {
            UR_Inserted: "inserted",
            UR_Verified: "verified",
            UR_Updated: "updated",
            UR_Unchanged: "unchanged",
            UR_Deleted: "deleted",
        };
 
 
        const UpsertResultDescriptionMap = {
            "inserted": UR_Inserted,
            "verified": UR_Verified,
            "updated": UR_Updated,
            "unchanged": UR_Unchanged,
            "deleted": UR_Deleted,
        };
 
        const UpsertResultLetterMap = {
            UR_Inserted: "I",
            UR_Verified: "V",
            UR_Updated: "U",
            UR_Unchanged: ".",
            UR_Deleted: "X",
        };
 
protected:
        string name;
        Columns columns;
        AbstractPrimaryKey primaryKey;
        Indexes indexes;
        ForeignConstraints foreignConstraints;
        Constraints constraints;
        Triggers triggers;
        bool native_case = False;
        bool inDb = False;
        bool manual = False;
 
        hash m_customCopMap = {};
 
public:
 
 
protected:
     constructor(AbstractDatasource nds, string nname, *hash nopts) ;
public:
 
 
    copy(AbstractTable old);
 
 
 
    setDatasource(AbstractDatasource nds);
 
 
protected:
     doTableOptions(*hash<auto> nopts);
public:
 
 
    beginTransaction();
 
 
    commit();
 
 
    rollback();
 
 
 
    bool inDb();
 
 
 
    Qore::AbstractIterator getUniqueConstraintIterator();
 
 
 
    dropCommit(*hash<auto> opt);
 
 
 
    drop(*hash<auto> opt);
 
 
      deprecated dropNoCommit(*hash<auto> opt);
 
 
    auto tryExec(string sql);
 
 
 
    auto tryExecArgs(string sql, *softlist<auto> args);
 
 
 
    auto tryExecRaw(string sql);
 
 
 
    softlist<auto> getDropSql(*hash<auto> opt);
 
 
 
    truncateCommit();
 
 
 
    truncate();
 
 
      deprecated truncateNoCommit();
 
 
    string getTruncateSql(*hash<auto> opt);
 
 
 
    createCommit(*hash<auto> opt);
 
 
 
    create(*hash<auto> opt);
 
 
      deprecated createNoCommit(*hash<auto> opt);
 
 
    rename(string new_name, *reference<string> sql, *Tables table_cache);
 
 
protected:
     doRenameIntern(string new_name, *Tables table_cache);
public:
 
 
 
    bool emptyData();
 
 
 
    bool empty();
 
 
protected:
     bool emptyUnlocked();
public:
 
 
 
    setupTable(hash<auto> desc, *hash<auto> opt);
 
 
 
    AbstractColumn addColumn(string cname, hash<auto> opt, bool nullable = True, *reference lsql);
 
 
 
    list<auto> getAddColumnSql(string cname, hash<auto> copt, bool nullable = True, *hash<auto> opt);
 
 
    private AbstractColumn addColumnUnlocked(string cname, hash<auto> opt, bool nullable = True, *reference lsql,
            bool do_exec = True, bool modify_table = True) {
        if (!columns)
            columns = new Columns();
        else if (columns.hasKey(cname))
            throw "COLUMN-ERROR", sprintf("%s column %y: this column already exists", getDesc(), cname);
 
        if (!opt.native_type && !opt.qore_type)
            throw "COLUMN-ERROR", sprintf("%s column %y: no native_type or qore_type keys in column option hash: %y",
                getDesc(), cname, opt);
 
        validateColumnOptions(cname, \opt, nullable);
 
        // get the new column object
        AbstractColumn c = addColumnImpl(cname, opt, nullable);
 
        // add column in table if the table is already known to be in the database
        lsql = c.getAddColumnSql(self);
        if (do_exec)
            execSql(lsql);
 
        // add the column to the internal column representation
        if (modify_table)
            addColumnToTableUnlocked(c);
 
        return c;
    }
 
protected:
     addColumnToTableUnlocked(AbstractColumn c);
public:
 
 
 
    AbstractColumn modifyColumn(string cname, hash<auto> opt, bool nullable = True, *reference lsql);
 
 
 
    list<auto> getModifyColumnSql(string cname, hash<auto> copt, bool nullable = True, *hash<auto> opt);
 
 
 
    AbstractColumn renameColumn(string old_name, string new_name, reference<string> sql);
 
 
 
    string getRenameColumnSql(string old_name, string new_name, *hash<auto> opt);
 
 
protected:
     AbstractColumn renameColumnIntern(AbstractColumn c, string new_name);
public:
 
 
protected:
     validateOptionsIntern(string err, hash<auto> ropt, reference<hash<auto>> opt);
public:
 
 
protected:
     validateOptionsIntern(string err, hash<auto> ropt, reference<hash<auto>> opt, string tag);
public:
 
 
protected:
     execSql(softlist lsql);
public:
 
 
 
    AbstractPrimaryKey addPrimaryKey(string pkname, softlist cols, *hash<auto> opt, *reference<string> sql);
 
 
 
    string getAddPrimaryKeySql(string pkname, softlist cols, *hash pkopt, *hash<auto> opt);
 
 
protected:
     setPrimaryKeyUnlocked(AbstractPrimaryKey pk);
public:
 
 
protected:
     AbstractPrimaryKey addPrimaryKeyUnlocked(string pkname, softlist cols, *hash<auto> opt, *reference<string> sql);
public:
 
 
protected:
     AbstractPrimaryKey addPrimaryKeyUnlockedIntern(string pkname, softlist cols, *hash<auto> opt, *reference<string> sql);
public:
 
 
 
    list<auto> getDropAllConstraintsAndIndexesOnColumnSql(string cname, *hash<auto> opt);
 
 
protected:
     list<auto> getDropAllConstraintsAndIndexesOnColumnSqlUnlocked(string cname, *hash<auto> opt);
public:
 
 
 
    list<auto> getDropPrimaryKeySql(*hash<auto> opt);
 
 
 
    AbstractPrimaryKey dropPrimaryKey(*reference lsql);
 
 
 
    AbstractUniqueConstraint addUniqueConstraint(string cname, softlist cols, *hash<auto> opt, *reference<string> sql);
 
 
 
    string getAddUniqueConstraintSql(string cname, softlist cols, *hash ukopt, *hash<auto> opt);
 
 
protected:
     AbstractUniqueConstraint addUniqueConstraintUnlocked(string cname, softlist cols, *hash<auto> opt, *reference<string> sql);
public:
 
 
protected:
     AbstractUniqueConstraint addUniqueConstraintUnlockedIntern(string cname, softlist cols, *hash<auto> opt, *reference<string> sql);
public:
 
 
 
    AbstractIndex addIndex(string iname, bool unique, softlist cols, *hash<auto> opt, *reference<string> sql);
 
 
 
    string getAddIndexSql(string iname, bool unique, softlist cols, *hash<auto> ixopt, *hash<auto> opt);
 
 
protected:
     AbstractIndex addIndexUnlocked(string iname, bool unique, softlist cols, *hash<auto> opt, *reference<string> sql);
public:
 
 
protected:
     AbstractIndex addIndexUnlockedIntern(string iname, bool unique, softlist cols, *hash<auto> opt, *reference<string> sql);
public:
 
 
 
    AbstractIndex renameIndex(string old_name, string new_name, reference<string> sql);
 
 
 
    AbstractIndex dropIndex(string iname, *reference<string> sql);
 
 
 
    string getDropIndexSql(string iname, *hash<auto> opt);
 
 
 
    AbstractForeignConstraint addForeignConstraint(string cname, softlist cols, string table, *softlist tcols, *hash<auto> opt, *reference<string> sql);
 
 
 
    string getAddForeignConstraintSql(string cname, softlist cols, string table, *softlist tcols, *hash fkopt, *hash<auto> opt);
 
 
protected:
     Columns getReferencedTableColumnsUnlocked(string table, *Tables cache, string err = 'FOREIGN-CONSTRAINT-ERROR');
public:
 
 
protected:
     AbstractForeignConstraint addForeignConstraintUnlocked(string cname, softlist cols, string table, *softlist tcols, *hash<auto> opt, *reference<string> sql);
public:
 
 
protected:
     AbstractForeignConstraint addForeignConstraintUnlockedIntern(string cname, softlist cols, string table, *softlist tcols, *hash<auto> opt, *reference<string> sql);
public:
 
 
 
    AbstractForeignConstraint dropForeignConstraint(string cname, *reference<string> sql);
 
 
 
    AbstractForeignConstraint removeForeignConstraint(string cname);
 
 
 
    AbstractCheckConstraint addCheckConstraint(string cname, string src, *hash<auto> opt, *reference<string> sql);
 
 
 
    string getAddCheckConstraintSql(string cname, string src, *hash copt, *hash<auto> opt);
 
 
protected:
     AbstractCheckConstraint addCheckConstraintUnlocked(string cname, string src, *hash<auto> opt, *reference<string> sql);
public:
 
 
protected:
     AbstractCheckConstraint addCheckConstraintUnlockedIntern(string cname, string src, *hash<auto> opt, *reference<string> sql);
public:
 
 
 
    AbstractConstraint renameConstraint(string old_name, string new_name, reference lsql);
 
 
 
    string getDropConstraintSql(string cname, *hash<auto> opt);
 
 
 
    *string getDropConstraintIfExistsSql(string cname, *hash<auto> opt, *reference<AbstractConstraint> cref);
 
 
protected:
     AbstractConstraint findDropConstraintUnlocked(string cname, reference<code> rmv);
public:
 
 
 
    AbstractConstraint dropConstraint(string cname, *reference<string> sql);
 
 
 
    AbstractTrigger addTrigger(string tname, string src, *hash<auto> opt, *reference lsql);
 
 
 
    list<auto> getAddTriggerSql(string tname, string src, *hash topt, *hash<auto> opt);
 
 
protected:
     AbstractTrigger addTriggerUnlocked(string tname, string src, *hash<auto> opt, *reference lsql);
public:
 
 
protected:
     AbstractTrigger addTriggerUnlockedIntern(string tname, string src, *hash<auto> opt, *reference lsql);
public:
 
 
 
    AbstractTrigger dropTrigger(string tname, *reference<string> sql);
 
 
 
    list<auto> getDropTriggerSql(string tname, *hash<auto> opt);
 
 
protected:
     getAllConstraintsUnlocked(*hash<auto> opt);
public:
 
 
protected:
     checkUniqueConstraintName(string err, string cname);
public:
 
 
protected:
     checkUniqueConstraintNameValidateOptions(string err, string cname, hash<auto> ropt, reference<hash> opt);
public:
 
 
protected:
     validateColumnOptions(string cname, reference<hash> opt, bool nullable);
public:
 
 
 
    AbstractColumn dropColumn(string cname, *reference lsql);
 
 
 
    list<auto> getDropColumnSql(string cname, *hash<auto> opt);
 
 
 
    *hash<auto> insertCommit(hash<auto> row);
 
 
 
    *hash<auto> insertCommit(hash<auto> row, reference<string> sql);
 
 
 
    *hash<auto> insertCommit(hash<auto> row, hash<auto> opt);
 
 
 
    *hash<auto> insertCommit(hash<auto> row, reference<string> sql, hash<auto> opt);
 
 
 
    *hash<auto> insert(hash<auto> row);
 
 
 
    *hash<auto> insert(hash<auto> row, reference<string> sql);
 
 
 
    *hash<auto> insert(hash<auto> row, hash<auto> opt);
 
 
 
    *hash<auto> insert(hash<auto> row, reference<string> sql, hash<auto> opt);
 
 
 
    hash<SqlResultInfo> insertWithInfo(hash<auto> row, *hash<auto> opt);
 
 
      deprecated *hash<auto> insertNoCommit(hash<auto> row, *reference<string> sql, *hash<auto> opt);
 
      deprecated *hash<auto> insertNoCommit(hash<auto> row, hash<auto> opt);
 
    private *hash<auto> insertIntern(hash<auto> row, *reference<string> sql, *hash<auto> opt,
            *reference<softlist<auto>> args) {
        // check data callback options if any
        validateOptionsIntern("OPTION-ERROR", getInsertOptions(), \opt);
 
        // issue #3352: do not execute runtime DML while holding the lock
        {
            l.lock();
            on_exit l.unlock();
 
            getColumnsUnlocked();
        }
        sql = sprintf("insert into %s (", getSqlName());
        foreach string k in (keys row);
 
        hash vh = getPlaceholdersAndValues(row);
 
        sql += (foldl $1 + "," + $2, (map getColumnSqlName($1), keys row));
        sql += ") values (";
        sql += (foldl $1 + "," + $2, vh.placeholders);
        sql += ")";
 
        args = vh.values;
 
        // check for a bulk insert in case the driver does not support array binding
        if (!hasArrayBind());
 
 
        if (opt.returning)
            return doReturningImpl(opt, \sql, args);
 
        execData(opt, sql, args);
    }
 
protected:
     hash<auto> getPlaceholdersAndValues(hash<auto> row);
public:
 
 
 
    bool hasReturning();
 
 
 
    int insertFromSelectCommit(list cols, AbstractTable source, hash<auto> sh, reference<string> sql, hash<auto> opt);
 
 
    int insertFromSelectCommit(list cols, AbstractTable source);
 
 
    int insertFromSelectCommit(list cols, AbstractTable source, hash<auto> sh);
 
 
    int insertFromSelectCommit(list cols, AbstractTable source, hash<auto> sh, reference<string> sql);
 
 
    int insertFromSelectCommit(list cols, AbstractTable source, hash<auto> sh, hash<auto> opt);
 
 
 
    int insertFromSelect(list cols, AbstractTable source, hash<auto> sh, reference<string> sql, hash<auto> opt);
 
 
    int insertFromSelect(list cols, AbstractTable source);
 
 
    int insertFromSelect(list cols, AbstractTable source, hash<auto> sh);
 
 
    int insertFromSelect(list cols, AbstractTable source, hash<auto> sh, reference<string> sql);
 
 
    int insertFromSelect(list cols, AbstractTable source, hash<auto> sh, hash<auto> opt);
 
 
 
    hash<SqlResultInfo> insertFromSelectWithInfo(list<auto> cols, AbstractTable source, hash<auto> select_hash,
            *hash<auto> opt) {
        hash<SqlResultInfo> rv();
        rv.result = insertFromSelectIntern(cols, source, select_hash, \rv.sql, opt, \rv.args);
        return rv;
    }
 
    deprecated int insertFromSelectNoCommit(list cols, AbstractTable source, *hash<auto> sh, *reference<string> sql,
            *hash<auto> opt) {
        return insertFromSelectIntern(cols, source, sh, \sql, opt);
    }
 
    private int insertFromSelectIntern(list cols, AbstractTable source, *hash<auto> sh, *reference<string> sql,
            *hash<auto> opt, *reference<softlist<auto>> args) {
        string ssql = source.getSelectSql(sh, \args);
 
        // issue #3352: do not execute runtime DML while holding the lock
        {
            l.lock();
            on_exit l.unlock();
 
            getColumnsUnlocked();
        }
 
        sql = sprintf("insert into %s (", getSqlName());
 
        foreach string k in (cols);
 
 
        sql += (foldl $1 + "," + $2, getColumnSqlNames(cols));
        sql += ") " + ssql;
 
        return execData(opt, sql, args);
    }
 
 
    int insertFromIteratorCommit(Qore::AbstractIterator i, *hash<auto> opt);
 
 
 
    int insertFromIterator(Qore::AbstractIterator i, *hash<auto> opt);
 
 
      deprecated int insertFromIteratorNoCommit(Qore::AbstractIterator i, *hash<auto> opt);
 
protected:
     int insertFromIteratorIntern(Qore::AbstractIterator i, *hash<auto> opt);
public:
 
 
 
    int upsertCommit(hash<auto> row, int upsert_strategy = UpsertAuto, *hash<auto> opt);
 
 
 
    int upsert(hash<auto> row, int upsert_strategy = UpsertAuto, *hash<auto> opt);
 
 
      deprecated int upsertNoCommit(hash<auto> row, int upsert_strategy = UpsertAuto);
 
 
    code getUpsertClosure(hash<auto> row, int upsert_strategy = UpsertAuto, *hash<auto> opt);
 
 
 
    code getBulkUpsertClosure(hash<auto> example_row, int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt);
 
 
 
    code getUpsertClosureWithValidation(hash<auto> example_row, int upsert_strategy = UpsertAuto, *hash<auto> opt);
 
 
 
    *hash<string, int> upsertFromIteratorCommit(Qore::AbstractIterator i,
            int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt) {
        on_success ds.commit();
        on_error ds.rollback();
 
        return upsertFromIteratorIntern(i, upsert_strategy, opt);
    }
 
 
    *hash<string, int> upsertFromIterator(Qore::AbstractIterator i, int upsert_strategy = AbstractTable::UpsertAuto,
            *hash<auto> opt) {
        return upsertFromIteratorIntern(i, upsert_strategy, opt - "commit_block");
    }
 
    deprecated *hash<string, int> upsertFromIteratorNoCommit(Qore::AbstractIterator i,
            int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt) {
        return upsertFromIteratorIntern(i, upsert_strategy, opt - "commit_block");
    }
 
    private *hash<string, int> upsertFromIteratorIntern(Qore::AbstractIterator i,
            int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt) {
        // check upsert options
        validateOptionsIntern("OPTION-ERROR", getUpsertOptions(), \opt);
 
        // try to get initial row
        if (!i.next());
 
 
        // result hash
        hash<string, int> rh;
 
        // primary key value hash for "delete_others"
        hash<string, bool> pkh;
 
        hash<auto> row = i.getValue();
        code upsert = getUpsertClosure(row, upsert_strategy, opt);
 
        opt.change_count = 0;
        do {
            int code = upsert(row);
            ++rh{AbstractTable::UpsertResultMap{code}};
            if (opt.info_callback) {
                opt.info_callback(getSqlName(), row, code);
            }
 
            if (code != UR_Unchanged && opt.commit_block) {
                if (++opt.change_count >= opt.commit_block) {
                    ds.commit();
                    opt.change_count = 0;
                }
            }
 
            // save primary key value in primary key hash if "delete_others" is set
            if (opt.delete_others) {
                pkh{foldl $1 + "-" + $2, (map row.$1.toString(), primaryKey.keyIterator())} = True;
            }
        } while (i.next() && (row = i.getValue()));
 
        if (opt.delete_others);
 
 
        return rh;
    }
 
protected:
     *hash<string, int> doDeleteOthersIntern(hash<auto> pkh, *hash<auto> opt);
public:
 
 
 
    *hash<string, int> upsertFromSelectCommit(AbstractTable t, *hash<auto> sh,
            int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt) {
        on_success { ds.commit(); t.commit(); }
        on_error { ds.rollback(); t.rollback(); }
 
        return upsertFromSelect(t, sh, upsert_strategy, opt);
    }
 
    *hash<string, int> upsertFromSelectCommit(Table t, *hash<auto> sh,
            int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt) {
        on_success { ds.commit(); t.commit(); }
        on_error { ds.rollback(); t.rollback(); }
 
        return upsertFromIteratorIntern(t.getStatement(sh), upsert_strategy, opt);
    }
 
 
    *hash<string, int> upsertFromSelect(AbstractTable t, *hash<auto> sh,
            int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt) {
        return upsertFromIteratorIntern(t.getStatement(sh), upsert_strategy, opt - "commit_block");
    }
 
    deprecated *hash<string, int> upsertFromSelectNoCommit(AbstractTable t, *hash<auto> sh,
            int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt) {
        return upsertFromIteratorIntern(t.getStatement(sh), upsert_strategy, opt - "commit_block");
    }
 
    deprecated *hash<string, int> upsertFromSelect(Table t, *hash<auto> sh,
            int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt) {
        return upsertFromIteratorIntern(t.getStatement(sh), upsert_strategy, opt - "commit_block");
    }
 
    deprecated *hash<string, int> upsertFromSelectNoCommit(Table t, *hash<auto> sh,
            int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt) {
        return upsertFromIteratorIntern(t.getStatement(sh), upsert_strategy, opt - "commit_block");
    }
 
 
    softint rowCount();
 
 
 
    Qore::SQL::SQLStatement getRowIterator(*hash<auto> sh, *reference<string> sql, *hash<auto> opt);
 
 
 
    Qore::SQL::SQLStatement getRowIteratorNoExec(*hash<auto> sh, *reference<string> sql, *hash<auto> opt);
 
 
 
    Qore::SQL::SQLStatement getRowIterator(*hash<auto> sh, *hash<auto> opt);
 
 
 
    Qore::SQL::AbstractSQLStatement getStatement(*hash<auto> sh, *reference<string> sql, *hash<auto> opt);
 
 
 
    Qore::SQL::AbstractSQLStatement getStatement(*hash<auto> sh, *hash<auto> opt);
 
 
 
    hash<SqlResultInfo> getStatementWithInfo(*hash<auto> select_hash, *hash<auto> opt);
 
 
 
    Qore::SQL::AbstractSQLStatement getStatementNoExec(*hash<auto> sh, *reference<string> sql, *hash<auto> opt);
 
 
 
    hash<SqlResultInfo> getStatementNoExecWithInfo(*hash<auto> select_hash, *hash<auto> opt);
 
 
 
    Qore::SQL::AbstractSQLStatement getStatementNoExec(*hash<auto> sh, *hash<auto> opt);
 
 
    private Qore::SQL::AbstractSQLStatement getStatementIntern(*hash<auto> sh, *reference<string> sql,
            *hash<auto> opt, *bool no_exec, *reference<softlist<auto>> args) {
        validateOptionsIntern("OPTION-ERROR", getSelectOptions(), \sh);
 
        sql = getSelectSqlIntern(sh, \args, opt);
 
        AbstractSQLStatement stmt = ds.getSQLStatement();
        stmt.prepare(sql);
        if (no_exec);
 else {
            execData(stmt, opt, args);
        }
 
        return stmt;
    }
 
 
    *hash<auto> selectRow(*hash<auto> sh, *reference<string> sql, *hash<auto> opt);
 
 
    private *hash<auto> selectRowIntern(*hash<auto> sh, *reference<string> sql, *hash<auto> opt,
            *reference<softlist<auto>> args) {
        validateOptionsIntern("OPTION-ERROR", getSelectOptions(), \sh);
        // check data callback options if any
        validateOptionsIntern("OPTION-ERROR", getSqlDataCallbackOptions(), \opt);
 
        sql = getSelectSqlUnlocked(sh, \args, opt);
 
        if (opt.sqlarg_callback);
 
 
        bool rollback_on_error = False;
        if (sh.forupdate);
 
        on_error if (rollback_on_error)
            ds.rollback();
        return ds.vselectRow(sql, args);
    }
 
 
    hash<SqlResultInfo> selectRowWithInfo(*hash<auto> select_hash, *hash<auto> opt);
 
 
 
    *list<auto> selectRows(*hash<auto> sh, *reference<string> sql, *hash<auto> opt);
 
 
    private *list<auto> selectRowsIntern(*hash<auto> sh, *reference<string> sql, *hash<auto> opt,
            *reference<softlist<auto>> args) {
        validateOptionsIntern("OPTION-ERROR", getSelectOptions(), \sh);
        // check data callback options if any
        validateOptionsIntern("OPTION-ERROR", getSqlDataCallbackOptions(), \opt);
 
        sql = getSelectSqlUnlocked(sh, \args, opt);
 
        if (opt.sqlarg_callback)
            opt.sqlarg_callback(sql, args);
 
        bool rollback_on_error = False;
        if (sh.forupdate);
 
        on_error if (rollback_on_error)
            ds.rollback();
 
        return ds.vselectRows(sql, args);
    }
 
 
    hash<SqlResultInfo> selectRowsWithInfo(*hash<auto> select_hash, *hash<auto> opt);
 
 
 
    *hash<auto> select(*hash<auto> sh, *reference<string> sql, *hash<auto> opt);
 
 
protected:
     *hash<auto> selectIntern(*hash<auto> sh, *reference<string> sql, *hash<auto> opt, *reference<softlist<auto>> args);
public:
 
 
 
    hash<SqlResultInfo> selectWithInfo(*hash<auto> select_hash, *hash<auto> opt);
 
 
 
    *hash<auto> selectRow(*hash<auto> sh, *hash<auto> opt);
 
 
 
    *list<auto> selectRows(*hash<auto> sh, *hash<auto> opt);
 
 
 
    *hash<auto> select(*hash<auto> sh, *hash<auto> opt);
 
 
 
    string getSelectSql(*hash<auto> sh, *reference<list<auto>> args);
 
 
    *AbstractUniqueConstraint matchAnyUnique(softlist<auto> cols);
 
 
    string getSelectSqlIntern(*hash<auto> qh, reference<list<auto>> args, *hash<auto> opt);
 
 
    string getSelectSqlUnlocked(*hash<auto> qh, reference<list<auto>> args, *hash<auto> opt);
 
 
    // column & table information must be retrieved before calling this method
    string getSelectSqlUnlockedIntern(*hash<auto> qh, string from, reference<list<auto>> args,
            *hash<string, bool> subquery_column_map, *hash<auto> opt, *hash<auto> pseudo_column_map) {
        hash<QueryInfo> info = <QueryInfo>{
            "table": self,
            // make sure query_hash stays "hash<auto>"
            "query_hash": {} + qh,
            "subquery_column_map": subquery_column_map,
            "query_options": opt,
            "pseudo_column_map": pseudo_column_map ?? ({} + getPseudoColumnHash()),
            "expression_map": getExpressionMap(),
 
            # backwards-compatibility
            "where_operator_map": getWhereOperatorMap(),
            "column_operator_map": getColumnOperatorMap(),
            "args": args ?? (),
        };
        on_success args = info.args;
 
        if (exists info.query_hash.offset);
 
        // do not overwrite args; could be used in a subquery
        if (!exists args);
 
 
        // resolve any table names in joins first
        map info.query_hash.join{$1.key}.table = getSubtableFromString($1.value.table, opt),
            info.query_hash.join.pairIterator(), $1.value.table.typeCode() == NT_STRING;
 
        // make a hash of aliases to tables when using joins
        info.join_map = cast<hash<string, AbstractTable>>(
            map {$1.alias ?? $1.table.getName() : $1.table}, info.query_hash.join.iterator()
        );
 
        // issue #1909: add an alias for the main table if present
        if (info.query_hash.alias);
 
 
        // if we have a "superquery" argument, then we need to track which columns are in this subquery in
        // subquery_column_map
 
        string cstr;
        // make query
        list<auto> coll = ();
        if (info.query_hash.columns);
 else {
            cstr = "*";
        }
 
        string sql = sprintf("select %s from %s", cstr, getFromIntern(from, info.query_hash));
        if (info.query_hash.alias);
 
 
        // process join specifications
        foreach auto js in (info.query_hash.join.iterator());
 
 
        getSelectWhereSqlUnlocked(\info, \sql);
 
        if (info.query_hash.groupby);
 
 
        if (info.query_hash.having);
 
 
        if (info.query_hash.orderby);
 else if (info.query_hash.limit);
 
 
        //printf("SQL: %s\nargs: %y\n", sql, args);
 
        if (info.query_hash.forupdate && !info.query_hash.superquery);
 
 
        // issue #4206: splice comments and hints into the SQL query string last
        if (info.query_hash.comment || info.query_hash.hint);
 
 
        if (info.query_hash.superquery);
 
 
        return sql;
    }
 
    AbstractTable getSubtableFromString(string table, *hash<auto> opt);
 
 
    string getExpressionArg(reference<hash<QueryInfo>> info, int role, auto arg,
            AbstractDataProviderType expected_type) {
        if (arg instanceof hash<DataProviderFieldReference>);
 
        if (arg instanceof hash<DataProviderExpression>);
 
 
        info.args += arg;
        return "%v";
    }
 
protected:
     string getFromIntern(string from, *hash<auto> qh);
public:
 
 
protected:
     list<auto> getGroupByListUnlocked(hash<QueryInfo> info, list<auto> coll);
public:
 
 
protected:
     list<auto> getOrderByListUnlocked(hash<QueryInfo> info, list<auto> coll);
public:
 
 
protected:
     list<auto> getGroupOrderByListUnlocked(hash<QueryInfo> info, string key, list<auto> coll);
public:
 
 
protected:
     doForUpdate(reference<string> sql);
public:
 
 
protected:
     string getSelectSqlName(*hash<auto> qh);
public:
 
 
protected:
     string getColumnExpressionIntern(reference<hash<QueryInfo>> info, auto cvc);
public:
 
 
protected:
     string doColumnOperatorIntern(reference<hash<QueryInfo>> info, hash<auto> cvc);
public:
 
 
protected:
     string doColumnOperatorIntern(reference<hash<QueryInfo>> info, auto cop, auto arg, *string cve);
public:
 
 
protected:
     string getColumnNameIntern(hash<QueryInfo> info, string column_name);
public:
 
 
protected:
     bool asteriskRequiresPrefix();
public:
 
 
protected:
     getSelectWhereSqlUnlocked(reference<hash<QueryInfo>> info, reference<string> sql);
public:
 
 
    private *string getWhereClause(*hash<auto> cond, reference<list<auto>> args, *string cprefix,
            *hash<string, AbstractTable> join_map) {
        hash<QueryInfo> info = <QueryInfo>{
            "table": self,
            "query_hash": {
                "where": cond,
            },
            "args": args ?? (),
 
            "join_map": join_map,
            "pseudo_column_map": {} + getPseudoColumnHash(),
            "expression_map": getExpressionMap(),
 
            // backwards-compatibility
            "where_operator_map": getWhereOperatorMap(),
            "column_operator_map": getColumnOperatorMap(),
        };
        on_success args = info.args;
        l.lock();
        on_exit l.unlock();
        return getWhereClauseUnlocked(\info, info.query_hash."where", cprefix);
    }
 
    private *string getWhereExpressionUnlocked(reference<hash<QueryInfo>> info, hash<DataProviderExpression> cond,
            *string cprefix) {
        string sql = getExpressionUnlockedIntern(\info, ER_Search, cond, AbstractDataProviderTypeMap."bool");
        if (sql);
 
    }
 
    private *string getExpressionUnlockedIntern(reference<hash<QueryInfo>> info, int role,
            hash<DataProviderExpression> cond, AbstractDataProviderType expected_type) {
        *hash<auto> exp = info.expression_map{cond.exp};
        if (!exp);
 
 
        AbstractDataProvider::verifyExpression(role, exp.exp, LC_All, expected_type, cond);
        return exp.code(\info, role, cond.args);
    }
 
protected:
     *string getWhereClauseUnlocked(reference<hash<QueryInfo>> info, *hash<auto> cond, *string cprefix);
public:
 
 
protected:
     *list<string> getWhereClauseIntern(reference<hash<QueryInfo>> info, *hash<auto> cond, *string cprefix);
public:
 
 
protected:
     string doWhereExpressionIntern(reference<hash<QueryInfo>> info, string cn, auto we);
public:
 
 
    string getOrClause(reference<hash<QueryInfo>> info, list<auto> arglist);
 
 
    string getOrClause(reference<hash<QueryInfo>> info, hash<auto> arg);
 
 
protected:
     doSelectOrderBySqlUnlocked(hash<QueryInfo> info, reference<string> sql, list<auto> coll);
public:
 
 
 
    int delCommit(hash<auto> cond, reference<string> sql, hash<auto> opt);
 
 
    int delCommit(hash<auto> cond, hash<auto> opt);
 
 
    int delCommit(hash<auto> cond, reference<string> sql);
 
 
    int delCommit(hash<auto> cond);
 
 
    int delCommit();
 
 
 
    int del(hash<auto> cond, reference<string> sql, hash<auto> opt);
 
 
    int del(hash<auto> cond, hash<auto> opt);
 
 
    int del(hash<auto> cond, reference<string> sql);
 
 
    int del(hash<auto> cond);
 
 
    int del();
 
 
 
    hash<SqlResultInfo> delWithInfo(hash<auto> cond, *hash<auto> opt);
 
 
      deprecated int delNoCommit(*hash<auto> cond, *reference<string> sql);
 
protected:
     int delIntern(*hash<auto> cond, *reference<string> sql, *hash<auto> opt, *reference<softlist<auto>> args);
public:
 
 
 
    int updateCommit(hash<auto> set, hash<auto> cond, reference<string> sql, hash<auto> opt);
 
 
    int updateCommit(hash<auto> set, hash<auto> cond, reference<string> sql);
 
 
    int updateCommit(hash<auto> set, hash<auto> cond, hash<auto> opt);
 
 
    int updateCommit(hash<auto> set, hash<auto> cond);
 
 
    int updateCommit(hash<auto> set);
 
 
 
    int update(hash<auto> set, hash<auto> cond, reference<string> sql, hash<auto> opt);
 
 
    int update(hash<auto> set, hash<auto> cond, reference<string> sql);
 
 
    int update(hash<auto> set, hash<auto> cond, hash<auto> opt);
 
 
    int update(hash<auto> set, hash<auto> cond);
 
 
    int update(hash<auto> set);
 
 
 
    hash<SqlResultInfo> updateWithInfo(hash<auto> set, hash<auto> cond, *hash<auto> opt);
 
 
 
    hash<SqlCommandInfo> getUpdateSql(hash<auto> set, *hash<auto> cond);
 
 
      deprecated int updateNoCommit(hash<auto> set, *hash<auto> cond, *reference<string> sql);
 
      deprecated int updateNoCommit(hash<auto> set, *hash<auto> cond, *hash<auto> opt);
 
    private int updateIntern(hash<auto> set, *hash<auto> cond, *reference<string> sql, *hash<auto> opt,
            *reference<softlist<auto>> args) {
        hash<SqlCommandInfo> update_hash = getUpdateSql(set, cond);
        sql = update_hash.sql;
        args = update_hash.args;
        //printf("update_hash: %y\n", update_hash);
        return execData(opt, update_hash.sql, update_hash.args);
    }
 
protected:
     string getUpdateExpression(string col, hash<UpdateOperatorInfo> uh);
public:
 
 
protected:
     bool emptyDataIntern();
public:
 
 
protected:
     Columns checkUpsertRow(hash<auto> row, reference<int> upsert_strategy);
public:
 
 
protected:
     code getUpsertInsertFirst(Columns cols, hash<auto> example_row, *hash<auto> opt);
public:
 
 
protected:
     code getUpsertUpdateFirst(Columns cols, hash<auto> example_row, *hash<auto> opt);
public:
 
 
protected:
     code getUpsertSelectFirst(Columns cols, hash<auto> example_row, *hash<auto> opt);
public:
 
 
protected:
     code getUpsertInsertOnly(Columns cols, hash<auto> example_row, *hash<auto> opt);
public:
 
 
protected:
     code getUpsertUpdateOnly(Columns cols, hash<auto> example_row, *hash<auto> opt);
public:
 
 
protected:
     Columns getUpsertColumns(reference<string> csrc);
public:
 
 
 
protected:
     hash<string, Columns> getAllUpsertColumns(*hash<auto> row);
public:
 
 
protected:
     bool matchUniqueColumns(Columns cols, hash<auto> row);
public:
 
 
protected:
     string getUpsertSelectSql(hash<auto> row, Columns cols, reference<list<string>> updc);
public:
 
 
protected:
     string getUpsertInsertSql(hash<auto> row);
public:
 
 
protected:
     string getUpsertUpdateSql(hash<auto> row, Columns cols, reference updc, *hash<auto> opt);
public:
 
 
protected:
     softbool tryUpdate(string sql, hash<auto> row, Columns cols, list updc);
public:
 
 
protected:
     checkValue(string cname, string argname, reference val, string type);
public:
 
 
 
    string getSqlFromList(list<auto> l);
 
 
 
    string getSqlValue(auto v);
 
 
    string getName();
 
 
 
    cache(*hash<auto> opts);
 
 
 
    clear();
 
 
 
    hash<auto> getDescriptionHash();
 
 
 
    Columns describe();
 
 
 
    AbstractPrimaryKey getPrimaryKey();
 
 
 
    *AbstractUniqueConstraint findUniqueConstraint(string name);
 
 
    *AbstractUniqueConstraint findUniqueConstraintUnlocked(string name);
 
 
 
    Indexes getIndexes();
 
 
    ForeignConstraints getForeignConstraints(*hash<auto> opt);
 
 
    Constraints getConstraints();
 
 
 
    Triggers getTriggers();
 
 
 
    string getRenameSql(string new_name, *hash<auto> opt);
 
 
 
    string getCreateSqlString(*hash<auto> opt);
 
 
 
    list<auto> getCreateSql(*hash<auto> opt);
 
 
 
    string getCreateTableSql(*hash<auto> opt);
 
 
 
    bool checkExistence();
 
 
protected:
     *hash<string, bool> getCheckOmissionOptions(*softlist<softstring> ol, string err);
public:
 
 
 
    list<auto> getAlignSql(AbstractTable t, *hash<auto> opt);
 
 
protected:
     list<auto> getAlignSqlUnlocked(AbstractTable t, *hash<auto> opt);
public:
 
 
protected:
     *AbstractColumnSupportingConstraint getSupportingConstraint(string ixname);
public:
 
 
protected:
     *list<AbstractColumnConstraint> getAllSupportingConstraints(string ixname);
public:
 
 
protected:
     renameIndexUnlocked(AbstractIndex ix, string new_name);
public:
 
 
 
    string getAlignSqlString(AbstractTable t, *hash<auto> opt);
 
 
 
    *list<auto> getCreateIndexesSql(*hash<auto> opt, bool cache = True);
 
 
 
    *string getCreatePrimaryKeySql(*hash<auto> opt, bool cache = True);
 
 
 
    *list<auto> getCreateForeignConstraintsSql(*hash<auto> opt, bool cache = True);
 
 
 
    *list<auto> getCreateConstraintsSql(*hash<auto> opt, bool cache = True);
 
 
 
    *list<auto> getCreateMiscSql(*hash<auto> opt, bool cache = True);
 
 
 
    *list<auto> getCreateTriggersSql(*hash<auto> opt, bool cache = True);
 
 
 
    *hash find(auto id);
 
 
 
    *list find(list<auto> ids);
 
 
protected:
     string getPrimaryKeyColumn();
public:
 
 
 
    *hash<auto> find(hash<auto> row);
 
 
 
    *hash<auto> findSingle(*hash<auto> cond);
 
 
 
    *list<auto> findAll(*hash<auto> cond);
 
 
 
    string getDesc();
 
 
    string getBaseType();
 
 
    string getSqlName();
 
 
    string getColumnSqlName(string col);
 
 
    list<auto> getColumnSqlNames(softlist cols);
 
 
 
    bool bindEmptyStringsAsNull();
 
 
 
    *hash<string, AbstractDataField> getRecordType();
 
 
 
    AbstractDataField getColumnDataField(string column_name, *hash<auto> options, *string append_desc);
 
 
 
    AbstractDataField getColumnDataField(AbstractColumn column, *hash<SqlUtilDataTypeOptionInfo> options, *string append_desc);
 
 
 
    AbstractDataProviderType getColumnDataType(string column_name, *hash<SqlUtilDataTypeOptionInfo> options);
 
 
 
    AbstractDataProviderType getDbType(AbstractColumn column, *hash<SqlUtilDataTypeOptionInfo> options);
 
 
 
    AbstractDataProviderType getDbType(string native_type, *string qore_type, bool nullable, int max_size = -1,
            *hash<SqlUtilDataTypeOptionInfo> options) {
        hash<auto> type_options;
        if (nullable && options.mandatory);
 
        if (nullable && native_type[0] != '*');
 
        if (options.maxlen && (max_size < 0 || max_size > options.maxlen));
 
        if (!qore_type);
 
        switch (qore_type);
 
    }
 
 
    AbstractDataProviderType getNumericType(string type_name, bool nullable, *hash<auto> options);
 
 
 
    AbstractSavepointHelper getSavepointHelper(*string savepoint);
 
 
 
    hash<auto> getExpressionMap();
 
 
 
    hash<auto> getWhereOperatorMap();
 
 
    abstract bool hasArrayBind();
 
 
protected:
     hash<auto> getTableOptions();
public:
 
 
 
protected:
     hash<auto> getForeignConstraintOptions();
public:
 
 
 
protected:
     hash<auto> getConstraintOptions();
public:
 
 
 
protected:
     hash<auto> getCacheOptions();
public:
 
 
 
protected:
     hash<auto> getTableCreationOptions();
public:
 
 
 
protected:
     hash<auto> getAlignTableOptions();
public:
 
 
 
protected:
     hash<auto> getTableDescriptionHashOptions();
public:
 
 
 
protected:
     hash<auto> getColumnOptions();
public:
 
 
 
protected:
     hash<auto> getColumnDescOptions();
public:
 
 
 
protected:
     hash<auto> getTableColumnDescOptions();
public:
 
 
 
protected:
     hash<auto> getIndexOptions();
public:
 
 
 
protected:
     hash<auto> getTriggerOptions();
public:
 
 
 
protected:
     hash<auto> getSelectOptions();
public:
 
 
 
protected:
     hash<auto> getUpsertOptions();
public:
 
 
 
protected:
     hash<auto> getInsertOptions();
public:
 
 
 
protected:
     hash<auto> getInsertFromIteratorOptions();
public:
 
 
 
protected:
     hash<auto> getSqlDataCallbackOptions();
public:
 
 
 
protected:
     hash<auto> getColumnOperatorMap();
public:
 
 
protected:
     *hash<auto> getColumnOperatorMapImpl();
public:
 
 
 
    addCustomCopOperator(string name, hash<auto> operator);
 
 
 
    bool isDuplicateRowError(hash<ExceptionInfo> ex);
 
 
 
protected:
     hash<auto> getInsertOperatorMap();
public:
 
 
 
protected:
     hash<auto> getUpdateOperatorMap();
public:
 
 
 
protected:
     hash<auto> getRawUpdateOperatorMap();
public:
 
 
 
protected:
     *hash<auto> getPseudoColumnHash();
public:
 
 
protected:
     string getCreateTableSqlUnlocked(*hash<auto> opt);
public:
 
 
protected:
     *list<auto> getCreateIndexesSqlUnlocked(*hash<auto> opt, bool cache = True);
public:
 
 
protected:
     *string getCreatePrimaryKeySqlUnlocked(*hash<auto> opt, bool cache = True);
public:
 
 
protected:
     *list<auto> getCreateConstraintsSqlUnlocked(*hash<auto> opt, bool cache = True);
public:
 
 
protected:
     *list<auto> getCreateForeignConstraintsSqlUnlocked(*hash<auto> opt, bool cache = True);
public:
 
 
protected:
     *list<auto> getCreateMiscSqlUnlocked(*hash<auto> opt, bool cache = True);
public:
 
 
protected:
     *list<auto> getCreateTriggersSqlUnlocked(*hash<auto> opt, bool cache = True);
public:
 
 
protected:
     list<auto> getCreateSqlUnlocked(*hash<auto> opt, bool cache = True);
public:
 
 
protected:
     cacheUnlocked(*hash<auto> opt);
public:
 
 
protected:
     auto execData(*hash<auto> opt, string sql, *list<auto> args);
public:
 
 
protected:
     execData(AbstractSQLStatement stmt, *hash<auto> opt, *list<auto> args);
public:
 
 
      static AbstractTable getTable(AbstractDatasource nds, string nname, *hash<auto> opts);
 
      static AbstractTable getTable(string dsstr, string nname, *hash<auto> opts);
 
      static AbstractTable getTable(hash<auto> dsh, string nname, *hash<auto> opts);
 
protected:
     getColumnsUnlocked();
public:
 
 
protected:
     getPrimaryKeyUnlocked();
public:
 
 
    // also loads primary key and constraints (for unique constraints)
protected:
     getIndexesUnlocked();
public:
 
 
protected:
     getForeignConstraintsUnlocked(*hash<auto> opt);
public:
 
 
protected:
     addSourceConstraint(string table_name, AbstractForeignConstraint fk);
public:
 
 
protected:
     getConstraintsUnlocked();
public:
 
 
protected:
     getTriggersUnlocked();
public:
 
 
protected:
     bool hasReturningImpl();
public:
 
 
protected:
     softlist<auto> getDropSqlImpl();
public:
 
 
protected:
     string getTruncateSqlImpl();
public:
 
 
protected:
     auto tryExecArgsImpl(string sql, *softlist<auto> args);
public:
 
 
protected:
     auto tryExecRawImpl(string sql);
public:
 
 
protected:
     clearImpl();
public:
 
 
protected:
     preSetupTableImpl(reference desc, *hash<auto> opt);
public:
 
 
 
protected:
     abstract AbstractDataProviderType getNumericTypeImpl(string type_name, bool nullable, *hash<auto> options);
public:
 
protected:
     abstract *hash<auto> doReturningImpl(hash<auto> opt, reference<string> sql, list<auto> args);
public:
 
protected:
     abstract bool emptyImpl();
public:
 
protected:
     abstract *string getSqlValueImpl(auto v);
public:
 
 
protected:
     abstract bool checkExistenceImpl();
public:
 
protected:
     abstract bool supportsTablespacesImpl();
public:
 
protected:
     abstract bool constraintsLinkedToIndexesImpl();
public:
 
protected:
     abstract bool uniqueIndexCreatesConstraintImpl();
public:
 
protected:
     abstract setupTableImpl(hash<auto> desc, *hash<auto> opt);
public:
 
protected:
     abstract Columns describeImpl();
public:
protected:
     abstract AbstractPrimaryKey getPrimaryKeyImpl();
public:
protected:
     abstract Indexes getIndexesImpl();
public:
protected:
     abstract ForeignConstraints getForeignConstraintsImpl(*hash<auto> opt);
public:
protected:
     abstract Constraints getConstraintsImpl();
public:
protected:
     abstract Triggers getTriggersImpl();
public:
 
protected:
     abstract string getCreateTableSqlImpl(*hash<auto> opt);
public:
protected:
     abstract *list<auto> getCreateMiscSqlImpl(*hash<auto> opt, bool cache);
public:
protected:
     abstract string getCreateSqlImpl(list<auto> l);
public:
protected:
     abstract string getRenameSqlImpl(string new_name);
public:
protected:
     abstract *list<auto> getAlignSqlImpl(AbstractTable t, *hash<auto> opt);
public:
 
protected:
     abstract AbstractColumn addColumnImpl(string cname, hash<auto> opt, bool nullable = True);
public:
protected:
     abstract AbstractPrimaryKey addPrimaryKeyImpl(string cname, hash<auto> ch, *hash<auto> opt);
public:
protected:
     abstract AbstractIndex addIndexImpl(string iname, bool enabled, hash<auto> ch, *hash<auto> opt);
public:
protected:
     abstract AbstractForeignConstraint addForeignConstraintImpl(string cname, hash<auto> ch, string table, hash<auto> tch, *hash<auto> opt);
public:
protected:
     abstract AbstractCheckConstraint addCheckConstraintImpl(string cname, string src, *hash<auto> opt);
public:
protected:
     abstract AbstractUniqueConstraint addUniqueConstraintImpl(string cname, hash<auto> ch, *hash<auto> opt);
public:
 
protected:
     abstract AbstractTrigger addTriggerImpl(string tname, string src, *hash<auto> opt);
public:
 
protected:
     abstract bool tryInsertImpl(string sql, hash<auto> row);
public:
 
protected:
     abstract hash<auto> getQoreTypeMapImpl();
public:
 
protected:
     abstract hash<auto> getTypeMapImpl();
public:
 
    private abstract doSelectOrderByWithOffsetSqlUnlockedImpl(reference<hash<QueryInfo>> info, reference<string> sql,
        list<auto> coll);
 
protected:
     abstract doSelectLimitOnlyUnlockedImpl(reference<hash<QueryInfo>> info, reference<string> sql);
public:
 
protected:
     abstract copyImpl(AbstractTable old);
public:
 
 
protected:
     abstract AbstractSavepointHelper getSavepointHelperImpl(*string savepoint);
public:
 
 
protected:
     abstract bool isDuplicateRowErrorImpl(hash<ExceptionInfo> ex);
public:
};
};