PgsqlSqlUtil.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
/*  PgsqlSqlUtil.qm Copyright (C) 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
 
 
// version history is included below in the docs
 
namespace PgsqlSqlUtil {
     PgsqlTable get_table(AbstractDatasource nds, string nname, *hash<auto> opts);
 
 
     PgsqlDatabase get_database(AbstractDatasource nds, *hash<auto> opts);
 
 
class PgsqlNumberDataType : public SqlUtil::AbstractNumericDataType {
 
public:
        constructor(string native_type, bool nullable, *hash<auto> options) ;
 
    };
 
    parse_schema_name(string nname, reference<string> schema, reference<string> name);
 
 
class PgsqlSavepointHelper : public AbstractSavepointHelper {
 
public:
        constructor(AbstractDatasource ds, *string savepoint) ;
 
 
protected:
         createSavepointImpl();
public:
 
 
protected:
         rollbackImpl();
public:
 
 
protected:
         deleteSavepointImpl();
public:
 
    };
 
class PgsqlType : public Qore::Serializable {
 
public:
            string name;
 
            string src;
 
        constructor(string n_name, string n_src);
 
 
        list getTypeList();
 
 
        list getModifySql(PgsqlType old, *hash opt);
 
 
        string getCreateSql(*hash opt);
 
 
 
        string getDropSql(*hash opt);
 
 
 
        string getRenameSql(string new_name, *hash opt);
 
 
        bool equal(PgsqlType type);
 
    };
 
class PgsqlIndex : public SqlUtil::AbstractIndex {
 
public:
            *string tablespace;
 
        constructor(string n_name, bool n_unique, hash n_cols, *string n_tablespace) ;
 
 
        string getCreateSql(string table_name, *hash opt);
 
 
        string getDropSql(string table_name);
 
 
protected:
         bool equalImpl(AbstractIndex ix);
public:
 
 
        string getRenameSql(string table_name, string new_name);
 
 
    };
 
class PgsqlForeignConstraint : public SqlUtil::AbstractForeignConstraint {
 
public:
        constructor(string n, Columns c, ForeignConstraintTarget t) ;
 
 
        string getCreateSql(string table_name, *hash opt);
 
 
        string getDropSql(string table_name);
 
 
        softlist getRenameSql(string table_name, string new_name);
 
 
        string getCreateSql(string name, string table_name, *hash<auto> opt);
 
    };
 
class PgsqlCheckConstraint : public SqlUtil::AbstractCheckConstraint {
 
public:
        constructor(string n, string n_src) ;
 
 
        string getCreateSql(string table_name, *hash opt);
 
 
        list getRenameSql(string table_name, string new_name);
 
 
        string getCreateSql(string name, string table_name, *hash opt);
 
    };
 
class PgsqlColumn : 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)
 ;
 
 
        string getNativeTypeString();
 
 
 
        list getAddColumnSql(AbstractTable t);
 
 
 
        list 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 PgsqlNumericColumn : public PgsqlColumn {
 
public:
        constructor(string n, string nt, *string qt, int sz, bool nul, *string dv, *string cm, softint bs,
                softint scale) ;
 
 
        string getNativeTypeString();
 
    };
 
class PgsqlUniqueConstraintCommon : public SqlUtil::AbstractUniqueConstraint {
 
public:
protected:
            *string tablespace;
 
public:
 
        constructor(*string ts);
 
 
        *string getTablespace();
 
 
        setTablespace(*string ts);
 
 
        bool setIndexBase(string ix);
 
 
        clearIndex();
 
 
        getIndexSql(reference<string> sql, string name, *hash opts);
 
    };
 
class PgsqlUniqueConstraint : public SqlUtil::AbstractUniqueConstraint,public  PgsqlUniqueConstraintCommon {
 
public:
protected:
            bool enabled;
 
public:
 
 
        constructor(string n, hash n_cols, bool e = True, *string ts)
 ;
 
 
 
        PgsqlColumn memberGate(string k);
 
 
        string getCreateSql(string table_name, *hash opts);
 
 
        list<auto> getRenameSql(string table_name, string new_name);
 
 
        string getCreateSql(string name, string table_name, *hash<auto> opts);
 
 
        bool isEnabled();
 
    };
 
class PgsqlPrimaryKey : public SqlUtil::AbstractPrimaryKey,public  PgsqlUniqueConstraintCommon {
 
public:
        constructor();
 
 
 
        constructor(string n, *hash c, *string ts) ;
 
 
 
        PgsqlColumn memberGate(string k);
 
 
        string getCreateSql(string table_name, *hash<auto> opts);
 
 
        softlist getRenameSql(string table_name, string new_name);
 
    };
 
class PgsqlSequence : public SqlUtil::AbstractSequence {
 
public:
        constructor(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);
 
    };
 
class PgsqlView : public SqlUtil::AbstractView {
 
public:
            *string viewowner;
 
        constructor(string n_name, string n_src, *string n_schemaname,
                    *string n_viewowner)
 ;
 
 
        string getCreateSql(*hash opt);
 
 
 
        softlist getRenameSql(string new_name, *hash opt);
 
    };
 
class PgsqlTrigger : 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);
 
 
        string getNormalizedSource(string src);
 
    };
 
class PgsqlFunction : public SqlUtil::AbstractFunction {
 
public:
            *string args;
 
        constructor(string n, string n_src, *string a) ;
 
 
        softlist getCreateSql(*hash opt);
 
 
 
        string getDropSql(*hash opt);
 
 
protected:
         bool equalImpl(AbstractFunctionBase t);
public:
 
 
 
        softlist getRenameSql(string new_name, *hash opt);
 
 
        setName(string new_name);
 
    };
 
class PgsqlTriggerFunction : public PgsqlFunction {
 
public:
            string trigger;
 
        constructor(string n, string n_src, string n_trigger) ;
 
    };
 
class PgsqlDatabase : public SqlUtil::AbstractDatabase {
 
public:
            const PgsqlSchemaDescriptionOptions = ...;
 
 
            const PGSQL_TempSavepoint = "qore_pgsql_tmp_savepoint";
 
            const PgsqlReclaimSpaceOptions = ...;
 
 
            const PgsqlReservedWords = {
                "all": True,
                "analyse": True,
                "analyze": True,
                "and": True,
                "any": True,
                "as": True,
                "asc": True,
                "authorization": True,
                "between": True,
                "binary": True,
                "both": True,
                "case": True,
                "cast": True,
                "check": True,
                "collate": True,
                "column": True,
                "constraint": True,
                "create": True,
                "cross": True,
                "currentdate": True,
                "currenttime": True,
                "currenttimestamp": True,
                "currentuser": True,
                "default": True,
                "deferrable": True,
                "desc": True,
                "distinct": True,
                "do": True,
                "else": True,
                "end": True,
                "except": True,
                "false": True,
                "for": True,
                "foreign": True,
                "freeze": True,
                "from": True,
                "full": True,
                "grant": True,
                "group": True,
                "having": True,
                "ilike": True,
                "in": True,
                "initially": True,
                "inner": True,
                "intersect": True,
                "into": True,
                "is": True,
                "isnull": True,
                "join": True,
                "leading": True,
                "left": True,
                "like": True,
                "limit": True,
                "localtime": True,
                "localtimestamp": True,
                "natural": True,
                "new": True,
                "not": True,
                "notnull": True,
                "null": True,
                "off": True,
                "offset": True,
                "old": True,
                "on": True,
                "only": True,
                "or": True,
                "order": True,
                "outer": True,
                "overlaps": True,
                "placing": True,
                "primary": True,
                "references": True,
                "right": True,
                "select": True,
                "sessionuser": True,
                "similar": True,
                "some": True,
                "table": True,
                "then": True,
                "to": True,
                "trailing": True,
                "true": True,
                "union": True,
                "unique": True,
                "user": True,
                "using": True,
                "verbose": True,
                "when": True,
                "where": True,
            };
 
        constructor(AbstractDatasource nds, *hash opts) ;
 
 
protected:
         list<string> featuresImpl();
public:
 
 
        PgsqlType makeType(string name, string src, *hash opts);
 
 
        *PgsqlType getType(string name);
 
 
protected:
         PgsqlSequence 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:
         PgsqlFunction makeFunctionImpl(string name, string src, *hash opts);
public:
 
 
protected:
         PgsqlFunction makeProcedureImpl(string name, string src, *hash opts);
public:
 
 
protected:
         *AbstractFunction getFunctionImpl(string name);
public:
 
 
protected:
         AbstractFunction getProcedureImpl(string name);
public:
 
 
          static *string getFunctionArgs(string err, reference<string> src);
 
          static PgsqlFunction processFunction(hash<auto> row, bool native_case);
 
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:
 
 
        list<string> listMaterializedViews();
 
 
        ListIterator materializedViewIterator();
 
 
        list<string> listTypes();
 
 
        ListIterator typeIterator();
 
 
protected:
         string getCreateSqlImpl(list l);
public:
 
 
          static string getCreateSql(list l);
 
protected:
         hash getSchemaDescriptionOptions();
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:
 
 
protected:
         auto tryExecArgsImpl(string sql, *softlist<auto> args);
public:
 
 
protected:
         auto tryExecRawImpl(string sql, *softlist<auto> args);
public:
 
 
          static auto tryExecArgs(AbstractDatasource ds, string sql, *softlist<auto> args);
 
          static auto tryExecRaw(AbstractDatasource ds, string sql);
    };
 
class PgsqlTable : public SqlUtil::AbstractTable {
 
public:
            const PgsqlTypeMap = ...;
 
 
            const PgsqlNameMap = ...;
 
 
            const QoreTypeMap = ...;
 
 
 
            const PgsqlTableDescriptionHashOptions = ...;
 
 
            const PgsqlColumnDescOptions = AbstractTable::ColumnDescOptions;
 
            const PgsqlIndexOptions = AbstractTable::IndexOptions;
 
            const PgsqlConstraintOptions = ...;
 
 
            const PgsqlTableCreationOptions = ...;
 
 
            const PgsqlAlignTableOptions = AbstractTable::AlignTableOptions + PgsqlTableCreationOptions;
 
            const PgsqlExpressionMap = DefaultExpressionMap + {
                COP_CAST: {
                    "exp": <DataProviderExpressionInfo>{
                        "type": DET_Operator,
                        "label": COP_CAST,
                        "name": "cast",
                        "desc": "cast operator",
                        "symbol": "cast",
                        "args": (
                            DataProviderSignatureAnyType,
                            DataProviderSignatureStringValueType,
                            DataProviderSignatureOptionalIntValueType,
                            DataProviderSignatureOptionalIntValueType,
                        ),
                        "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 = PgsqlTypeMap{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_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("to_char(%s, 'YYYY')", 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("to_char(%s, 'YYYY-MM')", 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("to_char(%s, 'YYYY-MM-DD')", 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("to_char(%s, 'YYYY-MM-DD HH24')", 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 = PgsqlTruncDate{args[1]};
                        if (!str) {
                            throw "TRUNC-DATE-ERROR", sprintf("unknown date truncation format argument %y; "
                                "supported date format arguments: %y", args[1], keys PgsqlTruncDate);
                        }
                        string exp0 = info.table.getExpressionArg(\info, role, args[0],
                            AbstractDataProviderTypeMap."date");
                        return sprintf("date_trunc(%s, %s)", str, exp0);
                    },
                },
                COP_SEQ: {
                    "exp": <DataProviderExpressionInfo>{
                        "type": DET_Operator,
                        "label": COP_SEQ,
                        "name": COP_SEQ,
                        "desc": "returns the next value in the given sequence; args: sequence name",
                        "symbol": COP_SEQ,
                        "args": (
                            DataProviderSignatureStringValueType,
                        ),
                        "return_type": AbstractDataProviderTypeMap."int",
                    },
                    "code": string sub (reference<hash<QueryInfo>> info, int role, list<auto> args) {
                        return sprintf("nextval('%s')", args[0]);
                    }
                },
                COP_SEQ_CURRVAL: {
                    "exp": <DataProviderExpressionInfo>{
                        "type": DET_Operator,
                        "label": COP_SEQ_CURRVAL,
                        "name": COP_SEQ_CURRVAL,
                        "desc": "returns the current value in the given sequence; args: sequence name",
                        "symbol": COP_SEQ_CURRVAL,
                        "args": (
                            DataProviderSignatureStringValueType,
                        ),
                        "return_type": AbstractDataProviderTypeMap."int",
                    },
                    "code": string sub (reference<hash<QueryInfo>> info, int role, list<auto> args) {
                        return sprintf("currval('%s')", args[0]);
                    }
                },
            };
 
            const PgsqlCopMap = {
                COP_CAST: (
                    "code": string sub (string cve, list<auto> args) {
                        string name = QoreTypeMap{args[0]} ?? args[0];
                        hash desc = PgsqlTypeMap{name};
                        string sql = sprintf ("cast (%s as %s", cve, name);
                        switch (name) {
                            default:
                                if (desc.size == SZ_MAND) {
                                    if (!exists args[1] && !exists desc.size_range)
                                        throw "OPERATOR-ERROR", sprintf ("op_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_YEAR: (
                    "code": string sub (string arg1, auto arg) {
                        return sprintf("to_char(%s, 'YYYY')", arg1);
                    }
                ),
                COP_YEAR_MONTH: (
                    "code": string sub (string arg1, auto arg) {
                        return sprintf("to_char(%s, 'YYYY-MM')", arg1);
                    }
                ),
                COP_YEAR_DAY: (
                    "code": string sub (string arg1, auto arg) {
                        return sprintf("to_char(%s, 'YYYY-MM-DD')", arg1);
                    }
                ),
                COP_YEAR_HOUR: (
                    "code": string sub (string arg1, auto arg) {
                        return sprintf("to_char(%s, 'YYYY-MM-DD HH24')", arg1);
                    }
                ),
                COP_SEQ: (
                    "nocolumn": True,
                    "withalias": True,
                    "code": string sub (*string cve, hash arg, reference<hash> psch) {
                        string sql = sprintf("nextval('%s')", arg.seq);
                        if (arg.as) {
                            psch{arg.as} = sql;
                            sql += " " + arg.as;
                        }
                        return sql;
                    }
                ),
                COP_SEQ_CURRVAL: (
                    "nocolumn": True,
                    "withalias": True,
                    "code": string sub (*string cve, hash arg, reference<hash> psch) {
                        string sql = sprintf("currval('%s')", arg.seq);
                        if (arg.as) {
                            psch{arg.as} = sql;
                            sql += " " + arg.as;
                        }
                        return sql;
                    }
                ),
                COP_TRUNC_DATE: (
                    "code": string sub(string arg1, auto arg) {
                        if (!PgsqlTruncDate.hasKey(arg)) {
                            throw "COP-TRUNC-DATE-ERROR", sprintf("Not allowed format argument: %n: allowed: %n", arg,
                                PgsqlTruncDate.keys());
                        }
                        return sprintf("date_trunc(%s, %s)", PgsqlTruncDate{arg}, arg1);
                    }
                ),
            };
 
            const PgsqlTruncDate = ...;
 
 
            const PgsqlIopMap = ...;
 
 
            const PgsqlUopMap = ...;
 
 
protected:
            *string tablespace;
 
            string schema;
 
            Functions triggerFunctions;
 
            bool has_atomic_merge;
 
            int server_version;
 
            int server_version_major;
 
            int server_version_minor;
 
            int server_version_sub;
 
            transient Mutex pg_state();
 
public:
 
        constructor(AbstractDatasource nds, string nname, *hash opts) ;
 
 
        string getSchemaName();
 
 
        *string getTablespaceName();
 
 
        PgsqlFunction addTriggerFunction(string tfname, string src, string trigger);
 
 
        bool hasArrayBind();
 
 
        string getColumnSqlName(string col);
 
 
 
        list<auto> getColumnSqlNames(softlist<auto> cols);
 
 
 
        code getUpsertClosure(hash<auto> row, int upsert_strategy = UpsertAuto, *hash<auto> opt);
 
 
        bool hasAtomicUpsert();
 
 
protected:
         getServerVersion();
public:
 
 
protected:
         code getUpsertAuto(Columns cols, hash<auto> row, *hash<auto> opt);
public:
 
 
protected:
         PgsqlFunction addTriggerFunctionUnlocked(string tfname, string src, string trigger);
public:
 
 
        string getSqlName();
 
 
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:
         hash getInsertOperatorMap();
public:
 
 
protected:
         hash getRawUpdateOperatorMap();
public:
 
 
        hash<auto> getExpressionMap();
 
 
protected:
         bool checkExistenceImpl();
public:
 
 
protected:
         Columns describeImpl();
public:
 
 
protected:
         PgsqlPrimaryKey getPrimaryKeyImpl();
public:
 
 
protected:
         Indexes getIndexesImpl();
public:
 
 
protected:
         ForeignConstraints getForeignConstraintsImpl(*hash opts);
public:
 
 
protected:
         Constraints getConstraintsImpl();
public:
 
 
protected:
         Triggers getTriggersImpl();
public:
 
 
protected:
         string getCreateTableSqlImpl(*hash opt);
public:
 
 
protected:
         *list getCreateMiscSqlImpl(*hash opt, bool cache);
public:
 
 
protected:
         *list getAlignSqlImpl(AbstractTable table, *hash<auto> opt);
public:
 
 
protected:
         string getCreateSqlImpl(list l);
public:
 
 
protected:
         string getRenameSqlImpl(string new_name);
public:
 
 
protected:
         AbstractColumn addColumnImpl(string cname, hash opt, bool nullable = True);
public:
 
 
protected:
         AbstractPrimaryKey addPrimaryKeyImpl(string cname, hash ch, *hash opt);
public:
 
 
protected:
         AbstractIndex addIndexImpl(string iname, bool enabled, hash ch, *hash opt);
public:
 
 
        private AbstractForeignConstraint addForeignConstraintImpl(string cname, hash<auto> ch, string table,
                hash<auto> tch, *hash<auto> opt) {
            ForeignConstraintTarget fct(table, new Columns(tch));
            return new PgsqlForeignConstraint(cname, new Columns(ch), fct);
        }
 
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<auto> getQoreTypeMapImpl();
public:
 
 
protected:
         hash<auto> getTypeMapImpl();
public:
 
 
 
protected:
         *string getSqlValueImpl(auto v);
public:
 
 
protected:
         bool emptyImpl();
public:
 
 
protected:
         clearImpl();
public:
 
 
protected:
         softlist getDropSqlImpl();
public:
 
 
protected:
         setupTableImpl(hash<auto> desc, *hash<auto> 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:
         auto tryExecArgsImpl(string sql, *softlist<auto> args);
public:
 
 
protected:
         auto tryExecRawImpl(string sql, *softlist<auto> args);
public:
 
 
protected:
         copyImpl(AbstractTable old);
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:
 
 
protected:
         AbstractDataProviderType getNumericTypeImpl(string native_type, bool nullable, *hash<auto> options);
public:
 
 
 
protected:
         AbstractSavepointHelper getSavepointHelperImpl(*string savepoint);
public:
 
    };
};