MysqlSqlUtil.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
/*  MysqlSqlUtil.qm Copyright 2013 - 2022 Qore Technologies, s.r.o.
 
    Permission is hereby granted, free of charge, to any person obtaining a
    copy of this software and associated documentation files (the "Software"),
    to deal in the Software without restriction, including without limitation
    the rights to use, copy, modify, merge, publish, distribute, sublicense,
    and/or sell copies of the Software, and to permit persons to whom the
    Software is furnished to do so, subject to the following conditions:
 
    The above copyright notice and this permission notice shall be included in
    all copies or substantial portions of the Software.
 
    THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
    IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
    FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
    AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
    LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
    FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
    DEALINGS IN THE SOFTWARE.
*/
 
// minimum required Qore version
 
// requires the SqlUtil module
 
// don't use "$" signs for variables and class members, assume local variable scope
 
// require type definitions everywhere
 
// enable all warnings
 
 
namespace MysqlSqlUtil {
     MysqlTable get_table(AbstractDatasource nds, string nname, *hash opts);
 
 
     MysqlDatabase get_database(AbstractDatasource nds, *hash opts);
 
 
    parse_schema_name(string nname, reference<*string> schema, reference<string> name);
 
 
class MysqlSavepointHelper : public AbstractSavepointHelper {
 
public:
        constructor(AbstractDatasource ds, *string savepoint) ;
 
 
protected:
         createSavepointImpl();
public:
 
 
protected:
         rollbackImpl();
public:
 
 
protected:
         deleteSavepointImpl();
public:
 
    };
 
class MysqlNumberDataType : public SqlUtil::AbstractNumericDataType {
 
public:
        constructor(string native_type, bool nullable, *hash<auto> options)
 ;
 
    };
 
class MysqlIndex : public SqlUtil::AbstractIndex {
 
public:
            string type;
 
        constructor(string n_name, bool n_unique, hash n_cols, string n_type = 'BTREE') ;
 
 
        string getCreateSql(string table_name, *hash opt);
 
 
protected:
         bool equalImpl(AbstractIndex ix);
public:
 
 
        string getRenameSql(string table_name, string new_name);
 
 
        string getDropSql(string table_name);
 
    };
 
class MysqlForeignConstraint : public SqlUtil::AbstractForeignConstraint {
 
public:
        constructor(string n, Columns c, ForeignConstraintTarget t) ;
 
 
        string getCreateSql(string table_name, *hash opt);
 
 
        softlist getRenameSql(string table_name, string new_name);
 
 
        string getCreateSql(string name, string table_name, *hash opt);
 
 
        string getAddSql(string name, string table_name, *hash opt);
 
 
        string getDropSql(string table_name);
 
    };
 
class MysqlColumn : public SqlUtil::AbstractColumn {
 
public:
            int byte_size;
 
protected:
         constructor();
public:
 
 
        constructor(string n, string nt, *string qt, int sz, bool nul, *string dv, *string cm, *softint bs,
                *int scale) ;
 
 
 
        softlist<string> getAddColumnSql(AbstractTable t);
 
 
        string getCreateSql(AbstractTable t);
 
 
 
        softlist<string> getModifySqlImpl(AbstractTable t, AbstractColumn col, *hash opt);
 
 
 
        string getRenameSql(AbstractTable t, string new_name);
 
 
 
        string getDdlName(string name);
 
 
protected:
         bool equalImpl(AbstractColumn c);
public:
 
    };
 
class MysqlNumericColumn : public MysqlColumn {
 
public:
            bool unsigned;
            bool auto_increment;
            // auto-incrememnt columns must be either "unique" or "primary key" in mysql
            bool pk = False;
 
protected:
            // AUTO_INCREMENT applies only to integer and floating-point types
            const AUTO_INCREMENT_VALID_TYPES = {
                // int types
                "tinyint": True,
                "smallint": True,
                "mediumint": True,
                "int": True,
                "bigint": True,
                # float types
                "float": True,
                "real": True,
                "double precision": True,
            };
 
public:
 
        constructor(string n, string nt, *string qt, int sz, bool nul, *string dv, *string cm, softint bs,
                softint scale, bool n_unsigned = False, bool n_auto_increment = False, bool n_pk = False)
 ;
 
 
private:
         deserializeMembers(hash<auto> members);
public:
 
 
protected:
         validateConstructor();
public:
 
 
        string getNativeTypeString();
 
 
protected:
         bool equalImpl(AbstractColumn c);
public:
 
    };
 
class MysqlUniqueConstraintCommon : public SqlUtil::AbstractUniqueConstraint {
 
public:
        constructor();
 
 
        bool setIndexBase(string ix);
 
 
        clearIndex();
 
 
        getIndexSql(reference<string> sql, string name, *hash opts);
 
    };
 
class MysqlUniqueConstraint : public SqlUtil::AbstractUniqueConstraint,public  MysqlUniqueConstraintCommon {
 
public:
        constructor(string n, hash n_cols) ;
 
 
 
        MysqlColumn memberGate(string k);
 
 
        string getCreateSql(string table_name, *hash opts);
 
 
        list getRenameSql(string table_name, string new_name);
 
 
        string getCreateSql(string name, string table_name, *hash opts);
 
 
        string getDropSql(string table_name);
 
    };
 
class MysqlPrimaryKey : public SqlUtil::AbstractPrimaryKey,public  MysqlUniqueConstraintCommon {
 
public:
        constructor();
 
 
        constructor(*hash c) ;
 
 
 
        MysqlColumn memberGate(string k);
 
 
        string getCreateSql(string table_name, *hash opts);
 
 
        softlist getRenameSql(string table_name, string new_name);
 
 
        string getDropSql(string table_name);
 
 
        bool supportsName();
 
    };
 
class MysqlTrigger : public SqlUtil::AbstractTrigger {
 
public:
        constructor(string n, string n_src) ;
 
 
        softlist getCreateSql(string table_name, *hash opt);
 
 
        softlist getDropSql(string table_name);
 
 
protected:
         bool equalImpl(AbstractFunctionBase t);
public:
 
 
        softlist getRenameSql(string table_name, string new_name);
 
    };
 
class MysqlFunction : public SqlUtil::AbstractFunction {
 
public:
        constructor(string n, string n_src) ;
 
 
        softlist getCreateSql(*hash opt);
 
 
 
        string getDropSql(*hash opt);
 
 
protected:
         bool equalImpl(AbstractFunctionBase t);
public:
 
 
 
        softlist getRenameSql(string new_name, *hash opt);
 
    };
 
class MysqlSequence : public SqlUtil::AbstractSequence {
 
public:
protected:
            string table_name;
 
public:
 
        constructor(string n_table_name, string n_name, number n_start = 1, number n_increment = 1, *softnumber n_end) ;
 
 
        string getCreateSql(*hash opt);
 
 
 
        softlist getRenameSql(string new_name, *hash opt);
 
 
 
        string getDropSql(*hash opt);
 
    };
 
class MysqlView : public SqlUtil::AbstractView {
 
public:
            *string tablecatalog;
            *string checkoption;
            *string definer;
            *string securitytype;
 
        constructor(string n_name, string n_src, *string n_tablecatalog,
                    *string n_schema,
                    *string n_checkoption, *string n_definer,
                    *string n_securitytype, bool n_updatable)
 ;
 
 
        string getCreateSql(*hash opt);
 
 
 
        softlist getRenameSql(string new_name, *hash opt);
 
    };
 
class MysqlDatabase : public SqlUtil::AbstractDatabase {
 
public:
            const MysqlOptions = ...;
 
 
            const MysqlSchemaDescriptionOptions = AbstractDatabase::SchemaDescriptionOptions + MysqlOptions;
 
            const MysqlDatabaseOptions = AbstractDatabase::DatabaseOptions + MysqlOptions;
 
            const MysqlSequenceTable = ...;
 
 
            const MysqlSequenceFunction = "%s(seq_name varchar(40)) returns decimal(14)
begin
  update %s set id = last_insert_id(id + 1) where name = seq_name;
  return last_insert_id();
end";
 
            const MysqlComputeStatisticsOptions = ...;
 
 
            const MysqlReclaimSpaceOptions = ...;
 
 
            const MysqlReservedWords = ...;
 
 
            const MysqlMaxPrecision = 65;
 
protected:
            string schema;
 
            Datasource seqds;
 
            string sequence_table = "sqlutil_sequences";
            string sequence_function = "sqlutil_nextval";
 
public:
 
        constructor(AbstractDatasource nds, *hash opts) ;
 
 
 
        bool requiresScale();
 
 
 
        int getMaximumPrecision();
 
 
protected:
         list<string> featuresImpl();
public:
 
 
        string getSchemaName();
 
 
protected:
         AbstractSequence makeSequenceImpl(string name, number start = 1, number increment = 1, *softnumber end, *hash opts);
public:
 
 
protected:
         *AbstractSequence getSequenceImpl(string name);
public:
 
 
protected:
         *AbstractView getViewImpl(string name);
public:
 
 
protected:
         MysqlFunction makeFunctionImpl(string name, string src, *hash opts);
public:
 
 
protected:
         MysqlFunction makeProcedureImpl(string name, string src, *hash opts);
public:
 
 
protected:
         *AbstractFunction getFunctionImpl(string name);
public:
 
 
protected:
          static string makeParameter(hash<auto> row);
public:
 
 
protected:
         AbstractFunction getProcedureImpl(string name);
public:
 
 
protected:
         list getDropSchemaSqlImpl(hash schema_hash, *hash opt);
public:
 
 
protected:
         list getAlignSqlImpl(hash schema_hash, *hash opt);
public:
 
 
protected:
         list<string> listTablesImpl();
public:
 
 
 
protected:
         list<string> listFunctionsImpl();
public:
 
 
 
protected:
         list<string> listProceduresImpl();
public:
 
 
protected:
         list<string> listSequencesImpl();
public:
 
 
protected:
         list<string> listViewsImpl();
public:
 
 
protected:
         string getCreateSqlImpl(list l);
public:
 
 
          static string getCreateSql(list l);
 
protected:
         hash getDatabaseOptions();
public:
 
 
protected:
         hash getSchemaDescriptionOptions();
public:
 
 
protected:
         hash getComputeStatisticsOptions();
public:
 
 
protected:
         hash getReclaimSpaceOptions();
public:
 
 
protected:
         softint getNextSequenceValueImpl(string name);
public:
 
 
protected:
         softint getCurrentSequenceValueImpl(string name);
public:
 
 
protected:
         bool supportsSequencesImpl();
public:
 
 
protected:
         bool supportsTypesImpl();
public:
 
 
protected:
         bool supportsPackagesImpl();
public:
 
 
protected:
         bool rebuildIndexImpl(string name, *hash options);
public:
 
 
protected:
         computeStatisticsImpl(*hash options);
public:
 
 
protected:
         reclaimSpaceImpl(*hash options);
public:
 
 
protected:
         int getPhysicalSizeImpl();
public:
 
    };
 
class MysqlTable : public SqlUtil::AbstractTable {
 
public:
            const MysqlTypeMap = {
                "decimal": {
                    "qore": Type::Number,
                    "size": SZ_NUM,
                },
                "tinyint": ("qore": Type::Int, "ai": True,),
                "smallint": ("qore": Type::Int, "ai": True,),
                "mediumint": ("qore": Type::Int, "ai": True,),
                "int": ("qore": Type::Int, "ai": True,),
                "bigint": ("qore": Type::Int, "ai": True,),
                "float": ("qore": Type::Float, "ai": True,),
                "double": ("qore": Type::Float, "ai": True,),
 
                "date": ("qore": Type::Date,),
                "datetime": ("qore": Type::Date,),
                "timestamp": ("qore": Type::Date, "size": SZ_OPT, "size_range": (0, 6), "default_size": 6,),
                "time": ("qore": Type::Date, "size": SZ_OPT, "size_range": (0, 6), "default_size": 6,),
                "year": ("qore": Type::Int,),
 
                "char": {
                    "qore": Type::String,
                    "size": SZ_OPT,
                    "size_range": (0, 255),
                },
                "varchar": {
                    "qore": Type::String,
                    "size": SZ_MAND,
                    "size_range": (0, 65535),
                    "default_size": AbstractColumn::DefaultVarcharSize,
                },
 
                "binary": ("qore": Type::Binary, "size": SZ_OPT, "size_range": (0, 255)),
                "varbinary": {
                    "qore": Type::Binary,
                    "size": SZ_MAND,
                    "size_range": (0, 65535),
                    "default_size": 80,
                },
 
                "tinytext": ("qore": Type::String,),
                "text": ("qore": Type::String,),
                "mediumtext": ("qore": Type::String,),
                "longtext": ("qore": Type::String,),
 
                "tinyblob": ("qore": Type::Binary,),
                "blob": ("qore": Type::Binary,),
                "mediumblob": ("qore": Type::Binary,),
                "longblob": ("qore": Type::Binary,),
 
                "bit": ("qore": Type::Int,),
            };
 
            const QoreTypeMap = ...;
 
 
 
            const MysqlTableDescriptionHashOptions = ...;
 
 
 
            const MysqlColumnDescOptions = ...;
 
 
            const MysqlIndexOptions = AbstractTable::IndexOptions;
 
            const MysqlConstraintOptions = ...;
 
 
            const MysqlTableCreationOptions = AbstractTable::TableCreationOptions + MysqlConstraintOptions;
 
            const MysqlAlignTableOptions = AbstractTable::AlignTableOptions + MysqlTableCreationOptions;
 
            const MysqlCopMap = ...;
 
 
            const MysqlExpressionMap = DefaultExpressionMap + {
                COP_CAST: {
                    "exp": <DataProviderExpressionInfo>{
                        "type": DET_Operator,
                        "label": COP_CAST,
                        "name": "cast",
                        "desc": "cast operator",
                        "symbol": "cast",
                        "args": (
                            DataProviderSignatureAnyType,
                            DataProviderSignatureStringValueType,
                            DataProviderSignatureOptionalIntValueType,
                            DataProviderSignatureOptionalIntValueType),
                        "varargs": True,
                        "return_type": AbstractDataProviderTypeMap."any",
                    },
                    "code": string sub (reference<hash<QueryInfo>> info, int role, list<auto> args) {
                        string exp0 = info.table.getExpressionArg(\info, role, args[0],
                            AbstractDataProviderTypeMap."any");
                        string name = QoreTypeMap{args[1]} ?? args[1];
                        *hash<auto> desc = MysqlTypeMap{name};
                        string sql = sprintf ("cast (%s as %s", exp0, name);
                        if (desc.size == SZ_MAND) {
                            if (!exists args[1] && !exists desc.size_range)
                                throw "OPERATOR-ERROR", sprintf ("cast operator missing size for type %s",
                                    name);
                            sql += sprintf("(%d)", args[1] ?? desc.size_range[1]);
                        } else if (desc.size == SZ_NUM && exists args[1]) {
                            sql += sprintf("(%d", args[1]);
                            sql += exists args[2] ? sprintf(",%d)", args[2]) : ")";
                        } else if (desc.size == SZ_OPT && exists args[1]) {
                            sql += sprintf("(%d)", args[1]);
                        }
                        sql += ")";
                        return sql;
                    },
                },
                COP_PREPEND: DefaultExpressionMap{COP_PREPEND} + {
                    "code": string sub (reference<hash<QueryInfo>> info, int role, list<auto> args) {
                        string exp0 = info.table.getExpressionArg(\info, role, args[0],
                            AbstractDataProviderTypeMap."string");
                        string exp1 = info.table.getExpressionArg(\info, role, args[1],
                            AbstractDataProviderTypeMap."string");
                        return sprintf("concat(%s, %s)", exp1, exp0);
                    },
                },
                COP_APPEND: DefaultExpressionMap{COP_APPEND} + {
                    "code": string sub (reference<hash<QueryInfo>> info, int role, list<auto> args) {
                        string exp0 = info.table.getExpressionArg(\info, role, args[0],
                            AbstractDataProviderTypeMap."string");
                        string exp1 = info.table.getExpressionArg(\info, role, args[1],
                            AbstractDataProviderTypeMap."string");
                        return sprintf("concat(%s, %s)", exp0, exp1);
                    },
                },
                COP_YEAR: {
                    "exp": <DataProviderExpressionInfo>{
                        "type": DET_Operator,
                        "label": COP_YEAR,
                        "name": COP_YEAR,
                        "desc": "returns the year component of a date as a string (ex: `2022`)",
                        "symbol": COP_YEAR,
                        "args": (
                            DataProviderSignatureDateType,
                        ),
                        "return_type": AbstractDataProviderTypeMap."string",
                    },
                    "code": string sub (reference<hash<QueryInfo>> info, int role, list<auto> args) {
                        string exp0 = info.table.getExpressionArg(\info, role, args[0],
                            AbstractDataProviderTypeMap."date");
                        return sprintf("date_format(%s, '%%Y')", exp0);
                    }
                },
                COP_YEAR_MONTH: {
                    "exp": <DataProviderExpressionInfo>{
                        "type": DET_Operator,
                        "label": COP_YEAR_MONTH,
                        "name": COP_YEAR_MONTH,
                        "desc": "returns the year and month components of a date as a string (ex: `2022-06`)",
                        "symbol": COP_YEAR_MONTH,
                        "args": (
                            DataProviderSignatureDateType,
                        ),
                        "return_type": AbstractDataProviderTypeMap."string",
                    },
                    "code": string sub (reference<hash<QueryInfo>> info, int role, list<auto> args) {
                        string exp0 = info.table.getExpressionArg(\info, role, args[0],
                            AbstractDataProviderTypeMap."date");
                        return sprintf("date_format(%s, '%%Y-%%m')", exp0);
                    }
                },
                COP_YEAR_DAY: {
                    "exp": <DataProviderExpressionInfo>{
                        "type": DET_Operator,
                        "label": COP_YEAR_DAY,
                        "name": COP_YEAR_DAY,
                        "desc": "returns the year, month, and day components of a date as a string (ex: `2022-06-29`)",
                        "symbol": COP_YEAR_DAY,
                        "args": (
                            DataProviderSignatureDateType,
                        ),
                        "return_type": AbstractDataProviderTypeMap."string",
                    },
                    "code": string sub (reference<hash<QueryInfo>> info, int role, list<auto> args) {
                        string exp0 = info.table.getExpressionArg(\info, role, args[0],
                            AbstractDataProviderTypeMap."date");
                        return sprintf("date_format(%s, '%%Y-%%m-%%e')", exp0);
                    }
                },
                COP_YEAR_HOUR: {
                    "exp": <DataProviderExpressionInfo>{
                        "type": DET_Operator,
                        "label": COP_YEAR_HOUR,
                        "name": COP_YEAR_HOUR,
                        "desc": "returns the year, month, day, and hour components of a date as a string "
                            "(ex: `2022-06-29 15`)",
                        "symbol": COP_YEAR_HOUR,
                        "args": (
                            DataProviderSignatureDateType,
                        ),
                        "return_type": AbstractDataProviderTypeMap."string",
                    },
                    "code": string sub (reference<hash<QueryInfo>> info, int role, list<auto> args) {
                        string exp0 = info.table.getExpressionArg(\info, role, args[0],
                            AbstractDataProviderTypeMap."date");
                        return sprintf("date_format(%s, '%%Y-%%m-%%e %%k')", exp0);
                    }
                },
                COP_TRUNC_DATE: {
                    "exp": <DataProviderExpressionInfo>{
                        "type": DET_Operator,
                        "label": COP_TRUNC_DATE,
                        "name": COP_TRUNC_DATE,
                        "desc": "truncates the given date to the given resolution; args: date, string code: Y: year, "
                            "M: month, D: day, H: hour, m: minute, S: second",
                        "symbol": COP_TRUNC_DATE,
                        "args": (
                            DataProviderSignatureDateType,
                            DataProviderSignatureStringValueType,
                        ),
                        "return_type": AbstractDataProviderTypeMap."date",
                    },
                    "code": string sub(reference<hash<QueryInfo>> info, int role, list<auto> args) {
                        *string str = MysqlTruncDate{args[1]};
                        if (!str) {
                            throw "COP-TRUNC-DATE-ERROR", sprintf("unknown date truncation format argument %y; "
                                "supported date format arguments: %y", args[1], keys MysqlTruncDate);
                        }
                        string exp0 = info.table.getExpressionArg(\info, role, args[0],
                            AbstractDataProviderTypeMap."date");
                        return sprintf("cast(date_format(%s, %s) as datetime)", exp0, str);
                    },
                },
            };
 
            const MysqlOpMap = DefaultOpMap + {
                COP_PREPEND: {
                    "arg": Type::String,
                    "sqlvalue": True,
                    "code": string sub (string cve, string arg) {
                        return sprintf("concat(%s, %s)", arg, cve);
                    },
                },
                COP_APPEND: {
                    "arg": Type::String,
                    "sqlvalue": True,
                    "code": string sub (string cve, string arg) {
                        return sprintf("concat(%s, %s)", cve, arg);
                    },
                },
            };
 
            const MysqlTruncDate = {
                DT_YEAR  : "'%Y-01-01 00:00:00'",
                DT_MONTH : "'%Y-%m-01 00:00:00'",
                DT_DAY   : "'%Y-%m-%d 00:00:00'",
                DT_HOUR  : "'%Y-%m-%d %H:00:00'",
                DT_MINUTE: "'%Y-%m-%d %H:%i:00'",
                DT_SECOND: "'%Y-%m-%d %H:%i:%s'",
            };
 
protected:
            string schema;
            string engine = "innodb";
            string collation;
            string table_encoding;
 
public:
 
        constructor(AbstractDatasource nds, string nname, *hash opts) ;
 
 
        string getSqlName();
 
 
        hash<auto> getExpressionMap();
 
 
        hash<auto> getWhereOperatorMap();
 
 
protected:
         hash getTableCreationOptions();
public:
 
 
protected:
         hash getTableDescriptionHashOptions();
public:
 
 
protected:
         hash getColumnDescOptions();
public:
 
 
protected:
         hash getIndexOptions();
public:
 
 
protected:
         hash getConstraintOptions();
public:
 
 
protected:
         hash getAlignTableOptions();
public:
 
 
protected:
         hash getColumnOperatorMapImpl();
public:
 
 
protected:
         bool checkExistenceImpl();
public:
 
 
protected:
         Columns describeImpl();
public:
 
 
protected:
         *string getCreatePrimaryKeySqlUnlocked(*hash opt, bool cache = True);
public:
 
 
protected:
         MysqlPrimaryKey getPrimaryKeyImpl();
public:
 
 
protected:
         Indexes getIndexesImpl();
public:
 
 
protected:
         ForeignConstraints getForeignConstraintsImpl(*hash opts);
public:
 
 
protected:
         Constraints getConstraintsImpl();
public:
 
 
protected:
         Triggers getTriggersImpl();
public:
 
 
        string getCreateTableSqlImpl(*hash opt);
 
 
        bool hasArrayBind();
 
 
protected:
         *list getCreateMiscSqlImpl(*hash opt, bool cache);
public:
 
 
protected:
         *list getAlignSqlImpl(AbstractTable table, *hash opt);
public:
 
 
protected:
         string getCreateSqlImpl(list l);
public:
 
 
protected:
         string getRenameSqlImpl(string new_name);
public:
 
 
protected:
         AbstractColumn addColumnImpl(string cname, hash<auto> opt, bool nullable = True);
public:
 
 
protected:
         setPrimaryKeyUnlocked(AbstractPrimaryKey pk);
public:
 
 
protected:
         addColumnToTableUnlocked(AbstractColumn c);
public:
 
 
protected:
         AbstractPrimaryKey addPrimaryKeyImpl(string cname, hash ch, *hash opt);
public:
 
 
protected:
         AbstractIndex addIndexImpl(string iname, bool enabled, hash ch, *hash opt);
public:
 
 
protected:
         AbstractForeignConstraint addForeignConstraintImpl(string cname, hash ch, string table, hash tch, *hash opt);
public:
 
 
protected:
         AbstractCheckConstraint addCheckConstraintImpl(string cname, string src, *hash opt);
public:
 
 
protected:
         AbstractUniqueConstraint addUniqueConstraintImpl(string cname, hash ch, *hash opt);
public:
 
 
protected:
         AbstractTrigger addTriggerImpl(string tname, string src, *hash opt);
public:
 
 
protected:
         bool tryInsertImpl(string sql, hash<auto> row);
public:
 
 
 
protected:
         bool isDuplicateRowErrorImpl(hash<ExceptionInfo> ex);
public:
 
 
protected:
         hash getQoreTypeMapImpl();
public:
 
 
protected:
         hash getTypeMapImpl();
public:
 
 
protected:
         *string getSqlValueImpl(auto v);
public:
 
 
protected:
          static *string getSqlValueIntern(auto v);
public:
 
 
 
        string getColumnSqlName(string col);
 
 
        list getColumnSqlNames(softlist cols);
 
 
 
          static *string getSqlValue(auto v);
 
protected:
         bool emptyImpl();
public:
 
 
protected:
         preSetupTableImpl(reference<hash> desc, *hash opt);
public:
 
 
protected:
         setupTableImpl(hash desc, *hash opt);
public:
 
 
protected:
         bool constraintsLinkedToIndexesImpl();
public:
 
 
protected:
         bool uniqueIndexCreatesConstraintImpl();
public:
 
 
protected:
         bool supportsTablespacesImpl();
public:
 
 
protected:
         doSelectLimitOnlyUnlockedImpl(reference<hash<QueryInfo>> info, reference<string> sql);
public:
 
 
        private doSelectOrderByWithOffsetSqlUnlockedImpl(reference<hash<QueryInfo>> info, reference<string> sql,
                list<auto> coll) {
            doSelectOrderBySqlUnlocked(info, \sql, coll);
            if (info.query_hash.limit);
 
 
            if (info.query_hash.offset);
 
        }
 
protected:
         bool asteriskRequiresPrefix();
public:
 
 
protected:
         *hash<auto> doReturningImpl(hash<auto> opt, reference<string> sql, list<auto> args);
public:
 
 
protected:
         list<auto> getGroupOrderByListUnlocked(hash<QueryInfo> info, string key, list<auto> coll);
public:
 
 
        bool hasReturningImpl();
 
 
protected:
         copyImpl(AbstractTable old);
public:
 
 
protected:
         AbstractDataProviderType getNumericTypeImpl(string native_type, bool nullable, *hash<auto> options);
public:
 
 
 
protected:
         AbstractSavepointHelper getSavepointHelperImpl(*string savepoint);
public:
 
    };
};