DbDataProvider.qc.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
namespace DbDataProvider {
 
class DbDataProvider : public AbstractDataProvider {
 
public:
        const ProviderInfo = <DataProviderInfo>{
            "type": "DbDataProvider",
            "supports_read": True,
            "supports_bulk_read": True,
            "supports_children": True,
            "constructor_options": ConstructorOptions,
            "search_options": SearchOptions,
            "create_options": NOTHING,
            "upsert_options": NOTHING,
            "child_create_options": ChildCreateOptions,
            "supports_search_expressions": True,
            "expressions": AbstractDataProvider::GenericExpressions,
            "transaction_management": True,
            "has_record": True,
            "record_requires_search_options": True,
            "supports_child_create": True,
            "supports_child_delete": True,
            "children_can_support_apis": False,
            "children_can_support_records": True,
            "children_can_support_transactions": True,
        };
 
 
        const MapperKeyInfo = Mapper::MapperKeyInfo + {
            "sequence": <MapperRuntimeKeyInfo>{
                "desc": "names the DB sequence that will be used to populate the field",
                "value_type": "string",
                "unique_roles": "*",
                "returns_type": "int",
            },
            "sequence_currval": <MapperRuntimeKeyInfo>{
                "desc": "names the DB sequence that will be used to populate the field; the current value of the "
                    "sequence is used; will not increment the sequence",
                "value_type": "string",
                "unique_roles": "*",
                "returns_type": "int",
            },
        };
 
        const ConstructorOptions = {
            "datasource": <DataProviderOptionInfo>{
                "type": (
                    AbstractDataProviderType::get(StringType),
                    AbstractDataProviderType::get(new Type("AbstractDatasource")),
                ),
                "desc": "the datasource connection string or an abstract datasource object",
                "required": True,
            },
        };
 
        const SearchOptions = {
            "sql": <DataProviderOptionInfo>{
                "type": AbstractDataProviderType::get(StringType),
                "desc": "the raw SQL for the select statement",
                "required": True,
            },
            "args": <DataProviderOptionInfo>{
                "type": AbstractDataProviderType::get(AutoListType),
                "desc": "any bind arguments for the select statement",
            },
        };
 
        const ChildCreateOptions = {
            "primary_key": <DataProviderOptionInfo>{
                "type": AbstractDataProviderType::get("softlist<string>"),
                "desc": "a list of column names for the primary key for the table; use `primary_key_name` to set the "
                    "name of the primary key constraint manually, otherwise a suitable name will be automatically "
                    "generated",
            },
            "primary_key_name": <DataProviderOptionInfo>{
                "type": AbstractDataProviderType::get(StringType),
                "desc": "the name of the primary key constraint; only used if `primary_key` is set",
            },
            "indexes": <DataProviderOptionInfo>{
                "type": new DbIndexesDataType(),
                "desc": "a hash of indexes keyed by index name",
            },
            "foreign_constraints": <DataProviderOptionInfo>{
                "type": new DbForeignConstraintsDataType(),
                "desc": "a hash of foreign constraints keyed by foreign constraint name",
            },
        };
 
protected:
        AbstractDatabase db;
 
        static *code datasource_lookup;
 
        static *code table_lookup;
 
public:
 
    constructor(AbstractDatasource ds, *hash<auto> opts);
 
 
    constructor(AbstractDatabase db);
 
 
    constructor(*hash<auto> options);
 
 
    string getName();
 
 
    *string getDesc();
 
 
 
    beginTransaction();
 
 
 
    commit();
 
 
 
    rollback();
 
 
 
    *hash<string, hash<MapperRuntimeKeyInfo>> getMapperRuntimeKeys();
 
 
    int doSequenceKey(string sequence_name, hash<auto> ctx, *reference<bool> missing_input);
 
 
    int doSequenceCurrvalKey(string sequence_name, hash<auto> ctx, *reference<bool> missing_input);
 
 
 
      static *hash<string, AbstractDataField> getRecordTypeFromDescribeHash(hash<auto> describe_hash);
 
 
protected:
     *hash<string, AbstractDataField> getRecordTypeImpl(*hash<auto> search_options);
public:
 
 
 
    private AbstractDataProviderBulkRecordInterface searchRecordsBulkImpl(int block_size = 1000,
            *hash<auto> where_cond, *hash<auto> search_options) {
        return new DbSelectBulkRecordInterface(block_size, db.getDatasource(), where_cond, search_options);
    }
 
 
protected:
     AbstractDataProviderRecordIterator searchRecordsImpl(*hash<auto> where_cond, *hash<auto> search_options);
public:
 
 
    *list<hash<DataProviderSummaryInfo>> getChildProviderSummaryInfo();
 
 
 
protected:
     *list<string> getChildProviderNamesImpl();
public:
 
 
 
protected:
     *AbstractDataProvider getChildProviderImpl(string name);
public:
 
 
protected:
     hash<DataProviderInfo> getStaticInfoImpl();
public:
 
 
 
    private AbstractDataProvider createChildProviderImpl(string name, hash<string, AbstractDataField> fields,
            *hash<auto> child_create_options) {
        hash<auto> table_desc = makeTableDesc(name, fields, child_create_options);
        AbstractTable table = db.makeTable(name, table_desc);
        DbTableTransactionHelper th(table);
        th.create();
        if (logger);
 
        return new DbTableDataProvider(table, logger);
    }
 
 
protected:
     deleteChildProviderImpl(string name, *hash<auto> child_delete_options);
public:
 
 
      static setDatasourceLookup(code datasource_lookup);
 
      static setTableLookup(code table_lookup);
 
      static AbstractDatasource getDatasource(AbstractDatasource ds);
 
      static AbstractDatasource getDatasource(string ds_string);
 
      static AbstractTable getTable(string ds_string, string table_string);
 
      static AbstractTable getTable(AbstractDatasource ds, string table_string);
 
      static hash<GenericColumnInfo> getColumnDesc(AbstractDatabase db, AbstractDataField field, *hash<auto> opts);
 
 
    hash<auto> makeTableDesc(string name, hash<string, AbstractDataField> fields, *hash<auto> opts);
 
};
};