SqlUtil.qm.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
/*  SqlUtil.qm Copyright (C) 2013 - 2024 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 Util module
 
// requires the DataProvider 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


//! the SqlUtil namespace contains all the objects in the SqlUtil module
namespace SqlUtil {
    public struct GenericColumnInfo {
        string qore_type;
        string native_type;
        softint size;
        softint scale;
        auto default_value;
        bool default_value_native = False;
        *string comment;
        bool notnull = False;
        hash<string, hash> driver;

        *bool auto_increment;
    };

    public struct OperatorInfo {
        string op;   
        auto arg;     
    };

    public struct ColumnOperatorInfo {
        string cop;  
        auto column;  
        auto arg;     
    };

    public struct InsertOperatorInfo {
        string _iop;  
        any arg;      
    };

    public struct UpdateOperatorInfo {
        string uop;  
        auto arg;     
        *hash nest;  
    };

    public struct JoinOperatorInfo {
        string jop;           
        auto table;           
        *string alias;        
        *hash jcols;          
        *hash cond;           
        *string ta;           
        *hash<auto> opt;      
    };

    public struct SqlUtilDataTypeOptionInfo {
        *string date_format;

        *TimeZone data_timezone;

        *TimeZone db_timezone;

        *string number_format;

        *softbool mandatory;



        *softint maxlen;
    };

    //! A hash describing SQL and arguments for an SQL DML command

    public struct SqlCommandInfo {
        string sql;


        list<auto> args;
    };


    const DB_FUNCTIONS = "functions";
    const DB_MVIEWS = "materialized views";
    const DB_PACKAGES = "packages";
    const DB_PROCEDURES = "procedures";
    const DB_SEQUENCES = "sequences";
    const DB_TABLES = "tables";
    const DB_TYPES = "named types";
    const DB_VIEWS = "views";
    const DB_SYNONYMS = "synonyms";
 
    /* @defgroup SqlTypeConstants SQL Type Constants
        These constants can be used for the \c "qore_type" values when creating columns to specify additional SQL column types
    */
    const VARCHAR = "string";

    const NUMERIC = "number";

    const CHAR = "char";

    const BLOB = "blob";

    const CLOB = "clob";

    const SZ_NONE = 0;

    const SZ_MAND = 1;

    const SZ_OPT = 2;

    const SZ_NUM = 3;


    const COP_AS = "as";


    const COP_CAST = "cast";


    const COP_PREPEND = "prepend";


    const COP_APPEND = "append";


    const COP_VALUE = "value";


    const COP_UPPER = "upper";


    const COP_LOWER = "lower";


    const COP_DISTINCT = "distinct";


    const COP_MIN = "min";


    const COP_MAX = "max";


    const COP_AVG = "avg";


    const COP_SUM = "sum";


    const COP_COUNT = "count";


    const COP_OVER = "over";


    const COP_MINUS = "minus";


    const COP_PLUS = "plus";


    const COP_DIVIDE = "divide";


    const COP_MULTIPLY = "multiply";


    const COP_YEAR = "year";


    const COP_YEAR_MONTH = "year_month";


    const COP_YEAR_DAY = "year_day";


    const COP_YEAR_HOUR = "year_hour";


    const COP_SEQ = "seq";


    const COP_SEQ_CURRVAL = "seq_currval";


    const COP_COALESCE = "coalesce";


    const COP_SUBSTR = "substr";


    const COP_LENGTH = "length";


    const COP_TRUNC_DATE = "truncate_date";


    const COP_CUME_DIST = "cume_dist";


    const COP_DENSE_RANK = "dense_rank";


    const COP_FIRST_VALUE = "first_value";


    const COP_LAST_VALUE = "last_value";


    const COP_NTILE = "ntile";


    const COP_PERCENT_RANK = "percent_rank";


    const COP_RANK = "rank";


    const COP_ROW_NUMBER = "row_number";

    public struct QueryInfo {
        object table;

        *hash<auto> query_hash;

        *hash<auto> query_options;

        *hash<string, AbstractTable> join_map;

        *hash<string, bool> subquery_column_map;

        *hash<auto> pseudo_column_map;

        *hash<auto> expression_map;

        *hash<auto> where_operator_map;

        *hash<auto> column_operator_map;


        list<auto> args;
    };

    const DefaultCopMap = ...;



     hash<ColumnOperatorInfo> make_cop(string cop, auto column, auto arg);
 


     hash<ColumnOperatorInfo> cop_as(auto column, string arg);
 


     hash<ColumnOperatorInfo> cop_cast(auto column, string arg, auto arg1, auto arg2);
 


     hash<ColumnOperatorInfo> cop_prepend(auto column, string arg);
 


     hash<ColumnOperatorInfo> cop_append(auto column, string arg);
 


     hash<ColumnOperatorInfo> cop_value(auto arg);
 


     hash<ColumnOperatorInfo> cop_upper(auto column);
 


     hash<ColumnOperatorInfo> cop_lower(auto column);
 


     hash<ColumnOperatorInfo> cop_distinct(auto column);
 


     hash<ColumnOperatorInfo> cop_min(auto column);
 


     hash<ColumnOperatorInfo> cop_max(auto column);
 


     hash<ColumnOperatorInfo> cop_avg(auto column);
 


     hash<ColumnOperatorInfo> cop_sum(auto column);
 


     hash<ColumnOperatorInfo> cop_count(auto column = '');
 


     hash<ColumnOperatorInfo> cop_over(auto column, *string partitionby, *string orderby);
 


     hash<ColumnOperatorInfo> cop_minus(auto column1, auto column2);
 


     hash<ColumnOperatorInfo> cop_plus(auto column1, auto column2);
 


     hash<ColumnOperatorInfo> cop_divide(auto column1, auto column2);
 


     hash<ColumnOperatorInfo> cop_multiply(auto column1, auto column2);
 


     hash<ColumnOperatorInfo> cop_year(auto column);
 


     hash<ColumnOperatorInfo> cop_year_month(auto column);
 


     hash<ColumnOperatorInfo> cop_year_day(auto column);
 


     hash<ColumnOperatorInfo> cop_year_hour(auto column);
 


     hash<ColumnOperatorInfo> cop_seq(string seq, *string as);
 


     hash<ColumnOperatorInfo> cop_seq_currval(string seq, *string as);
 


     hash<ColumnOperatorInfo> cop_coalesce(auto col1, auto col2);
 


     hash<ColumnOperatorInfo> cop_substr(auto column, int start, *int count);
 


     hash<ColumnOperatorInfo> cop_length(auto column);
 


     hash<ColumnOperatorInfo> cop_trunc_date(auto column, string mask);
 
 


     hash<ColumnOperatorInfo> cop_cume_dist();
 


     hash<ColumnOperatorInfo> cop_dense_rank();
 


     hash<ColumnOperatorInfo> cop_first_value(any column);
 


     hash<ColumnOperatorInfo> cop_last_value(any column);
 


     hash<ColumnOperatorInfo> cop_ntile(int value);
 


     hash<ColumnOperatorInfo> cop_percent_rank();
 


     hash<ColumnOperatorInfo> cop_rank();
 


     hash<ColumnOperatorInfo> cop_row_number();
 


    const DT_YEAR = "Y";

    const DT_MONTH = "M";

    const DT_DAY = "D";

    const DT_HOUR = "H";

    const DT_MINUTE = "m";

    const DT_SECOND = "S";
 
    // let's simulate and enum here'
    const DT_ALL_VALUES = ( DT_YEAR, DT_MONTH, DT_DAY, DT_HOUR, DT_MINUTE, DT_SECOND );

    const DefaultUopMap = ...;



     hash<UpdateOperatorInfo> make_uop(string uop, auto arg, *hash<UpdateOperatorInfo> nest);
 


     hash<UpdateOperatorInfo> uop_prepend(string arg, *hash<UpdateOperatorInfo> nest);
 


     hash<UpdateOperatorInfo> uop_append(string arg, *hash<UpdateOperatorInfo> nest);
 


     hash<UpdateOperatorInfo> uop_upper(*hash<UpdateOperatorInfo> nest);
 


     hash<UpdateOperatorInfo> uop_lower(*hash<UpdateOperatorInfo> nest);
 


     hash<UpdateOperatorInfo> uop_substr(int start, *int count, *hash<UpdateOperatorInfo> nest);
 


     hash<UpdateOperatorInfo> uop_plus(auto arg, *hash<UpdateOperatorInfo> nest);
 


     hash<UpdateOperatorInfo> uop_minus(auto arg, *hash<UpdateOperatorInfo> nest);
 


     hash<UpdateOperatorInfo> uop_multiply(auto arg, *hash<UpdateOperatorInfo> nest);
 


     hash<UpdateOperatorInfo> uop_divide(auto arg, *hash<UpdateOperatorInfo> nest);
 


     hash<UpdateOperatorInfo> uop_seq(string seq);
 


     hash<UpdateOperatorInfo> uop_seq_currval(string seq);



    const JOP_INNER = "inner";


    const JOP_LEFT = "left";


    const JOP_RIGHT = "right";

    const JopMap = ...;



     hash<string, hash<JoinOperatorInfo>> make_jop(string jop, AbstractTable table, *string alias, *hash jcols, *hash cond, *string ta, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> make_jop(string jop, string table_name, *string alias, *hash jcols, *hash cond, *string ta, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_inner(AbstractTable table, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_inner(Table table, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_inner(string table_name, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_inner(string ta, AbstractTable table, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_inner(string ta, Table table, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_inner_alias(string ta, string table_name, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_left(AbstractTable table, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_left(Table table, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_left(string table_name, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_left(string ta, AbstractTable table, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_left(string ta, Table table, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_left_alias(string ta, string table_name, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_right(AbstractTable table, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_right(Table table, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_right(string table_name, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_right(string ta, AbstractTable table, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_right(string ta, Table table, *string alias, *hash jcols, *hash cond, *hash<auto> opt);
 


     hash<string, hash<JoinOperatorInfo>> join_right_alias(string ta, string table_name, *string alias, *hash jcols, *hash cond, *hash<auto> opt);



    const OP_LIKE = "like";


    const OP_LT = "<";


    const OP_LE = "<=";


    const OP_GT = ">";


    const OP_GE = ">=";


    const OP_NE = "!=";


    const OP_EQ = "=";


    const OP_CLT = "C<";


    const OP_CLE = "C<=";


    const OP_CGT = "C>";


    const OP_CGE = "C>=";


    const OP_CNE = "C!=";


    const OP_CEQ = "C=";


    const OP_BETWEEN = "between";


    const OP_IN = "in";


    const OP_NOT = "not";


    const OP_SUBSTR = "substr";


    const OP_OR = "or";


    const OP_IN_SELECT = "in_select";

    const DefaultExpressionMap = ...;
 

    const DefaultOpMap = ...;


     hash<OperatorInfo> make_op(string op, auto arg);
 


     hash<OperatorInfo> op_like(string str);
 


     hash<OperatorInfo> op_lt(auto arg);
 


     hash<OperatorInfo> op_le(auto arg);
 


     hash<OperatorInfo> op_gt(auto arg);
 


     hash<OperatorInfo> op_ge(auto arg);
 


     hash<OperatorInfo> op_ne(auto arg);
 


     hash<OperatorInfo> op_eq(auto arg);
 


     hash<OperatorInfo> op_between(auto l, auto r);
 


     hash<OperatorInfo> op_in();
 


     hash<OperatorInfo> op_in_select(string table, hash<auto> select_hash);
 


     hash<OperatorInfo> op_in_select(AbstractTable table, hash<auto> select_hash);
 


     hash<OperatorInfo> op_in_select(Table table, hash<auto> select_hash);
 


     hash<OperatorInfo> op_in(list<auto> args);
 


     hash<OperatorInfo> op_not(hash arg);
 


     hash<OperatorInfo> op_clt(string arg);
 


     hash<OperatorInfo> op_cle(string arg);
 


     hash<OperatorInfo> op_cgt(string arg);
 


     hash<OperatorInfo> op_cge(string arg);
 


     hash<OperatorInfo> op_cne(string arg);
 


     hash<OperatorInfo> op_ceq(string arg);
 


     hash<OperatorInfo> op_substr(int start, *int count, string text);
 


     hash<OperatorInfo> op_substr(int start, string text);
 


     hash<string, hash<OperatorInfo>> wop_or(hash h1, hash h2);



    const IOP_SEQ = "seq";


    const IOP_SEQ_CURRVAL = "seq_currval";

    const DefaultIopMap = {};


     hash<InsertOperatorInfo> make_iop(string iop, auto arg);
 


     hash<InsertOperatorInfo> iop_seq(string arg);
 


     hash<InsertOperatorInfo> iop_seq_currval(string arg);


    const SqlUtilDrivers = ...;
 
 
    // private variable to store the closure used to deserialize datasources (if any)
    extern code ds_get;
 
    // private variable to store the closure used to serialize datasources (if any)
    extern code ds_do;

     sqlutil_register_ds_deserializer(*code new_ds_get);
 

     sqlutil_register_ds_serializer(*code new_ds_do);
 
 
    // private function used to deserialize datasources
    AbstractDatasource sqlutil_get_ds(string type, string config);
 
 
    // private function used to serialize datasources
    hash<auto> sqlutil_ds(AbstractDatasource ds);
 

class AbstractHashContainer : public Qore::Serializable {
 
public:
        
 
protected:
            *hash h;
 
public:

        constructor(*hash nh);
 

        constructor(AbstractHashContainer old);
 

        copy(AbstractHashContainer old);
 


        auto memberGate(string k);
 


        clear();
 

        abstract auto take(string k);

        renameKey(string old_name, string new_name);
 

        *hash<auto> getHash();
 


        bool matchKeys(hash h1);
 


        bool matchKeys(list<auto> l);
 


        bool matchKeys(AbstractHashContainer c);
 


        bool partialMatchKeys(hash<auto> h1);
 


        bool partialMatchKeys(list<auto> l);
 


        bool partialMatchKeys(AbstractHashContainer c);
 


        bool val();
 


        list<string> keys();
 


        list<auto> values();
 


        Qore::AbstractIterator iterator();
 


        Qore::AbstractIterator keyIterator();
 


        Qore::AbstractIterator pairIterator();
 

        bool empty();
 


        int size();
 


        bool hasKey(string k);
 


        bool hasKeyValue(string k);
 


        *string firstKey();
 


        *string lastKey();
 


        abstract string getElementName();
    };

class AbstractListContainer : public Qore::Serializable {
 
public:
        
 
protected:
            softlist l;
 
public:

        constructor(softlist nl);
 


        abstract auto get(softint i);

        add(auto val);
 

        auto take(int i);
 

        list<auto> getList();
 


        bool val();
 


        Qore::ListIterator iterator();
 

        bool empty();
 


        int size();
 

        abstract string getElementName();
 
protected:
         checkIndex(int i);
public:
 
    };

class Tables : public AbstractHashContainer {
 
public:
        constructor();
 

        constructor(AbstractDatasource ds, hash tables, *hash<auto> opt);
 

        constructor(AbstractDatasource ds);
 

        add(string k, Table val);
 

        add(string k, AbstractTable val);
 

        add(Table val);
 

        add(AbstractTable val);
 

        AbstractTable take(string k);
 

        populate(AbstractDatasource ds, hash<auto> tables, *hash<auto> opt);
 

        populate(AbstractDatasource ds);
 


        *list<auto> getDropAllForeignConstraintsOnTableSql(string name, *hash<auto> opt);
 


        AbstractTable memberGate(string k);
 

        string getElementName();
 

        *AbstractTable getIfExists(AbstractDatasource ds, string name);
 

        AbstractTable get(AbstractDatasource ds, string name);
 


        *string getRenameTableIfExistsSql(string old_name, string new_name, *hash<auto> opts);
 


        bool tableRenamed(string old_name, string new_name, string old_sql_name);
 
 
protected:
         tableRenamedIntern(string old_name, string new_name, string oldsn);
public:
 


        *string getDropConstraintIfExistsSql(string tname, string cname, *hash<auto> opts);
 
 
        list<auto> getCreateList();
 
 
        Qore::AbstractIterator createIterator();
 


        list<auto> getDropList();
 


        Qore::AbstractIterator dropIterator();
 
 
protected:
         getDependencies(reference<hash> tdh, reference<hash> sdh, *reference<hash> th);
public:
 
    };

class Columns : public AbstractHashContainer {
 
public:
        constructor(*hash c) ;
 

        constructor(Columns old) ;
 

        add(string k, AbstractColumn val);
 

        AbstractColumn take(string k);
 


        AbstractColumn memberGate(string k);
 

        Columns subset(softlist l);
 

        string getElementName();
 

        bool equal(Columns cols);
 

        AbstractIterator getSqlColumnNameIterator();
 
    };

class AbstractDdlObject : public Qore::Serializable {
 
public:
            string name;

            string ddl_name;

protected:
         constructor();
public:
 

        constructor(string name);
 



        abstract string getDdlName(string name);
    };

class AbstractColumn : public AbstractDdlObject {
 
public:
            string native_type;

            *string qore_type;

            int size;

            bool nullable;

            *string def_val;

            *string comment;

            *int scale;

            const DefaultVarcharSize = 80;

protected:
         constructor();
public:
 
 
        constructor(string n, string nt, *string qt, int sz, bool nul, *string dv, *string c, *int scale) ;
 


        hash<GenericColumnInfo> getDescriptionHash();
 


        string getNativeTypeString();
 

        string getCreateSql(AbstractTable t);
 


        abstract list<auto> getAddColumnSql(AbstractTable t);

        string getDropSql(string table_name);
 


        list<auto> getModifySql(AbstractTable t, AbstractColumn c, *hash<auto> opt);
 


        abstract string getRenameSql(AbstractTable t, string new_name);

        bool equal(AbstractColumn c);
 

protected:
         abstract bool equalImpl(AbstractColumn c);
public:


protected:
         abstract list<auto> getModifySqlImpl(AbstractTable t, AbstractColumn c, *hash<auto> opt);
public:
    };

class Indexes : public AbstractHashContainer {
 
public:
        constructor(*hash c) ;
 

        add(string k, AbstractIndex val);
 

        *AbstractIndex findEqual(AbstractIndex ix);
 

        AbstractIndex take(string k);
 

        *AbstractIndex tryTake(string k);
 


        AbstractIndex memberGate(string k);
 
 
        string getElementName();
 
    };

class AbstractIndex : public Qore::Serializable {
 
public:
            string name;

            bool unique;

            Columns columns;
 
protected:
            *AbstractColumnSupportingConstraint constraint;

            *AbstractForeignConstraint foreign_constraint;
 
public:

        constructor(string n, bool u, hash c);
 

        string getName();
 

        bool hasColumn(string cname);
 

        abstract string getCreateSql(string table_name, *hash<auto> opt);

        string getDropSql(string table_name);
 

        bool equal(AbstractIndex ix);
 

        bool equalExceptName(AbstractIndex ix);
 

        abstract bool equalImpl(AbstractIndex ix);

        abstract string getRenameSql(string table_name, string new_name);

        setSupportingConstraint(AbstractColumnSupportingConstraint c);
 

        setSupportingConstraint();
 

        *AbstractColumnSupportingConstraint getSupportingConstraint();
 

        setSupportingConstraint(AbstractForeignConstraint c);
 

        setForeignConstraint();
 

        *AbstractForeignConstraint getForeignConstraint();
 

        *list<AbstractColumnConstraint> getAllSupportingConstraints();
 

        list<auto> getRecreateSql(AbstractDatasource ds, string table_name, *hash<auto> opt);
 
    };

class Constraints : public AbstractHashContainer {
 
public:
        constructor(*hash c) ;
 

        add(string k, AbstractConstraint val);
 

        AbstractConstraint take(string k);
 

        *AbstractUniqueConstraint findEqualUniqueConstraint(AbstractUniqueConstraint uk);
 


        AbstractConstraint memberGate(string k);
 
 
        string getElementName();
 
    };

class AbstractConstraint : public Qore::Serializable {
 
public:
        
 
protected:
            string name;
 
public:

        constructor(string n);
 

        string getName();
 

        rename(string n);
 

        abstract string getCreateSql(string table_name, *hash<auto> opt);

        string getDropSql(string table_name);
 

        abstract list<auto> getRenameSql(string table_name, string new_name);

        string getDisableSql(string table_name);
 

        string getEnableSql(string table_name, *hash<auto> opt);
 

        bool equal(AbstractConstraint c);
 

protected:
         abstract bool equalImpl(AbstractConstraint c);
public:

        abstract bool setIndexBase(string ix);

        abstract clearIndex();

        bool hasColumn(string cname);
 
    };

class AbstractCheckConstraint : public AbstractConstraint {
 
public:
            string src;

        constructor(string n, string n_src) ;
 

protected:
         bool equalImpl(AbstractConstraint c);
public:
 

        bool setIndexBase(string ix);
 

        clearIndex();
 
    };

class AbstractColumnConstraint : public AbstractConstraint, public Columns {
 
public:
protected:
            *string index;
 
public:

        constructor(string name, *hash<auto> cols, *string index) ;
 

        constructor(string name, Columns cols, *string index) ;
 

        bool setIndexBase(string ix);
 

        bool hasColumn(string cname);
 

        clearIndex();
 
    };

class AbstractColumnSupportingConstraint : public AbstractColumnConstraint {
 
public:
protected:
            *hash<string, hash<string, AbstractForeignConstraint>> sourceConstraints;
 
public:

        constructor(string name, *hash<auto> cols, *string index) ;
 

        constructor(string name, Columns cols, *string index) ;
 


        Qore::AbstractIterator getSourceConstraintIterator();
 

        hash<auto> getDisableReenableSql(AbstractDatasource ds, string table_name, *hash<auto> opts);
 

        findMatchingIndex(*Indexes indexes);
 


        addSourceConstraint(string tname, AbstractForeignConstraint fk);
 

        removeSourceConstraint(string tname, list<auto> cols);
 

        renameSourceConstraintTable(string old_name, string new_name);
 

        bool hasColumn(string cname);
 

        *string getIndex();
 

protected:
         bool equalImpl(AbstractConstraint c);
public:
 


        abstract string getCreateSql(string table_name, *hash<auto> opts);
    };

class AbstractUniqueConstraint : public AbstractColumnSupportingConstraint {
 
public:
        constructor(string n, *hash<auto> c, *string n_index) ;
 
    };

class AbstractPrimaryKey : public AbstractUniqueConstraint {
 
public:
        constructor() ;
 
 
        constructor(string n, *hash<auto> c) ;
 
    };

class ForeignConstraints : public AbstractHashContainer {
 
public:
        constructor(*hash<auto> c) ;
 

        add(string k, AbstractForeignConstraint val);
 

        AbstractForeignConstraint take(string k);
 

        *AbstractForeignConstraint findEqual(AbstractForeignConstraint fk);
 


        AbstractForeignConstraint memberGate(string k);
 

        *hash<auto> findConstraintOn(string table, softlist<auto> cols);
 

        string getElementName();
 
    };

class ForeignConstraintTarget : public Qore::Serializable {
 
public:
            string table;

            Columns columns;

        constructor(string t, Columns c);
 

        bool hasColumn(string cname);
 

        bool equal(ForeignConstraintTarget targ);
 
    };

class AbstractForeignConstraint : public AbstractColumnConstraint {
 
public:
            ForeignConstraintTarget target;
 
        constructor(string name, Columns cols, ForeignConstraintTarget t) ;
 

        bool hasTargetColumn(string col);
 

protected:
         bool equalImpl(AbstractConstraint con);
public:
 
    };

class AbstractSequence : public Qore::Serializable {
 
public:
            string name;

            number start;

            number increment;

            *number max;

        constructor(string n_name, number n_start = 1, number n_increment = 1, *softnumber n_max);
 

        abstract string getCreateSql(*hash<auto> opt);


        string getDropSql(*hash<auto> opt);
 



        abstract softlist<auto> getRenameSql(string new_name, *hash<auto> opt);
    };

class AbstractView : public Qore::Serializable {
 
public:
            // ! potential object schema
            *string schema;

            string name;

            string src;

            bool updatable;

        constructor(string n_name, string n_src);
 

        abstract string getCreateSql(*hash<auto> opt);


        string getDropSql(*hash<auto> opt);
 



        abstract softlist<auto> getRenameSql(string new_name, *hash<auto> opt);
    };

class AbstractFunctionBase : public Qore::Serializable {
 
public:
            string name;

            string type;

            string src;


        constructor(string n, string n_type, string n_src);
 

        string getType();
 


        string getDropSql(*hash<auto> opt);
 

        bool equal(AbstractFunctionBase t);
 

        string getNormalizedSource(string src);
 

protected:
         abstract bool equalImpl(AbstractFunctionBase t);
public:
    };

class AbstractFunction : public AbstractFunctionBase {
 
public:

        constructor(string n, string n_type, string n_src) ;
 

        abstract list<auto> getCreateSql(*hash<auto> opt);


        abstract softlist<auto> getRenameSql(string new_name, *hash<auto> opt);

        setName(string new_name);
 
    };

class Functions : public AbstractHashContainer {
 
public:
        constructor(*hash c) ;
 

        add(string k, AbstractFunction val);
 

        AbstractFunction take(string k);
 


        AbstractFunction memberGate(string k);
 
 
        string getElementName();
 
    };

class AbstractTrigger : public AbstractFunctionBase {
 
public:
        constructor(string n, string n_src) ;
 

        abstract list<auto> getCreateSql(string table_name, *hash<auto> opt);

        abstract softlist<auto> getRenameSql(string table_name, string new_name);


        abstract list<auto> getDropSql(string table_name);
    };

class Triggers : public AbstractHashContainer {
 
public:
        constructor(*hash c) ;
 

        add(string k, AbstractTrigger val);
 

        AbstractTrigger take(string k);
 


        AbstractTrigger memberGate(string k);
 
 
        string getElementName();
 
    };
};