AbstractDatabase.qc.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
namespace SqlUtil {
class AbstractDatabase : public AbstractSqlUtilBase {
 
public:
 
        const DatabaseOptions = ...;
 
 
 
        const CacheOptions = ...;
 
 
 
        const CallbackOptions = ...;
 
 
        const AC_Unchanged = 0;
 
        const AC_Create = 1;
 
        const AC_Drop = 2;
 
        const AC_Rename = 3;
 
        const AC_Modify = 4;
 
        const AC_Truncate = 5;
 
        const AC_Add = 6;
 
        const AC_Recreate = 7;
 
        const AC_Insert = 8;
 
        const AC_Update = 9;
 
        const AC_Delete = 10;
 
        const AC_NotFound = 11;
 
        const ActionMap = ...;
 
 
        const ActionDescMap = ...;
 
 
        const ActionLetterMap = ...;
 
 
 
        const CreationOptions = ...;
 
 
 
        const AlignSchemaOptions = ...;
 
 
 
        const DropSchemaOptions = ...;
 
 
 
        const SchemaDescriptionOptions = ...;
 
 
 
        const SequenceDescriptionOptions = ...;
 
 
        const ComputeStatisticsOptions = ...;
 
 
        const ReclaimSpaceOptions = ...;
 
 
protected:
        bool native_case = False;
 
        // AbstractDatabase::getPhysicalSize() return in a case of no data
        const GET_PHYSICAL_DB_SIZE_NOVAL = -1;
 
public:
 
 
protected:
     constructor(AbstractDatasource nds, *hash nopts) ;
public:
 
 
    list features();
 
 
      static doOkCallback(*hash<auto> opt, int ac, string type, string name, *string table, *string info);
 
    static private runInfoCallback(code info_callback, int ac, string type, string name, *string table,
            *string new_name, *string info) {
        bool c = (type == "column");
        if (c)
            name = sprintf("%s.%s", table, name);
        string str = sprintf("%s %s %s", ActionMap{ac}, type, name);
        if (table && !c)
            str += sprintf(" %s %s", ac == AC_Drop ? "from" : "on", table);
        if (new_name)
            str += sprintf(" to %s", new_name);
        if (info)
            str += sprintf(" (%s)", info);
        info_callback(str, ac, type, name, table, new_name, info);
    }
 
    static *string doCallback(*hash<auto> opt, *string sql, int ac, string type, string name, *string table,
            *string new_name, *string info) {
        if (!sql)
            return;
        if (opt.info_callback);
 
        if (opt.sql_callback);
 
        return sql;
    }
 
    static list doCallback(*hash<auto> opt, list sql, int ac, string type, string name, *string table,
            *string new_name, *string info) {
        if (!sql)
            return sql;
        if (opt.info_callback);
 
        if (opt.sql_callback);
 
        return sql;
    }
 
 
    auto tryExec(string sql);
 
 
 
    auto tryExecArgs(string sql, *softlist<auto> args);
 
 
 
    auto tryExecRaw(string sql);
 
 
 
    list<auto> getAlignSql(hash schema_hash, *hash<auto> opt, *Tables table_cache);
 
 
 
    list<auto> getDropSchemaSql(hash schema_hash, *hash<auto> opt);
 
 
    private list dropSqlUnlocked(string type, hash schema_hash, code get, code make, *hash<auto> opt,
            string make_arg_type) {
        list l = ();
        hash copt = getCreationOptions();
        string drv = getDriverName();
 
        // drop objects
        reference<hash> fmap = \schema_hash{type + "s"};
        AbstractDatabase::checkDriverOptions(\fmap, drv);
        foreach string name in (fmap.keyIterator());
 
 
        return l;
    }
 
    private list alignCodeUnlocked(string type, hash schema_hash, code get, code make, *hash<auto> opt,
            string make_arg_type) {
        list l = ();
        hash copt = getCreationOptions();
        string drv = getDriverName();
 
        hash code_cache;
 
        // rename objects
        reference<*hash> fmap = \schema_hash{type + "_map"};
        AbstractDatabase::checkDriverOptions(\fmap, drv);
        HashIterator i(fmap);
        while (i.next());
 
 
        // create any missing functions; replace updated functions
        reference<hash> fh = \schema_hash{type + "s"};
        AbstractDatabase::checkDriverOptions(\fh, drv);
        foreach string name in (fh.keyIterator());
 
 
        return l;
    }
 
 
    AbstractSequence makeSequence(string name, number start = 1, number increment = 1, *softnumber end,
            *hash<auto> opts) {
        validateOptionsIntern("OPTION-ERROR", getCreationOptions(), \opts);
 
        // issue #4396: convert letters to lower case if necessary
        if (!opts.native_case);
 
        return makeSequenceImpl(name, start, increment, end, opts);
    }
 
    AbstractSequence makeSequenceFromDescription(string name, *hash<auto> sh, *hash<auto> opts);
 
 
 
    AbstractTable makeTable(string name, hash<auto> desc, *hash<auto> opts);
 
 
 
    AbstractFunction makeFunction(string name, string src, *hash<auto> opts);
 
 
 
    AbstractFunction makeProcedure(string name, string src, *hash<auto> opt);
 
 
 
    bool dropFunctionIfExists(string name, *hash<auto> opt);
 
 
 
    bool dropProcedureIfExists(string name, *hash<auto> opt);
 
 
 
    bool dropSequenceIfExists(string name, *hash<auto> opt);
 
 
 
    bool dropViewIfExists(string name, *hash<auto> opt);
 
 
 
    bool dropTableIfExists(string name, *hash<auto> opt);
 
 
 
    *string getDropFunctionSqlIfExists(string name, *hash<auto> opt);
 
 
 
    *string getDropProcedureSqlIfExists(string name, *hash<auto> opt);
 
 
 
    *string getDropSequenceSqlIfExists(string name, *hash<auto> opt);
 
 
 
    *list<auto> getDropTableSqlIfExists(string name, *hash<auto> opt);
 
 
    doDropSql(*softlist l, string type, string name, *hash<auto> opt);
 
 
    bool doDrop(*softlist l, string type, string name, *hash<auto> opt);
 
 
 
    list<auto> getAlignFunctionSql(AbstractFunction f, *hash<auto> opt);
 
 
 
    list<auto> getAlignProcedureSql(AbstractFunction f, *hash<auto> opt);
 
 
 
    *AbstractTable getTable(string name);
 
 
 
    *AbstractSequence getSequence(string name);
 
 
 
    *AbstractFunction getFunction(string name);
 
 
 
    *AbstractFunction getProcedure(string name);
 
 
 
    *AbstractView getView(string name);
 
 
 
    int getNextSequenceValue(string name);
 
 
 
    int getCurrentSequenceValue(string name);
 
 
 
    string getSqlFromList(list l);
 
 
    bool supportsSequences();
 
 
    bool supportsTypes();
 
 
    bool supportsPackages();
 
 
    list<string> listTables();
 
 
    Qore::ListIterator tableIterator();
 
 
    list<string> listFunctions();
 
 
    Qore::ListIterator functionIterator();
 
 
    list<string> listProcedures();
 
 
    Qore::ListIterator procedureIterator();
 
 
    list<string> listSequences();
 
 
    Qore::ListIterator sequenceIterator();
 
 
    list<string> listViews();
 
 
    Qore::ListIterator viewIterator();
 
 
 
    bool rebuildIndex(string name, *hash<auto> options);
 
 
 
    bool rebuildIndex(AbstractIndex index, *hash<auto> options);
 
 
 
    computeStatistics(*hash<auto> options);
 
 
 
    reclaimSpace(*hash<auto> options);
 
 
 
    int getPhysicalSize();
 
 
 
    bool requiresScale();
 
 
 
    int getMaximumPrecision();
 
 
protected:
     validateOptionsIntern(string err, hash<auto> ropt, reference<hash> opt);
public:
 
 
protected:
     validateOptionsIntern(string err, hash<auto> ropt, reference<hash> opt, string tag);
public:
 
 
      static AbstractDatabase getDatabase(AbstractDatasource nds, *hash<auto> opts);
 
      static string loadModule(AbstractDatasource nds, *reference<string> drv);
 
      static string getOdbcDriverName(AbstractDatasource nds);
 
      static AbstractDatabase getDatabase(string dsstr, *hash<auto> opts);
 
      static AbstractDatabase getDatabase(hash<auto> dsh, *hash<auto> opts);
 
      static checkDriverOptions(reference<hash<auto>> h, string drv);
 
protected:
     hash<auto> getDatabaseOptions();
public:
 
 
protected:
     hash<auto> getCallbackOptions();
public:
 
 
protected:
     hash<auto> getCreationOptions();
public:
 
 
protected:
     hash<auto> getCacheOptions();
public:
 
 
protected:
     hash<auto> getAlignSchemaOptions();
public:
 
 
protected:
     hash<auto> getDropSchemaOptions();
public:
 
 
protected:
     hash<auto> getSchemaDescriptionOptions();
public:
 
 
protected:
     hash<auto> getSequenceDescriptionOptions();
public:
 
 
protected:
     hash<auto> getRebuildIndexOptions();
public:
 
 
protected:
     hash<auto> getComputeStatisticsOptions();
public:
 
 
protected:
     hash<auto> getReclaimSpaceOptions();
public:
 
 
protected:
     auto tryExecArgsImpl(string sql, *softlist<auto> args);
public:
 
 
protected:
     auto tryExecRawImpl(string sql);
public:
 
 
protected:
     abstract string getCreateSqlImpl(list l);
public:
protected:
     abstract list<auto> getAlignSqlImpl(hash schema_hash, *hash<auto> opt);
public:
protected:
     abstract list<auto> getDropSchemaSqlImpl(hash schema_hash, *hash<auto> opt);
public:
 
protected:
     abstract *AbstractSequence getSequenceImpl(string name);
public:
protected:
     abstract *AbstractFunction getFunctionImpl(string name);
public:
protected:
     abstract *AbstractFunction getProcedureImpl(string name);
public:
protected:
     abstract *AbstractView getViewImpl(string name);
public:
 
    private abstract AbstractSequence makeSequenceImpl(string name, number start = 1, number increment = 1,
            *softnumber end, *hash<auto> opts);
protected:
     abstract AbstractFunction makeFunctionImpl(string name, string src, *hash<auto> opts);
public:
protected:
     abstract AbstractFunction makeProcedureImpl(string name, string src, *hash<auto> opts);
public:
 
protected:
     abstract list<string> featuresImpl();
public:
protected:
     abstract list<string> listTablesImpl();
public:
protected:
     abstract list<string> listFunctionsImpl();
public:
protected:
     abstract list<string> listProceduresImpl();
public:
protected:
     abstract list<string> listSequencesImpl();
public:
protected:
     abstract list<string> listViewsImpl();
public:
 
protected:
     abstract int getNextSequenceValueImpl(string name);
public:
protected:
     abstract int getCurrentSequenceValueImpl(string name);
public:
 
protected:
     abstract bool supportsSequencesImpl();
public:
protected:
     abstract bool supportsPackagesImpl();
public:
protected:
     abstract bool supportsTypesImpl();
public:
 
protected:
     abstract bool rebuildIndexImpl(string name, *hash<auto> options);
public:
protected:
     abstract computeStatisticsImpl(*hash<auto> options);
public:
protected:
     abstract reclaimSpaceImpl(*hash<auto> options);
public:
protected:
     abstract int getPhysicalSizeImpl();
public:
};
};