AbstractDataProvider.qc.dox.h

// -*- mode: c++; indent-tabs-mode: nil -*-
 
namespace DataProvider {
const UpsertResultInserted = "inserted";
 
const UpsertResultUpdated = "updated";
 
const UpsertResultVerified = "verified";
 
const UpsertResultUnchanged = "unchanged";
 
const UpsertResultDeleted = "deleted";
 
public hashdecl DataProviderOptionInfo {
    string display_name;
 
    *string short_desc;
 
    string desc;
 
    softlist<AbstractDataProviderType> type;
 
 
    bool required = False;
 
 
    *softlist<string> required_groups;
 
    *softlist<string> exclusive_with;
 
    auto default_value;
 
    bool sensitive = False;
 
    bool multiselect;
 
    *softlist<hash<Util::AllowedValueInfo>> allowed_values;
 
    bool allowed_values_creatable;
 
    /* In case the option type is a list, then this will provide the discrete values that can appear in the list
    */
    *softlist<hash<Util::AllowedValueInfo>> element_allowed_values;
 
    bool element_allowed_values_creatable;
 
 
    auto example_value;
 
 
    *string ref_data;
 
 
    *string element_ref_data;
 
    *string default_ref_data;
 
    *bool preselected;
 
    *hash<auto> metadata;
};
 
public hashdecl DataProviderSummaryInfo {
    string name;
 
    string display_name;
 
    *string short_desc;
 
    string desc;
 
    string type;
 
    bool supports_read = False;
 
    bool supports_create = False;
 
    bool supports_update = False;
 
    bool supports_upsert = False;
 
    bool supports_delete = False;
 
    bool supports_native_search = False;
 
 
    bool supports_bulk_read = False;
 
 
    bool supports_bulk_create = False;
 
 
    bool supports_bulk_upsert = False;
 
    bool supports_request = False;
 
    bool supports_children = False;
 
    bool transaction_management = False;
 
    bool has_record = False;
 
    bool supports_search_expressions = False;
 
 
    bool supports_observable = False;
 
 
    string supports_messages = MSG_None;
 
 
    bool supports_connections = False;
 
 
    bool supports_auto_reconnect = False;
 
 
    bool children_can_support_apis = False;
 
 
    bool children_can_support_records = False;
 
 
    bool children_can_support_observers = False;
 
 
    bool children_can_support_messages = False;
 
 
    bool children_can_support_transactions = False;
 
 
    bool children_identical = False;
};
 
public hashdecl DataProviderMessageInfo {
 
    string desc;
 
    AbstractDataProviderType type;
};
 
 
const MSG_None = "NONE";
 
 
const MSG_Sync = "SYNC";
 
 
const MSG_Async = "ASYNC";
 
const ST_Any = 1;
 
const ST_Value = 2;
 
 
const ST_Field = 3;
 
const SignatureTypeCodeMap = ...;
 
 
const SignatureTypeDescMap = map {$1.value: $1.key.toInt()}, SignatureTypeCodeMap.pairIterator();
 
const ER_Search = (1 << 0);
 
const ER_Field = (1 << 1);
 
const ER_All = ER_Search | ER_Field;
 
const RoleCodeMap = ...;
 
 
const RoleDescMap = map {$1.value: $1.key.toInt()}, RoleCodeMap.pairIterator();
 
const LC_And = (1 << 0);
 
const LC_Or = (1 << 1);
 
const LC_All = (LC_And | LC_Or);
 
const LogicCodeMap = ...;
 
 
const LogicDescMap = map {$1.value: $1.key.toInt()}, LogicCodeMap.pairIterator();
 
public hashdecl DataProviderSignatureTypeInfo {
    AbstractDataProviderType type;
 
    int type_code = ST_Any;
};
 
const DataProviderSignatureFieldType = ...;
 
 
const DataProviderSignatureAnyType = ...;
 
 
const DataProviderSignatureListType = ...;
 
 
const DataProviderSignatureStringValueType = ...;
 
 
const DataProviderSignatureOptionalStringValueType = ...;
 
 
const DataProviderSignatureIntValueType = ...;
 
 
const DataProviderSignatureOptionalIntValueType = ...;
 
 
const DataProviderSignatureListValueType = ...;
 
 
const DataProviderSignatureHashValueType = ...;
 
 
const DataProviderSignatureBoolType = ...;
 
 
const DataProviderSignatureIntType = ...;
 
 
const DataProviderSignatureStringType = ...;
 
 
const DataProviderSignatureDateType = ...;
 
 
const DET_Operator = 1;
 
const DET_Function = 2;
 
const ExpressionTypeCodeMap = ...;
 
 
const ExpressionTypeDescMap = map {$1.value: $1.key.toInt()}, ExpressionTypeCodeMap.pairIterator();
 
const DES_Generic = 1;
 
const DES_LogicOperator = 2;
 
const ExpressionSubtypeCodeMap = ...;
 
 
const ExpressionSubtypeDescMap = map {$1.value: $1.key.toInt()}, ExpressionSubtypeCodeMap.pairIterator();
 
public hashdecl DataProviderArgInfo {
    string display_name;
 
    *string short_desc;
 
    string desc;
 
    auto default_value;
 
    bool sensitive = False;
 
    bool multiselect;
 
    /* In case the arg type is a list, then this will provide the discrete values that can appear in the list
    */
    *softlist<hash<Util::AllowedValueInfo>> allowed_values;
 
    *bool allowed_values_creatable;
 
    /* In case the option type is a list, then this will provide the discrete values that can appear in the list
    */
    *softlist<hash<Util::AllowedValueInfo>> element_allowed_values;
 
    bool element_allowed_values_creatable;
 
 
    auto example_value;
};
 
public hashdecl DataProviderExpressionInfo {
    int type;
 
 
    int subtype = DES_Generic;
 
 
    string name;
 
    string display_name;
 
    string short_desc;
 
 
    string desc;
 
    string symbol;
 
 
    int role = ER_All;
 
 
    *string render_template;
 
    softlist<hash<DataProviderSignatureTypeInfo>> args;
 
    *softlist<hash<DataProviderArgInfo>> arg_info;
 
    AbstractDataProviderType return_type;
 
    bool varargs = False;
 
 
    *list<string> return_type_arg_priority;
 
 
    *bool return_type_first_arg;
};
 
public hashdecl DataProviderFieldReference {
    string field;
};
 
public hashdecl DataProviderExpression {
    string exp;
 
 
    softlist<auto> args;
};
 
public hashdecl DataProviderInfo {
 
    string name;
 
    string display_name;
 
    *string short_desc;
 
 
    *string desc;
 
 
    string type;
 
 
    bool supports_read = False;
 
 
    bool supports_create = False;
 
 
    bool supports_update = False;
 
 
    bool supports_upsert = False;
 
 
    bool supports_delete = False;
 
 
    bool supports_native_search = False;
 
 
    bool supports_bulk_read = False;
 
 
    bool supports_bulk_create = False;
 
 
    bool supports_bulk_upsert = False;
 
 
    bool supports_request = False;
 
 
    bool supports_children = False;
 
 
    bool transaction_management = False;
 
 
    bool has_record = False;
 
 
    bool record_requires_search_options = False;
 
 
    bool supports_child_create = False;
 
 
    bool supports_child_delete = False;
 
 
    bool supports_add_field = False;
 
 
    bool supports_update_field = False;
 
 
    bool supports_delete_field = False;
 
 
    bool supports_schema = False;
 
 
    bool supports_search_expressions = False;
 
 
    bool supports_observable = False;
 
 
    string supports_messages = MSG_None;
 
 
    bool supports_connections = False;
 
 
    bool supports_auto_reconnect = False;
 
 
    bool children_can_support_apis = False;
 
 
    bool children_can_support_records = False;
 
 
    bool children_can_support_observers = False;
 
 
    bool children_can_support_messages = False;
 
 
    bool children_can_support_transactions = False;
 
 
    bool children_identical = False;
 
 
    *string schema_type;
 
 
    *hash<string, hash<DataProviderOptionInfo>> constructor_options;
 
 
    *string required_constructor_options;
 
 
    *hash<string, hash<DataProviderOptionInfo>> create_options;
 
 
    *hash<string, hash<DataProviderOptionInfo>> upsert_options;
 
 
    *hash<string, hash<DataProviderOptionInfo>> search_options;
 
 
    *hash<string, hash<DataProviderOptionInfo>> request_options;
 
 
    *hash<string, hash<DataProviderOptionInfo>> child_create_options;
 
 
    *hash<string, hash<DataProviderOptionInfo>> child_delete_options;
 
 
    *hash<string, hash<DataProviderOptionInfo>> add_field_options;
 
 
    *hash<string, hash<DataProviderOptionInfo>> update_field_options;
 
 
    *hash<string, hash<DataProviderOptionInfo>> delete_field_options;
 
 
    *hash<string, hash<DataProviderOptionInfo>> send_message_options;
 
 
    *hash<string, hash<DataProviderExpressionInfo>> expressions;
 
 
    *hash<string, hash<DataProviderMessageInfo>> events;
 
 
    *hash<string, hash<DataProviderMessageInfo>> messages;
 
 
    int search_logic_capabilities = LC_All;
 
 
    hash<string, hash<MapperRuntimeKeyInfo>> mapper_keys = Mapper::MapperKeyInfo;
 
 
    *string connection_event;
 
 
    *string disconnection_event;
 
 
    *list<string> children;
 
    *hash<auto> info;
};
 
public hashdecl DataProviderConnectionInfo {
    bool connected;
 
    bool reconnecting;
 
    bool auto_reconnect;
 
    *string url;
 
    *hash<auto> info;
};
 
const DataProviderGenericExpressions = ...;
 
 
class AbstractDataProvider : public Logger::LoggerWrapper, public Qore::Serializable {
 
public:
        const GenericExpressionImplementations = ...;
 
 
 
        const GenericExpressions = map {$1.key: $1.value.exp}, GenericExpressionImplementations.pairIterator();
 
        const DataProviderSummaryInfoKeys = map $1.getName(), TypedHash::forName("DataProviderSummaryInfo").getMembers();
 
        const RequiresResultOption = ...;
 
 
 
        const GenericRecordSearchOptions = ...;
 
 
protected:
        static bool callbacks_locked = False;
 
        static code cb_value_needs_resolution;
 
        static code cb_resolve_value;
 
public:
 
    constructor();
 
 
    constructor(LoggerInterface logger) ;
 
 
 
    hash<auto> getInfoAsData(*bool with_type_info);
 
 
    hash<DataProviderInfo> getInfo();
 
 
    hash<DataProviderSummaryInfo> getSummaryInfo();
 
 
 
    string getDisplayName();
 
 
 
    *string getShortDesc();
 
 
    *string getDesc();
 
 
 
    *hash<auto> getAdditionalInfo();
 
 
 
    *hash<auto> createRecordFromOptions(*hash<auto> options);
 
 
 
    *hash<auto> createRecord(hash<auto> rec, *hash<auto> create_options);
 
 
 
    *hash<auto> createRecordsBulkFromOptions(*hash<auto> options);
 
 
 
    *hash<auto> createRecordsBulk(hash<auto> recs, *hash<auto> create_options);
 
 
 
    *hash<auto> createRecordsBulk(AbstractDataProviderBulkRecordInterface stream, *hash<auto> create_options);
 
 
 
    string upsertRecordWithOptions(*hash<auto> options);
 
 
 
    string upsertRecord(hash<auto> rec, *hash<auto> upsert_options);
 
 
 
    *list<string> upsertRecordsBulkWithOptions(*hash<auto> options);
 
 
 
    *list<string> upsertRecordsBulk(hash<auto> recs, *hash<auto> upsert_options);
 
 
 
    *list<string> upsertRecordsBulk(AbstractDataProviderBulkRecordInterface stream, *hash<auto> upsert_options);
 
 
 
    *hash<auto> searchFirstRecordWithOptions(*hash<auto> options);
 
 
 
    *hash<auto> searchFirstRecord(hash<DataProviderExpression> where_cond, *hash<auto> search_options);
 
 
 
    *hash<auto> searchFirstRecord(hash<auto> where_cond, *hash<auto> search_options);
 
 
 
    *hash<auto> searchSingleRecordWithOptions(*hash<auto> options);
 
 
 
    *hash<auto> searchSingleRecord(hash<DataProviderExpression> where_cond, *hash<auto> search_options);
 
 
 
    *hash<auto> searchSingleRecord(*hash<auto> where_cond, *hash<auto> search_options);
 
 
 
    AbstractDataProviderRecordIterator getRecordIterator(*hash<auto> search_options);
 
 
 
    AbstractDataProviderBulkRecordInterface getBulkRecordInterface(int block_size = 1000, *hash<auto> search_options);
 
 
 
    AbstractDataProviderBulkRecordInterface searchRecordsBulkWithOptions(*hash<auto> options);
 
 
 
    AbstractDataProviderBulkRecordInterface searchRecordsBulk(int block_size = 1000, *hash<DataProviderExpression> where_cond, *hash<auto> search_options);
 
 
 
    AbstractDataProviderBulkRecordInterface searchRecordsBulk(int block_size = 1000, *hash<auto> where_cond, *hash<auto> search_options);
 
 
 
    AbstractDataProviderRecordIterator searchRecordsWithOptions(*hash<auto> options);
 
 
 
    AbstractDataProviderRecordIterator searchRecords(*hash<DataProviderExpression> where_cond, *hash<auto> search_options);
 
 
 
    AbstractDataProviderRecordIterator searchRecords(*hash<auto> where_cond, *hash<auto> search_options);
 
 
 
    AbstractDataProviderRecordIterator requestSearchRecords(auto req, *hash<DataProviderExpression> where_cond, *hash<auto> search_options);
 
 
 
    AbstractDataProviderRecordIterator requestSearchRecords(auto req, *hash<auto> where_cond, *hash<auto> search_options);
 
 
 
    bool updateSingleRecordWithOptions(*hash<auto> options);
 
 
 
    bool updateSingleRecord(hash<auto> set, hash<DataProviderExpression> where_cond, *hash<auto> search_options);
 
 
 
    bool updateSingleRecord(hash<auto> set, hash<auto> where_cond, *hash<auto> search_options);
 
 
 
    int updateRecordsWithOptions(*hash<auto> options);
 
 
 
    int updateRecords(hash<auto> set, *hash<DataProviderExpression> where_cond, *hash<auto> search_options);
 
 
 
    int updateRecords(hash<auto> set, *hash<auto> where_cond, *hash<auto> search_options);
 
 
 
    int deleteRecordsWithOptions(*hash<auto> options);
 
 
 
    int deleteRecords(*hash<DataProviderExpression> where_cond, *hash<auto> search_options);
 
 
 
    int deleteRecords(*hash<auto> where_cond, *hash<auto> search_options);
 
 
 
    auto doRequest(auto req, *hash<auto> request_options);
 
 
 
    AbstractDataProvider createChildProvider(string name, hash<string, AbstractDataField> fields, *hash<auto> child_create_options);
 
 
 
    deleteChildProvider(string name, *hash<auto> child_delete_options);
 
 
 
    addField(AbstractDataField field, *hash<auto> field_add_options);
 
 
 
    updateField(string name, AbstractDataField field, *hash<auto> field_update_options);
 
 
 
    deleteField(string name, *hash<auto> field_delete_options);
 
 
 
    sendMessage(string message_id, auto msg, *hash<auto> send_message_options);
 
 
 
    object getSchemaObject();
 
 
 
    *AbstractDataProviderType getRequestType();
 
 
 
    *AbstractDataProviderType getRequestTypeWithData(auto req);
 
 
 
    *AbstractDataProviderType getRequestTypeWithOptions(*hash<auto> options);
 
 
 
    *hash<string, hash<ActionOptionInfo>> tryGetActionOptionsFromRequestTypeWithData(auto req);
 
 
 
    *AbstractDataProviderType getResponseType();
 
 
 
    *AbstractDataProviderType getResponseTypeWithData(auto req);
 
 
 
    *AbstractDataProviderType getResponseTypeWithOptions(*hash<auto> options);
 
 
 
    *hash<string, AbstractDataProviderType> getErrorResponseTypes();
 
 
 
    AbstractDataProviderType getErrorResponseType(string error_code);
 
 
 
    hash<DataProviderMessageInfo> getEventInfo(string event_id);
 
 
 
    hash<DataProviderMessageInfo> getEventInfoWithOptions(string event_id, *hash<auto> options);
 
 
 
    hash<string, hash<DataProviderMessageInfo>> getEventTypes();
 
 
 
    hash<string, hash<DataProviderMessageInfo>> getEventTypesWithOptions(*hash<auto> options);
 
 
 
    *hash<string, hash<ActionOptionInfo>> tryGetActionOptionsWithOptions(hash<DataProviderActionInfo> action, *hash<auto> options);
 
 
 
    hash<DataProviderMessageInfo> getMessageInfo(string message_id);
 
 
 
    hash<string, hash<DataProviderMessageInfo>> getMessageTypes();
 
 
 
    hash<string, hash<DataProviderMessageInfo>> getMessageTypesWithOptions(*hash<auto> options);
 
 
 
    auto getExampleRequestData();
 
 
 
    auto getExampleResponseData();
 
 
 
    auto getExampleErrorResponseData(string error_code);
 
 
 
    auto getExampleEventData(string event_id);
 
 
 
    hash<auto> getExampleRecordData();
 
 
 
    *hash<DataProviderConnectionInfo> getConnectionInfo();
 
 
 
    *list<hash<DataProviderSummaryInfo>> getChildProviderSummaryInfo();
 
 
 
    *list<string> getChildProviderNames();
 
 
 
    *AbstractDataProvider getChildProvider(string name);
 
 
 
    AbstractDataProvider getChildProviderEx(string name);
 
 
 
    AbstractDataProvider getChildProviderPath(string path);
 
 
 
    bool requiresTransactionManagement();
 
 
 
    beginTransaction();
 
 
 
    commit();
 
 
 
    rollback();
 
 
 
    bool currentThreadInTransaction();
 
 
 
    AbstractDataProviderBulkOperation getBulkInserter(*int block_size);
 
 
 
    AbstractDataProviderBulkOperation getBulkUpserter(*int block_size);
 
 
 
    *hash<string, hash<MapperRuntimeKeyInfo>> getMapperRuntimeKeys();
 
 
 
    checkRead();
 
 
 
    checkCreate();
 
 
 
    checkUpsert();
 
 
 
    checkUpdate();
 
 
 
    checkDelete();
 
 
 
    checkRequest();
 
 
 
    checkCreateChild();
 
 
 
    checkDeleteChild();
 
 
 
    checkAddField();
 
 
 
    checkUpdateField();
 
 
 
    checkDeleteField();
 
 
 
    checkSchema();
 
 
 
    checkSearchExpressions();
 
 
 
    checkObservable();
 
 
 
    checkMessages();
 
 
 
    *hash<auto> getSearchExpression(*hash<auto> where_cond, *hash<auto> search_options);
 
 
 
    *hash<string, bool> getSupportedReferenceData();
 
 
 
    *list<hash<AllowedValueInfo>> getReferenceDataSafe(string type, *hash<auto> action_opts);
 
 
 
    *list<hash<AllowedValueInfo>> getReferenceDataSafeEx(string type, *hash<auto> action_opts);
 
 
 
    *list<hash<AllowedValueInfo>> getReferenceData(string type, *hash<auto> action_opts);
 
 
 
    *list<hash<AllowedValueInfo>> getReferenceDataEx(string type, *hash<auto> action_opts);
 
 
 
    *hash<string, bool> getSupportedElementReferenceData();
 
 
 
    *list<hash<AllowedValueInfo>> getElementReferenceDataSafe(string type, *hash<auto> action_opts);
 
 
 
    *list<hash<AllowedValueInfo>> getElementReferenceDataSafeEx(string type, *hash<auto> action_opts);
 
 
 
    *list<hash<AllowedValueInfo>> getElementReferenceData(string type, *hash<auto> action_opts);
 
 
 
    *list<hash<AllowedValueInfo>> getElementReferenceDataEx(string type, *hash<auto> action_opts);
 
 
 
    *hash<string, bool> getSupportedReferenceDataValues();
 
 
 
    auto getReferenceDataValueSafe(string type, *hash<auto> action_opts);
 
 
 
    auto getReferenceDataValueSafeEx(string type, *hash<auto> action_opts);
 
 
 
    auto getReferenceDataValue(string type, *hash<auto> action_opts);
 
 
 
    auto getReferenceDataValueEx(string type, *hash<auto> action_opts);
 
 
 
    updateConnectionObjects(object conn, object connobj);
 
 
 
protected:
     *hash<auto> createRecordsBulkIntern(hash<auto> recs, *hash<auto> create_options);
public:
 
 
protected:
     *hash<string, hash<ActionOptionInfo>> getSearchOptionsAsActionOptions();
public:
 
 
protected:
     *hash<string, hash<ActionOptionInfo>> getOptionsAsActionOptions( *hash<string, hash<DataProviderOptionInfo>> options);
public:
 
 
 
protected:
     *hash<string, hash<ActionOptionInfo>> tryGetActionOptionsForEventWithOptionsImpl( hash<DataProviderActionInfo> action, *hash<auto> options);
public:
 
 
 
protected:
     *hash<string, hash<ActionOptionInfo>> tryGetActionOptionsForRequestWithOptionsImpl( hash<DataProviderActionInfo> action, *hash<auto> options);
public:
 
 
 
protected:
     *hash<string, hash<ActionOptionInfo>> tryGetActionOptionsForMessageWithOptionsImpl( hash<DataProviderActionInfo> action, *hash<auto> options);
public:
 
 
 
protected:
     *hash<string, hash<ActionOptionInfo>> tryGetActionOptionsForSearchWithOptionsImpl( hash<DataProviderActionInfo> action, *hash<auto> options);
public:
 
 
 
protected:
     *hash<string, hash<ActionOptionInfo>> tryGetActionOptionsForCreateWithOptionsImpl( hash<DataProviderActionInfo> action, *hash<auto> options);
public:
 
 
 
protected:
     *hash<string, hash<ActionOptionInfo>> tryGetActionOptionsForUpsertWithOptionsImpl( hash<DataProviderActionInfo> action, *hash<auto> options);
public:
 
 
 
protected:
     *hash<string, hash<ActionOptionInfo>> tryGetActionOptionsForUpdateWithOptionsImpl( hash<DataProviderActionInfo> action, *hash<auto> options);
public:
 
 
 
protected:
     *hash<string, hash<ActionOptionInfo>> tryGetActionOptionsForDeleteWithOptionsImpl( hash<DataProviderActionInfo> action, *hash<auto> options);
public:
 
 
 
protected:
     *hash<string, hash<ActionOptionInfo>> tryGetActionOptionsWithOptionsImpl( hash<DataProviderActionInfo> action, *hash<auto> options);
public:
 
 
 
protected:
     hash<DataProviderExpression> getSimpleArgumentIntern(int role, hash<DataProviderInfo> info, hash<DataProviderExpressionInfo> expinfo, string key, auto value);
public:
 
 
 
protected:
     hash<DataProviderExpression> getEqualityComparisonExpression(int role, hash<DataProviderInfo> info, string key, auto value);
public:
 
 
 
protected:
      static hash<DataProviderExpressionInfo> getExpression(int role, string exp, *hash<string, hash<DataProviderExpressionInfo>> expmap);
public:
 
 
 
      static bool setDynamicValueCallbacks();
 
 
      static auto evalGenericExpressionValue(hash<auto> rec, auto val);
            return rv;
        };
        if (val instanceof hash<DataProviderExpression>);
 
        return val;
    };
 
 
      static auto evalGenericExpression(hash<auto> rec, hash<DataProviderExpression> exp);
 
 
      static bool setDynamicValueCallbacks(code value_needs_resolution, code resolve_value);
 
 
      static verifyExpression(int role, *hash<string, hash<DataProviderExpressionInfo>> expmap, int caps, AbstractDataProviderType expected_type, hash<DataProviderExpression> exp);
 
 
      static verifyExpression(int role, hash<DataProviderExpressionInfo> expinfo, int caps, AbstractDataProviderType expected_type, hash<DataProviderExpression> exp);
 
 
      static verifyExpressionArgValue(int role, int caps, hash<DataProviderExpressionInfo> expinfo, softlist<auto> values, int pos);
 
protected:
      static bool checkCallbacks();
public:
 
 
 
protected:
     *hash<auto> validateCreateOptions(*hash<auto> create_options);
public:
 
 
 
protected:
     *hash<auto> validateUpsertOptions(*hash<auto> upsert_options);
public:
 
 
 
protected:
     *hash<auto> validateSearchOptions(*hash<auto> search_options);
public:
 
 
 
protected:
     *hash<auto> validateRequestOptions(*hash<auto> request_options);
public:
 
 
 
protected:
     *hash<auto> validateChildCreateOptions(*hash<auto> child_create_options);
public:
 
 
 
protected:
     *hash<auto> validateChildDeleteOptions(*hash<auto> child_delete_options);
public:
 
 
 
protected:
     *hash<auto> validateFieldAddOptions(*hash<auto> field_add_options);
public:
 
 
 
protected:
     *hash<auto> validateFieldUpdateOptions(*hash<auto> field_update_options);
public:
 
 
 
protected:
     *hash<auto> validateFieldDeleteOptions(*hash<auto> field_delete_options);
public:
 
 
 
protected:
     *hash<auto> validateSendMessageOptions(*hash<auto> send_message_options);
public:
 
 
protected:
     processConstructorOptions(*hash<string, hash<DataProviderOptionInfo>> option_desc, *hash<auto> options, *string required_options);
public:
 
 
 
protected:
     *hash<auto> checkOptions(string err, *hash<string, hash<DataProviderOptionInfo>> option_desc, *hash<auto> uoptions, *string required_options);
public:
 
 
 
protected:
     verifyRequiredOptions(string err, *hash<auto> options, string required_options);
public:
 
 
 
protected:
     *hash<DataProviderExpression> processSearchParameters(*hash<DataProviderExpression> exp, *hash<auto> search_options);
public:
 
 
 
protected:
     *hash<auto> processFieldValues(*hash<auto> h, *hash<auto> search_options);
public:
 
 
    bool searchAcceptsForeignField(string field);
 
 
 
    *hash<string, AbstractDataField> getRecordType(*hash<auto> search_options);
 
 
 
    *hash<string, AbstractDataField> getCreateRecordType(*hash<auto> create_options);
 
 
 
    *hash<string, AbstractDataField> getUpdateRecordType(*hash<auto> search_options);
 
 
    *hash<string, AbstractDataField> getSoftRecordType(*hash<auto> search_options);
 
 
    *hash<string, AbstractDataField> getOrNothingRecordType(*hash<auto> search_options);
 
 
 
    *hash<string, AbstractDataField> getRecordTypeWithOptions(*hash<auto> options, *hash<auto> search_options);
 
 
 
    *hash<string, AbstractDataField> getCreateRecordTypeWithOptions(*hash<auto> options, *hash<auto> create_options);
 
 
 
    *hash<string, AbstractDataField> getUpdateRecordTypeWithOptions(*hash<auto> options, *hash<auto> search_options);
 
 
    *hash<string, AbstractDataField> getSoftRecordTypeWithOptions(*hash<auto> options, *hash<auto> search_options);
 
 
    *hash<string, AbstractDataField> getOrNothingRecordTypeWithOptions(*hash<auto> options, *hash<auto> search_options);
 
 
 
    *hash<string, hash<DataProviderOptionInfo>> getSearchOptions();
 
 
 
    *hash<string, hash<DataProviderOptionInfo>> getCreateOptions();
 
 
 
    *hash<string, hash<DataProviderOptionInfo>> getUpsertOptions();
 
 
 
    *hash<string, hash<DataProviderOptionInfo>> getRequestOptions();
 
 
 
    *hash<string, hash<DataProviderOptionInfo>> getChildCreateOptions();
 
 
 
    *hash<string, hash<DataProviderOptionInfo>> getChildDeleteOptions();
 
 
 
    *hash<string, hash<DataProviderOptionInfo>> getFieldAddOptions();
 
 
 
    *hash<string, hash<DataProviderOptionInfo>> getFieldUpdateOptions();
 
 
 
    *hash<string, hash<DataProviderOptionInfo>> getFieldDeleteOptions();
 
 
 
    *hash<string, hash<DataProviderOptionInfo>> getSendMessageOptions();
 
 
 
    string getMessageSupport();
 
 
 
    bool supportsRead();
 
 
 
    bool supportsBulkRead();
 
 
 
    bool supportsCreate();
 
 
 
    bool supportsUpdate();
 
 
 
    bool supportsUpsert();
 
 
 
    bool supportsDelete();
 
 
 
    bool supportsNativeSearch();
 
 
 
    bool supportsBulkCreate();
 
 
 
    bool supportsBulkUpsert();
 
 
 
    bool supportsRequest();
 
 
 
    bool recordRequiresSearchOptions();
 
 
 
    bool hasRecord();
 
 
 
    bool supportsCreateChild();
 
 
 
    bool supportsDeleteChild();
 
 
 
    bool supportsAddField();
 
 
 
    bool supportsUpdateField();
 
 
 
    bool supportsDeleteField();
 
 
 
    bool supportsSchema();
 
 
 
    bool supportsSearchExpressions();
 
 
 
    bool supportsObservable();
 
 
 
    bool supportsMessages();
 
 
 
    *object getSchemaType();
 
 
 
    bool supportsChildren();
 
 
 
    bool childrenIdentical();
 
 
 
      static registerChild(string name, code generator);
 
protected:
     error(string err, string fmt, ...);
public:
 
 
 
protected:
     *hash<auto> searchFirstRecordImpl(hash<auto> where_cond, *hash<auto> search_options);
public:
 
 
 
protected:
     *hash<auto> searchSingleRecordImpl(*hash<auto> where_cond, *hash<auto> search_options);
public:
 
 
 
protected:
     *list<string> getChildProviderNamesImpl();
public:
 
 
 
protected:
     *AbstractDataProvider getChildProviderImpl(string name);
public:
 
 
 
protected:
     *hash<DataProviderConnectionInfo> getConnectionInfoImpl();
public:
 
 
 
protected:
     hash<auto> generateExampleData(hash<string, AbstractDataField> fields);
public:
 
 
 
protected:
     *hash<string, AbstractDataField> getRecordTypeImpl(*hash<auto> search_options);
public:
 
 
 
protected:
     *hash<string, AbstractDataField> getUpdateRecordTypeImpl(*hash<auto> search_options);
public:
 
 
 
protected:
     *hash<string, AbstractDataField> getCreateRecordTypeImpl(*hash<auto> create_options);
public:
 
 
 
protected:
     *hash<string, AbstractDataField> getRecordTypeWithOptionsImpl(*hash<auto> options, *hash<auto> search_options);
public:
 
 
 
protected:
     *hash<string, AbstractDataField> getCreateRecordTypeWithOptionsImpl(*hash<auto> options, *hash<auto> create_options);
public:
 
 
 
protected:
     *hash<string, AbstractDataField> getUpdateRecordTypeWithOptionsImpl(*hash<auto> options, *hash<auto> search_options);
public:
 
 
 
protected:
     AbstractDataProviderBulkRecordInterface searchRecordsBulkImpl(int block_size = 1000, *hash<auto> where_cond, *hash<auto> search_options);
public:
 
 
 
protected:
     AbstractDataProviderRecordIterator searchRecordsImpl(*hash<auto> where_cond, *hash<auto> search_options);
public:
 
 
 
protected:
     AbstractDataProviderRecordIterator requestSearchRecordsImpl(auto req, *hash<auto> where_cond, *hash<auto> search_options);
public:
 
 
 
protected:
     *hash<auto> createRecordImpl(hash<auto> rec, *hash<auto> create_options);
public:
 
 
 
protected:
     *hash<auto> createRecordsBulkImpl(hash<auto> recs, *hash<auto> create_options);
public:
 
 
 
protected:
     string upsertRecordImpl(hash<auto> rec, *hash<auto> upsert_options);
public:
 
 
 
protected:
     *list<string> upsertRecordsBulkImpl(hash<auto> recs, *hash<auto> upsert_options);
public:
 
 
 
protected:
     bool updateSingleRecordImpl(hash<auto> set, hash<auto> where_cond, *hash<auto> search_options);
public:
 
 
 
protected:
     int updateRecordsImpl(hash<auto> set, *hash<auto> where_cond, *hash<auto> search_options);
public:
 
 
 
protected:
     int deleteRecordsImpl(*hash<auto> where_cond, *hash<auto> search_options);
public:
 
 
 
protected:
     auto doRequestImpl(auto req, *hash<auto> request_options);
public:
 
 
 
protected:
     AbstractDataProvider createChildProviderImpl(string name, hash<string, AbstractDataField> fields, *hash<auto> child_create_options);
public:
 
 
 
protected:
     deleteChildProviderImpl(string name, *hash<auto> child_delete_options);
public:
 
 
 
protected:
     addFieldImpl(AbstractDataField field, *hash<auto> field_add_options);
public:
 
 
 
protected:
     updateFieldImpl(string name, AbstractDataField field, *hash<auto> field_update_options);
public:
 
 
 
protected:
     deleteFieldImpl(string name, *hash<auto> field_delete_options);
public:
 
 
 
protected:
     sendMessageImpl(string message_id, auto msg, *hash<auto> send_message_options);
public:
 
 
 
protected:
     object getSchemaObjectImpl();
public:
 
 
 
protected:
     *AbstractDataProviderType getRequestTypeImpl();
public:
 
 
 
protected:
     *AbstractDataProviderType getRequestTypeWithDataImpl(auto req);
public:
 
 
 
protected:
     *AbstractDataProviderType getRequestTypeWithOptionsImpl(*hash<auto> options);
public:
 
 
 
protected:
     *AbstractDataProviderType getResponseTypeImpl();
public:
 
 
 
protected:
     *AbstractDataProviderType getResponseTypeWithDataImpl(auto req);
public:
 
 
 
protected:
     *AbstractDataProviderType getResponseTypeWithOptionsImpl(hash<auto> options);
public:
 
 
 
protected:
     *hash<string, AbstractDataProviderType> getErrorResponseTypesImpl();
public:
 
 
 
protected:
     AbstractDataProviderType getErrorResponseTypeImpl(string error_code);
public:
 
 
 
protected:
     hash<DataProviderMessageInfo> getEventInfoImpl(string event_id);
public:
 
 
 
protected:
     hash<DataProviderMessageInfo> getEventInfoWithOptionsImpl(string event_id, *hash<auto> options);
public:
 
 
 
protected:
     hash<string, hash<DataProviderMessageInfo>> getEventTypesImpl();
public:
 
 
 
protected:
     hash<string, hash<DataProviderMessageInfo>> getEventTypesWithOptionsImpl(hash<auto> options);
public:
 
 
 
protected:
     hash<DataProviderMessageInfo> getMessageInfoImpl(string message_id);
public:
 
 
 
protected:
     hash<string, hash<DataProviderMessageInfo>> getMessageTypesImpl();
public:
 
 
 
protected:
     hash<string, hash<DataProviderMessageInfo>> getMessageTypesWithOptionsImpl(hash<auto> options);
public:
 
 
 
protected:
     throwUnimplementedException();
public:
 
 
 
protected:
     auto getExampleRequestDataImpl();
public:
 
 
 
protected:
     auto getExampleResponseDataImpl();
public:
 
 
 
protected:
     auto getExampleErrorResponseDataImpl(string error_code);
public:
 
 
 
protected:
     auto getExampleEventDataImpl(string event_id);
public:
 
 
 
protected:
     hash<auto> getExampleRecordDataImpl();
public:
 
 
 
protected:
     *list<hash<AllowedValueInfo>> getReferenceDataImpl(string type, *hash<auto> action_opts);
public:
 
 
 
protected:
     *list<hash<AllowedValueInfo>> getElementReferenceDataImpl(string type, *hash<auto> action_opts);
public:
 
 
 
protected:
     auto getReferenceDataValueImpl(string type, *hash<auto> action_opts);
public:
 
 
 
protected:
     bool currentThreadInTransactionImpl();
public:
 
 
    abstract string getName();
 
protected:
     abstract hash<DataProviderInfo> getStaticInfoImpl();
public:
}
}