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);
 
protected:
      static runInfoCallback(code info_callback, int ac, string type, string name, *string table, *string new_name, *string info);
public:
 
 
      static *string doCallback(*hash<auto> opt, *string sql, int ac, string type, string name, *string table, *string new_name, *string info);
 
      static list doCallback(*hash<auto> opt, list sql, int ac, string type, string name, *string table, *string new_name, *string info);
 
 
    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);
 
 
protected:
     list dropSqlUnlocked(string type, hash schema_hash, code get, code make, *hash<auto> opt, string make_arg_type);
public:
 
 
protected:
     list alignCodeUnlocked(string type, hash schema_hash, code get, code make, *hash<auto> opt, string make_arg_type);
public:
 
 
 
    AbstractSequence makeSequence(string name, number start = 1, number increment = 1, *softnumber end, *hash<auto> 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 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:
 
protected:
     abstract AbstractSequence makeSequenceImpl(string name, number start = 1, number increment = 1, *softnumber end, *hash<auto> opts);
public:
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:
};
};