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);
 
 
protected:
     AbstractColumn addColumnUnlocked(string cname, hash<auto> opt, bool nullable = True, *reference lsql, bool do_exec = True, bool modify_table = True);
public:
 
 
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);
 
protected:
     *hash<auto> insertIntern(hash<auto> row, *reference<string> sql, *hash<auto> opt, *reference<softlist<auto>> args);
public:
 
 
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);
 
 
      deprecated int insertFromSelectNoCommit(list cols, AbstractTable source, *hash<auto> sh, *reference<string> sql, *hash<auto> opt);
 
protected:
     int insertFromSelectIntern(list cols, AbstractTable source, *hash<auto> sh, *reference<string> sql, *hash<auto> opt, *reference<softlist<auto>> args);
public:
 
 
 
    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);
 
 
 
    *hash<string, int> upsertFromIterator(Qore::AbstractIterator i, int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt);
 
 
      deprecated *hash<string, int> upsertFromIteratorNoCommit(Qore::AbstractIterator i, int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt);
 
protected:
     *hash<string, int> upsertFromIteratorIntern(Qore::AbstractIterator i, int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt);
public:
 
 
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);
 
 
    *hash<string, int> upsertFromSelectCommit(Table t, *hash<auto> sh, int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt);
 
 
 
    *hash<string, int> upsertFromSelect(AbstractTable t, *hash<auto> sh, int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt);
 
 
      deprecated *hash<string, int> upsertFromSelectNoCommit(AbstractTable t, *hash<auto> sh, int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt);
 
      deprecated *hash<string, int> upsertFromSelect(Table t, *hash<auto> sh, int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt);
 
      deprecated *hash<string, int> upsertFromSelectNoCommit(Table t, *hash<auto> sh, int upsert_strategy = AbstractTable::UpsertAuto, *hash<auto> opt);
 
 
    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);
 
 
protected:
     Qore::SQL::AbstractSQLStatement getStatementIntern(*hash<auto> sh, *reference<string> sql, *hash<auto> opt, *bool no_exec, *reference<softlist<auto>> args);
public:
 
 
 
    *hash<auto> selectRow(*hash<auto> sh, *reference<string> sql, *hash<auto> opt);
 
 
protected:
     *hash<auto> selectRowIntern(*hash<auto> sh, *reference<string> sql, *hash<auto> opt, *reference<softlist<auto>> args);
public:
 
 
 
    hash<SqlResultInfo> selectRowWithInfo(*hash<auto> select_hash, *hash<auto> opt);
 
 
 
    *list<auto> selectRows(*hash<auto> sh, *reference<string> sql, *hash<auto> opt);
 
 
protected:
     *list<auto> selectRowsIntern(*hash<auto> sh, *reference<string> sql, *hash<auto> opt, *reference<softlist<auto>> args);
public:
 
 
 
    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);
 
 
    AbstractTable getSubtableFromString(string table, *hash<auto> opt);
 
 
    string getExpressionArg(reference<hash<QueryInfo>> info, int role, auto arg, AbstractDataProviderType expected_type);
 
 
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:
 
 
protected:
     *string getWhereClause(*hash<auto> cond, reference<list<auto>> args, *string cprefix, *hash<string, AbstractTable> join_map);
public:
 
 
protected:
     *string getWhereExpressionUnlocked(reference<hash<QueryInfo>> info, hash<DataProviderExpression> cond, *string cprefix);
public:
 
 
protected:
     *string getExpressionUnlockedIntern(reference<hash<QueryInfo>> info, int role, hash<DataProviderExpression> cond, AbstractDataProviderType expected_type);
public:
 
 
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);
 
protected:
     int updateIntern(hash<auto> set, *hash<auto> cond, *reference<string> sql, *hash<auto> opt, *reference<softlist<auto>> args);
public:
 
 
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);
 
 
 
    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:
 
protected:
     abstract doSelectOrderByWithOffsetSqlUnlockedImpl(reference<hash<QueryInfo>> info, reference<string> sql, list<auto> coll);
public:
 
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:
};
};