Schema.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
// @file Schema.qm Qore user module for working with SQL data

/*  Schema.qm Copyright 2014 - 2016 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.
*/

// this module requires Qore 0.8.12 or better

// 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 c_int(bool notnull = False, *string comment);



     hash c_int(string comment);



     hash c_varchar(int size, bool notnull = False, *string comment);



     hash c_varchar(int size, string comment);



     hash c_char(int size, bool notnull = False, *string comment);



     hash c_char(int size, string comment);



     hash c_date(bool notnull = False, *string comment);



     hash c_date(string comment);



     hash c_timestamp(bool notnull = False, *string comment);



     hash c_timestamp(string comment);



     hash c_number(bool notnull = False, *string comment);



     hash c_number(int size, int scale, bool notnull = False, *string comment);



     hash c_number(int size, bool notnull = False, *string comment);



     hash c_number(int size, string comment);


    class SchemaCallbackHelper {

public:
        public :
            AbstractSchema schema;
            int verbose;
            int change_count = 0;
            int dot_count = 0;
            int error_count = 0;
            list sql_cache = ();

public:


        constructor(AbstractSchema sc, int v = 0);


        infoCallback(string str, int ac, *string type, *string name, *string table, *string new_name, *string info);


        sqlCallback(string str);


        nothing sqlForceCallback(string str);


        hash getCallbacks(bool force = False);

    };


    class AbstractSchema {

public:
        private :
            string name;
            string version;

            hash schema;

            *hash index_options;
            *hash creation_options;
            *hash column_options;
            *hash all_options;

            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(AbstractDatasource n_ds, *string dts, *string its, *hash opts);


        string getName();


        string getVersion();


        AbstractDatasource getDatasource();


        AbstractDatabase getDatabase();



        logpf(string fmt);



        log(string fmt);



        logProgress(string str);



        int align(bool force = False, int verbose = 0);


        drop(bool force = False, int verbose = 0);



        *hash getIndexOptions();



        *hash getCreationOptions();



        *hash getColumnOptions();



        *hash getTables();



        *hash getSequences();



        *hash getTypes();



        *hash getFunctions();



        *hash getProcedures();



        *hash getPackages();



        *hash getMaterializedViews();



        *hash getStrictReferenceDataHash();



        *hash getReferenceDataHash();



        *hash getCreateOnlyReferenceData();



        *hash getInsertOnlyReferenceData();


        private abstract string getNameImpl();

        private abstract string getVersionImpl();


        private *hash getIndexOptionsImpl();



        private *hash getColumnOptionsImpl();



        private *hash getGenericOptionsImpl();



        private *hash getTablesImpl();



        private *hash getSequencesImpl();



        private *hash getTypesImpl();



        private *hash getFunctionsImpl();



        private *hash getProceduresImpl();



        private *hash getPackagesImpl();



        private *hash getMaterializedViewsImpl();



        private *hash getStrictReferenceDataHashImpl();



        private *hash getReferenceDataHashImpl();



        private *hash getCreateOnlyReferenceDataImpl();



        private *hash getInsertOnlyReferenceDataImpl();



        private bool checkExistence();


        private bool checkFirstTimeInstall();


        private bool checkDropSchema(bool force);


        private bool checkUpdateSchema(bool force, reference initial_schema_info);


        private doPostAlignment(Tables table_cache, bool first_time_install, *hash initial_schema_info);


        private int getUpsertStrategy(bool first_time_install);


        private postDataActions(bool first_time_install);


        private doTable(AbstractTable table, list rows, int upsert_strategy, bool delete_others, int verbose, reference sh);



          static list getRows(*softlist l);

          static hash combineOptions(*hash h);
    };


class AbstractVersionedSchema : public AbstractSchema {

public:
        private :
            string version_table;
            string version_column;
            hash version_where;

public:


        constructor(AbstractDatasource ds, *string dts, *string its, *hash opts) ;


        private *softstring getSchemaVersion();


        private bool checkDropSchema(bool force);


        private bool checkUpdateSchema(bool force, reference initial_schema_info);


        private bool checkUpgrade(string current_version);


        private bool checkDowngrade(string current_version);



        private string getVersionTable();



        private string getVersionColumn();



        private hash getVersionWhere();


        private abstract string getVersionTableImpl();

        private abstract string getVersionColumnImpl();

        private abstract hash getVersionWhereImpl();
    };
};