Sqlite3SqlUtil.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
/*  Sqlite3SqlUtil.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:bool n_auto_increment = False, bool n_pk = False
 
    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 Sqlite3SqlUtil {
     Sqlite3Table get_table(AbstractDatasource nds, string nname, *hash<auto> opts);
 
 
     Sqlite3Database get_database(AbstractDatasource nds, *hash<auto> opts);
 
 
class Sqlite3SavepointHelper : public AbstractSavepointHelper {
 
public:
        constructor(AbstractDatasource ds, *string savepoint) ;
 
 
protected:
         createSavepointImpl();
public:
 
 
protected:
         rollbackImpl();
public:
 
 
protected:
         deleteSavepointImpl();
public:
 
    };
 
class Sqlite3Index : public SqlUtil::AbstractIndex {
 
public:
            hash<string, string> collations;
 
        constructor(string name, bool unique, hash<auto> cols, *hash<string, string> collations)
 ;
 
 
        string getCreateSql(string table_name, *hash<auto> opt);
 
 
        list<string> getColumnCollationList();
 
 
protected:
         bool equalImpl(AbstractIndex ix);
public:
 
 
 
        string getRenameSql(string table_name, string new_name);
 
 
        string getDropSql(string table_name);
 
    };
 
class Sqlite3ForeignConstraint : public SqlUtil::AbstractForeignConstraint {
 
public:
        constructor(string n, Columns c, ForeignConstraintTarget t) ;
 
 
        string getCreateSql(string table_name, *hash<auto> opt);
 
 
        softlist getRenameSql(string table_name, string new_name);
 
 
        string getCreateSql(string name, string table_name, *hash<auto> opt);
 
 
        string getAddSql(string name, string table_name, *hash<auto> opt);
 
 
        string getDropSql(string table_name);
 
    };
 
class Sqlite3Column : public SqlUtil::AbstractColumn {
 
public:
            bool auto_increment;
            bool primary_key;
 
protected:
         constructor();
public:
 
 
        constructor(string name, string native_type, *string qore_type, bool nullable, *string default_value,
                bool auto_increment = False, bool primary_key = False)
 ;
 
 
 
        softlist<string> getAddColumnSql(AbstractTable t);
 
 
 
        softlist<string> getModifySqlImpl(AbstractTable t, AbstractColumn col, *hash<auto> opt);
 
 
 
        string getRenameSql(AbstractTable t, string new_name);
 
 
 
        string getDdlName(string name);
 
 
protected:
         bool equalImpl(AbstractColumn c);
public:
 
    };
 
class Sqlite3UniqueConstraint : public SqlUtil::AbstractUniqueConstraint {
 
public:
        constructor(string name, hash<auto> cols) ;
 
 
 
        Sqlite3Column memberGate(string k);
 
 
        string getCreateSql(string table_name, *hash<auto> opts);
 
 
        list<string> getRenameSql(string table_name, string new_name);
 
 
        string getCreateSql(string name, string table_name, *hash<auto> opts);
 
 
        string getDropSql(string table_name);
 
    };
 
class Sqlite3PrimaryKey : public SqlUtil::AbstractPrimaryKey {
 
public:
        constructor();
 
 
        constructor(hash<auto> c) ;
 
 
        string getCreateSql(string table_name, *hash<auto> opts);
 
 
        list<string> getRenameSql(string table_name, string new_name);
 
 
        bool supportsName();
 
    };
 
class Sqlite3Trigger : public SqlUtil::AbstractTrigger {
 
public:
        constructor(string n, string n_src) ;
 
 
        softlist getCreateSql(string table_name, *hash<auto> opt);
 
 
        softlist getDropSql(string table_name);
 
 
protected:
         bool equalImpl(AbstractFunctionBase t);
public:
 
 
        softlist getRenameSql(string table_name, string new_name);
 
    };
 
class Sqlite3View : public SqlUtil::AbstractView {
 
public:
        constructor(string name, string src) ;
 
 
        string getCreateSql(*hash<auto> opt);
 
 
 
        softlist getRenameSql(string new_name, *hash<auto> opt);
 
    };
 
class Sqlite3Database : public SqlUtil::AbstractDatabase {
 
public:
            const Sqlite3ReservedWords = {
                "abort": True,
                "action": True,
                "add": True,
                "after": True,
                "all": True,
                "alter": True,
                "always": True,
                "analyze": True,
                "and": True,
                "as": True,
                "asc": True,
                "attach": True,
                "autoincrement": True,
                "before": True,
                "begin": True,
                "between": True,
                "by": True,
                "cascade": True,
                "case": True,
                "cast": True,
                "check": True,
                "collate": True,
                "column": True,
                "commit": True,
                "conflict": True,
                "constraint": True,
                "create": True,
                "cross": True,
                "current": True,
                "current_date": True,
                "current_time": True,
                "current_timestamp": True,
                "database": True,
                "default": True,
                "deferrable": True,
                "deferred": True,
                "delete": True,
                "desc": True,
                "detach": True,
                "distinct": True,
                "do": True,
                "drop": True,
                "each": True,
                "else": True,
                "end": True,
                "escape": True,
                "except": True,
                "exclude": True,
                "exclusive": True,
                "exists": True,
                "explain": True,
                "fail": True,
                "filter": True,
                "first": True,
                "following": True,
                "for": True,
                "foreign": True,
                "from": True,
                "full": True,
                "generated": True,
                "glob": True,
                "group": True,
                "groups": True,
                "having": True,
                "if": True,
                "ignore": True,
                "immediate": True,
                "in": True,
                "index": True,
                "indexed": True,
                "initially": True,
                "inner": True,
                "insert": True,
                "instead": True,
                "intersect": True,
                "into": True,
                "is": True,
                "isnull": True,
                "join": True,
                "key": True,
                "last": True,
                "left": True,
                "like": True,
                "limit": True,
                "match": True,
                "materialized": True,
                "natural": True,
                "no": True,
                "not": True,
                "nothing": True,
                "notnull": True,
                "null": True,
                "nulls": True,
                "of": True,
                "offset": True,
                "on": True,
                "or": True,
                "order": True,
                "others": True,
                "outer": True,
                "over": True,
                "partition": True,
                "plan": True,
                "pragma": True,
                "preceding": True,
                "primary": True,
                "query": True,
                "raise": True,
                "range": True,
                "recursive": True,
                "references": True,
                "regexp": True,
                "reindex": True,
                "release": True,
                "rename": True,
                "replace": True,
                "restrict": True,
                "returning": True,
                "right": True,
                "rollback": True,
                "row": True,
                "rows": True,
                "savepoint": True,
                "select": True,
                "set": True,
                "table": True,
                "temp": True,
                "temporary": True,
                "then": True,
                "ties": True,
                "to": True,
                "transaction": True,
                "trigger": True,
                "unbounded": True,
                "union": True,
                "unique": True,
                "update": True,
                "using": True,
                "vacuum": True,
                "values": True,
                "view": True,
                "virtual": True,
                "when": True,
                "where": True,
                "window": True,
                "with": True,
                "without": True,
            };
 
        constructor(AbstractDatasource ds, *hash<auto> opts) ;
 
 
 
        bool requiresScale();
 
 
 
        int getMaximumPrecision();
 
 
protected:
         list<string> featuresImpl();
public:
 
 
        string getSchemaName();
 
 
        private AbstractSequence makeSequenceImpl(string name, number start = 1, number increment = 1,
                *softnumber end, *hash<auto> opts) {
            throw "UNSUPPORTED";
        }
 
protected:
         *AbstractSequence getSequenceImpl(string name);
public:
 
 
protected:
         *AbstractView getViewImpl(string name);
public:
 
 
protected:
         AbstractFunction makeFunctionImpl(string name, string src, *hash<auto> opts);
public:
 
 
protected:
         AbstractFunction makeProcedureImpl(string name, string src, *hash<auto> opts);
public:
 
 
protected:
         *AbstractFunction getFunctionImpl(string name);
public:
 
 
protected:
         *AbstractFunction getProcedureImpl(string name);
public:
 
 
protected:
         list<string> getDropSchemaSqlImpl(hash<auto> schema_hash, *hash<auto> opt);
public:
 
 
protected:
         list<string> getAlignSqlImpl(hash schema_hash, *hash<auto> 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<auto> l);
public:
 
 
          static string getCreateSql(list<auto> l);
 
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<auto> options);
public:
 
 
protected:
         computeStatisticsImpl(*hash<auto> options);
public:
 
 
protected:
         reclaimSpaceImpl(*hash<auto> options);
public:
 
 
protected:
         int getPhysicalSizeImpl();
public:
 
    };
 
class Sqlite3Table : public SqlUtil::AbstractTable {
 
public:
            const Sqlite3TypeMap = {
                "real": {
                    "qore": Type::Float,
                    "size": SZ_NUM,
                },
                "integer": {
                    "qore": Type::Int,
                    "ai": True,
                },
                "text": {
                    "qore": Type::String,
                },
                "varchar": {
                    "qore": Type::String,
                },
                "blob": {
                    "qore": Type::Binary,
                },
            };
 
            const QoreTypeMap = ...;
 
 
            const Sqlite3CopMap = ...;
 
 
        constructor(AbstractDatasource ds, string name, *hash<auto> opts) ;
 
 
        string getSqlName();
 
 
protected:
         hash getColumnOperatorMapImpl();
public:
 
 
protected:
         bool checkExistenceImpl();
public:
 
 
protected:
         Columns describeImpl();
public:
 
 
protected:
         *string getCreatePrimaryKeySqlUnlocked(*hash<auto> opt, bool cache = True);
public:
 
 
protected:
         Sqlite3PrimaryKey getPrimaryKeyImpl();
public:
 
 
protected:
         Indexes getIndexesImpl();
public:
 
 
protected:
         ForeignConstraints getForeignConstraintsImpl(*hash<auto> opts);
public:
 
 
protected:
         Constraints getConstraintsImpl();
public:
 
 
protected:
         Triggers getTriggersImpl();
public:
 
 
        string getCreateTableSqlImpl(*hash<auto> opt);
 
 
        bool hasArrayBind();
 
 
protected:
         *list getCreateMiscSqlImpl(*hash<auto> 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<auto> opt, bool nullable = True);
public:
 
 
protected:
         setPrimaryKeyUnlocked(AbstractPrimaryKey pk);
public:
 
 
protected:
         addColumnToTableUnlocked(AbstractColumn c);
public:
 
 
protected:
         AbstractPrimaryKey addPrimaryKeyImpl(string cname, hash<auto> ch, *hash<auto> opt);
public:
 
 
protected:
         AbstractIndex addIndexImpl(string iname, bool enabled, hash<auto> ch, *hash<auto> 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 Sqlite3ForeignConstraint(cname, new Columns(ch), fct);
        }
 
protected:
         AbstractCheckConstraint addCheckConstraintImpl(string cname, string src, *hash<auto> opt);
public:
 
 
protected:
         AbstractUniqueConstraint addUniqueConstraintImpl(string cname, hash<auto> ch, *hash<auto> opt);
public:
 
 
protected:
         AbstractTrigger addTriggerImpl(string tname, string src, *hash<auto> 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:
          static *string getSqlValueIntern(auto v);
public:
 
 
 
        string getColumnSqlName(string col);
 
 
        list<string> getColumnSqlNames(softlist<auto> cols);
 
 
 
          static *string getSqlValue(auto v);
 
protected:
         bool emptyImpl();
public:
 
 
protected:
         preSetupTableImpl(reference<hash> desc, *hash<auto> opt);
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:
         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:
 
    };
};