Schema.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
/*  Schema.qm Copyright 2014 - 2023 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 Qore version
 
// requires the SqlUtil module
 
// requires the Util module
 
// don't use "$" signs for variables and class members, assume local variable scope
 
// require type definitions everywhere
 
// enable all warnings
 
// strict args
 
 
namespace Schema {
    const C_NULL = False;
    const C_NOT_NULL = True;
 
 
     hash<GenericColumnInfo> c_int(bool notnull = False, *string comment);
 
 
 
     hash<GenericColumnInfo> c_int(string comment);
 
 
 
     hash<GenericColumnInfo> c_varchar(int size, bool notnull = False, *string comment);
 
 
 
     hash<GenericColumnInfo> c_varchar(int size, string comment);
 
 
 
     hash<GenericColumnInfo> c_char(int size, bool notnull = False, *string comment);
 
 
 
     hash<GenericColumnInfo> c_char(int size, string comment);
 
 
 
     hash<GenericColumnInfo> c_date(bool notnull = False, *string comment);
 
 
 
     hash<GenericColumnInfo> c_date(string comment);
 
 
 
     hash<GenericColumnInfo> c_timestamp(bool notnull = False, *string comment);
 
 
 
     hash<GenericColumnInfo> c_timestamp(string comment);
 
 
 
     hash<GenericColumnInfo> c_number(bool notnull = False, *string comment);
 
 
 
     hash<GenericColumnInfo> c_number(int size, int scale, bool notnull = False, *string comment);
 
 
 
     hash<GenericColumnInfo> c_number(int size, bool notnull = False, *string comment);
 
 
 
     hash<GenericColumnInfo> c_number(int size, string comment);
 
 
 
     hash<GenericColumnInfo> c_blob(bool notnull = False, *string comment);
 
 
 
     hash<GenericColumnInfo> c_blob(string comment);
 
 
 
     hash<GenericColumnInfo> c_clob(bool notnull = False, *string comment);
 
 
 
     hash<GenericColumnInfo> c_clob(string comment);
 
 
    public hashdecl SchemaAlignmentInfo {
 
        bool created;
 
        int num_changes;
 
        *hash<string, int> change_map;
 
        *hash<string, int> data_change_map;
    };
 
    class SchemaCallbackHelper {
 
public:
            AbstractSchema schema;
            int verbose;
            int change_count = 0;
            int dot_count = 0;
            int error_count = 0;
 
            list<string> sql_cache = ();
 
            hash<string, int> change_map;
 
            hash<string, int> data_change_map;
 
 
            bool created;
 
            const CreateActionMap = {
                AbstractDatabase::AC_Create: True,
                AbstractDatabase::AC_Add: True,
                AbstractDatabase::AC_Insert: True,
            };
 
 
        constructor(AbstractSchema sc, int v = 0);
 
 
        hash<SchemaAlignmentInfo> getInfo();
 
 
        infoCallback(string str, int ac, *string type, *string name, *string table, *string new_name, *string info);
 
 
        sqlCallback(string str);
 
 
        nothing sqlForceCallback(string str);
 
 
        hash<auto> getCallbacks(bool force = False);
 
    };
 
    public hashdecl SchemaOptionInfo {
        *string data_ts;
 
        *string index_ts;
 
        *hash<auto> db_opts;
    };
 
 
    class AbstractSchema {
 
public:
protected:
            string name;
            string version;
 
            hash schema;
 
            *hash index_options;
            *hash creation_options;
            *hash column_options;
            *hash all_options;
 
            Qore::SQL::AbstractDatasource ds;
            string drv;
 
            SqlUtil::Database db;
 
            hash pure_callback_opts;
            hash callback_opts;
 
            code info_callback;
 
            *string data_ts;
 
            *string index_ts;
 
public:
 
 
        constructor(Qore::SQL::AbstractDatasource ds, *string dts, *string its, *hash opts);
 
 
 
        constructor(Qore::SQL::AbstractDatasource ds, *hash<SchemaOptionInfo> opts);
 
 
        string getName();
 
 
        string getVersion();
 
 
        Qore::SQL::AbstractDatasource getDatasource();
 
 
        SqlUtil::AbstractDatabase getDatabase();
 
 
 
        logpf(string fmt);
 
 
 
        log(string fmt);
 
 
 
        logProgress(string str);
 
 
 
        int align(bool force = False, int verbose = 0, bool do_msgs = True);
 
 
 
        hash<SchemaAlignmentInfo> alignWithInfo(bool force = False, int verbose = 0, bool do_msgs = True);
 
 
 
protected:
         SchemaCallbackHelper alignIntern(bool force = False, int verbose = 0, bool do_msgs = True);
public:
 
 
        drop(bool force = False, int verbose = 0, bool do_msgs = True);
 
 
 
        *hash<auto> getIndexOptions();
 
 
 
        *hash<auto> getCreationOptions();
 
 
 
        *hash<auto> getColumnOptions();
 
 
 
        *hash<auto> getTables();
 
 
 
        *hash<auto> getSequences();
 
 
 
        *hash<auto> getTypes();
 
 
 
        *hash<auto> getFunctions();
 
 
 
        *hash<auto> getProcedures();
 
 
 
        *hash<auto> getPackages();
 
 
 
        *hash<auto> getMaterializedViews();
 
 
 
        *hash<auto> getStrictReferenceDataHash();
 
 
 
        *hash<auto> getReferenceDataHash();
 
 
 
        *hash<auto> getCreateOnlyReferenceData();
 
 
 
        *hash<auto> getInsertOnlyReferenceData();
 
 
protected:
         init(Qore::SQL::AbstractDatasource ds, *hash<SchemaOptionInfo> opts);
public:
 
 
protected:
         abstract string getNameImpl();
public:
 
protected:
         abstract string getVersionImpl();
public:
 
 
protected:
         *hash<auto> getIndexOptionsImpl();
public:
 
 
 
protected:
         *hash<auto> getColumnOptionsImpl();
public:
 
 
 
protected:
         *hash<auto> getGenericOptionsImpl();
public:
 
 
 
protected:
         *hash<auto> getTablesImpl();
public:
 
 
 
protected:
         *hash<auto> getSequencesImpl();
public:
 
 
 
protected:
         *hash<auto> getTypesImpl();
public:
 
 
 
protected:
         *hash<auto> getFunctionsImpl();
public:
 
 
 
protected:
         *hash<auto> getProceduresImpl();
public:
 
 
 
protected:
         *hash<auto> getPackagesImpl();
public:
 
 
 
protected:
         *hash<auto> getMaterializedViewsImpl();
public:
 
 
 
protected:
         *hash<auto> getStrictReferenceDataHashImpl();
public:
 
 
 
protected:
         *hash<auto> getReferenceDataHashImpl();
public:
 
 
 
protected:
         *hash<auto> getCreateOnlyReferenceDataImpl();
public:
 
 
 
protected:
         *hash<auto> getInsertOnlyReferenceDataImpl();
public:
 
 
 
protected:
         bool checkExistence();
public:
 
 
protected:
         bool checkFirstTimeInstall();
public:
 
 
protected:
         bool checkDropSchema(bool force);
public:
 
 
protected:
         bool checkUpdateSchema(bool force, reference<hash<auto>> initial_schema_info);
public:
 
 
protected:
         doPostAlignment(Tables table_cache, bool first_time_install, *hash<auto> initial_schema_info, int verbose);
public:
 
 
protected:
         doPostAlignment(Tables table_cache, bool first_time_install, *hash<auto> initial_schema_info);
public:
 
 
protected:
         int getUpsertStrategy(bool first_time_install);
public:
 
 
protected:
         postDataActions(Tables table_cache, bool first_time_install, *hash<auto> initial_schema_info, int verbose);
public:
 
 
protected:
         postDataActions(bool first_time_install);
public:
 
 
protected:
         doTable(AbstractTable table, list rows, int upsert_strategy, bool delete_others, int verbose, reference<hash<string, int>> sh);
public:
 
 
 
          static list getRows(*softlist<auto> l);
 
          static hash combineOptions(*hash h);
    };
 
 
class AbstractVersionedSchema : public AbstractSchema {
 
public:
protected:
            string version_table;
            string version_column;
            hash version_where;
 
public:
 
 
        constructor(Qore::SQL::AbstractDatasource ds, *string dts, *string its, *hash opts) ;
 
 
protected:
         *softstring getSchemaVersion();
public:
 
 
protected:
         bool checkDropSchema(bool force);
public:
 
 
protected:
         bool checkUpdateSchema(bool force, reference<hash<auto>> initial_schema_info);
public:
 
 
protected:
         bool checkUpgrade(string current_version);
public:
 
 
protected:
         bool checkDowngrade(string current_version);
public:
 
 
 
protected:
         string getVersionTable();
public:
 
 
 
protected:
         string getVersionColumn();
public:
 
 
 
protected:
         hash getVersionWhere();
public:
 
 
protected:
         abstract string getVersionTableImpl();
public:
 
protected:
         abstract string getVersionColumnImpl();
public:
 
protected:
         abstract hash getVersionWhereImpl();
public:
    };
};