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 AllowedValueInfo {
    auto value;
 
    string desc;
};
 
public hashdecl DataProviderOptionInfo {
    softlist<AbstractDataProviderType> type;
 
    bool required = False;
 
    string desc;
 
    auto default_value;
 
    bool sensitive = False;
 
    *softlist<hash<AllowedValueInfo>> allowed_values;
};
 
public hashdecl DataProviderSummaryInfo {
    string name;
 
    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 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;
};
 
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 = {
    ST_Any: "any",
    ST_Value: "value",
    ST_Field: "field reference",
};
 
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 = {
    ER_Search: "search",
};
 
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 = {
    LC_And: "AND",
    LC_Or: "OR",
};
 
const LogicDescMap = map {$1.value: $1.key.toInt()}, LogicCodeMap.pairIterator();
 
public hashdecl DataProviderSignatureTypeInfo {
    AbstractDataProviderType type;
 
    int type_code = ST_Any;
};
 
const DataProviderSignatureFieldType = <DataProviderSignatureTypeInfo>{
    "type": AbstractDataProviderTypeMap."any",
    "type_code": ST_Field,
};
 
const DataProviderSignatureAnyType = <DataProviderSignatureTypeInfo>{
    "type": AbstractDataProviderTypeMap."any",
    "type_code": ST_Any,
};
 
const DataProviderSignatureStringValueType = <DataProviderSignatureTypeInfo>{
    "type": AbstractDataProviderTypeMap."string",
    "type_code": ST_Value,
};
 
const DataProviderSignatureOptionalStringValueType = <DataProviderSignatureTypeInfo>{
    "type": AbstractDataProviderTypeMap."*string",
    "type_code": ST_Value,
};
 
const DataProviderSignatureIntValueType = <DataProviderSignatureTypeInfo>{
    "type": AbstractDataProviderTypeMap."int",
    "type_code": ST_Value,
};
 
const DataProviderSignatureOptionalIntValueType = <DataProviderSignatureTypeInfo>{
    "type": AbstractDataProviderTypeMap."*int",
    "type_code": ST_Value,
};
 
const DataProviderSignatureListValueType = <DataProviderSignatureTypeInfo>{
    "type": AbstractDataProviderTypeMap."list",
    "type_code": ST_Value,
};
 
const DataProviderSignatureHashValueType = <DataProviderSignatureTypeInfo>{
    "type": AbstractDataProviderTypeMap."hash",
    "type_code": ST_Value,
};
 
const DataProviderSignatureBoolType = <DataProviderSignatureTypeInfo>{
    "type": AbstractDataProviderTypeMap."bool",
    "type_code": ST_Any,
};
 
const DataProviderSignatureStringType = <DataProviderSignatureTypeInfo>{
    "type": AbstractDataProviderTypeMap."string",
    "type_code": ST_Any,
};
 
const DataProviderSignatureDateType = <DataProviderSignatureTypeInfo>{
    "type": AbstractDataProviderTypeMap."date",
    "type_code": ST_Any,
};
 
const DET_Operator = 1;
 
const DET_Function = 2;
 
const ExpressionTypeCodeMap = {
    DET_Operator: "operator",
    DET_Function: "function",
};
 
const ExpressionTypeDescMap = map {$1.value: $1.key.toInt()}, ExpressionTypeCodeMap.pairIterator();
 
public hashdecl DataProviderExpressionInfo {
    int type;
 
 
    string label;
 
    string name;
 
    string desc;
 
    string symbol;
 
 
    int role = ER_All;
 
    softlist<hash<DataProviderSignatureTypeInfo>> args;
 
    AbstractDataProviderType return_type;
 
    bool varargs = False;
};
 
public hashdecl DataProviderFieldReference {
    string field;
};
 
public hashdecl DataProviderExpression {
    string exp;
 
 
    softlist<auto> args;
};
 
public hashdecl DataProviderInfo {
 
    string name;
 
 
    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 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;
 
 
    *string schema_type;
 
 
    *hash<string, hash<DataProviderOptionInfo>> 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 desc;
 
 
    *list<string> children;
};
 
class AbstractDataProvider {
 
public:
        const GenericExpressionImplementations = {
            DP_OP_AND: {
                "exp": <DataProviderExpressionInfo>{
                    "type": DET_Operator,
                    "label": DP_OP_AND,
                    "name": "and (&&)",
                    "desc": "logical AND operation supporting logic short-circuiting",
                    "symbol": "&&",
                    "args": (DataProviderSignatureBoolType),
                    "varargs": True,
                    "return_type": AbstractDataProviderTypeMap."bool",
                },
                "impl": auto sub (hash<auto> rec, hash<DataProviderExpression> exp) {
                    foreach auto arg in (exp.args) {
                        if (!AbstractDataProvider::evalGenericExpressionValue(rec, arg)) {
                            return False;
                        }
                    }
                    return True;
                },
            },
            DP_OP_OR: {
                "exp": <DataProviderExpressionInfo>{
                    "type": DET_Operator,
                    "label": DP_OP_OR,
                    "name": "or (||)",
                    "desc": "logical OR operation supporting logic short-circuiting",
                    "symbol": "||",
                    "args": (DataProviderSignatureBoolType),
                    "varargs": True,
                    "return_type": AbstractDataProviderTypeMap."bool",
                },
                "impl": auto sub (hash<auto> rec, hash<DataProviderExpression> exp) {
                    foreach auto arg in (exp.args) {
                        if (AbstractDataProvider::evalGenericExpressionValue(rec, arg)) {
                            return True;
                        }
                    }
                    return False;
                },
            },
            DP_SEARCH_OP_EQ: {
                "exp": <DataProviderExpressionInfo>{
                    "type": DET_Operator,
                    "label": DP_SEARCH_OP_EQ,
                    "name": "equals (=)",
                    "desc": "a value for equality comparisons; the type of the value should correspond to the field "
                        "type",
                    "symbol": "==",
                    "args": (DataProviderSignatureAnyType, DataProviderSignatureAnyType),
                    "return_type": AbstractDataProviderTypeMap."bool",
                },
                "impl": auto sub (hash<auto> rec, hash<DataProviderExpression> exp) {
                    auto arg0 = AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[0]);
                    auto arg1 = AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[1]);
                    // for backwards compatibility, if the first argument is a field reference, and the second is a
                    # hash
 
                    return arg0 == arg1;
                },
            },
            DP_SEARCH_OP_NE: {
                "exp": <DataProviderExpressionInfo>{
                    "type": DET_Operator,
                    "label": DP_SEARCH_OP_NE,
                    "name": "not equals (!=)",
                    "desc": "a value for not-equals comparisons; the type of the value should correspond to the "
                        "field type",
                    "symbol": "!=",
                    "args": (DataProviderSignatureAnyType, DataProviderSignatureAnyType),
                    "return_type": AbstractDataProviderTypeMap."bool",
                },
                "impl": auto sub (hash<auto> rec, hash<DataProviderExpression> exp) {
                    return AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[0])
                        != AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[1]);
                },
            },
            DP_SEARCH_OP_LT: {
                "exp": <DataProviderExpressionInfo>{
                    "type": DET_Operator,
                    "label": DP_SEARCH_OP_LT,
                    "name": "less than (<)",
                    "desc": "a value for less than comparisons; if the field value is less than the argument, then "
                        "the operation returns true; the type of the value should correspond to the field type",
                    "symbol": "<",
                    "args": (DataProviderSignatureAnyType, DataProviderSignatureAnyType),
                    "return_type": AbstractDataProviderTypeMap."bool",
                },
                "impl": auto sub (hash<auto> rec, hash<DataProviderExpression> exp) {
                    return AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[0])
                        < AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[1]);
                },
            },
            DP_SEARCH_OP_LE: {
                "exp": <DataProviderExpressionInfo>{
                    "type": DET_Operator,
                    "label": DP_SEARCH_OP_LE,
                    "name": "less than or equals (<=)",
                    "desc": "a value for less than or equals comparisons; if the field value is less than or equal "
                        "to the argument, then the operation returns true; the type of the value should correspond "
                        "to the field type",
                    "symbol": "<=",
                    "args": (DataProviderSignatureAnyType, DataProviderSignatureAnyType),
                    "return_type": AbstractDataProviderTypeMap."bool",
                },
                "impl": auto sub (hash<auto> rec, hash<DataProviderExpression> exp) {
                    return AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[0])
                        <= AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[1]);
                },
            },
            DP_SEARCH_OP_GT: {
                "exp": <DataProviderExpressionInfo>{
                    "type": DET_Operator,
                    "label": DP_SEARCH_OP_GT,
                    "name": "greater than (>)",
                    "desc": "a value for less than comparisons; if the field value is less than the argument, then "
                        "the operation returns true; the type of the value should correspond to the field type",
                    "symbol": ">",
                    "args": (DataProviderSignatureAnyType, DataProviderSignatureAnyType),
                    "return_type": AbstractDataProviderTypeMap."bool",
                },
                "impl": auto sub (hash<auto> rec, hash<DataProviderExpression> exp) {
                    return AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[0])
                        > AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[1]);
                },
            },
            DP_SEARCH_OP_GE: {
                "exp": <DataProviderExpressionInfo>{
                    "type": DET_Operator,
                    "label": DP_SEARCH_OP_GE,
                    "name": "greater than or equals (>=)",
                    "desc": "a value for greater than or equals comparisons; if the field value is greater than or "
                        "equal to the argument, then the operation returns true; the type of the value should "
                        "correspond to the field type",
                    "symbol": ">=",
                    "args": (DataProviderSignatureAnyType, DataProviderSignatureAnyType),
                    "return_type": AbstractDataProviderTypeMap."bool",
                },
                "impl": auto sub (hash<auto> rec, hash<DataProviderExpression> exp) {
                    return AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[0])
                        >= AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[1]);
                },
            },
            DP_SEARCH_OP_BETWEEN: {
                "exp": <DataProviderExpressionInfo>{
                    "type": DET_Operator,
                    "label": DP_SEARCH_OP_BETWEEN,
                    "name": "between",
                    "desc": "A list with two elements giving the lower and upper bounds of the field value; the list "
                        "element value types must be equal to the field's type",
                    "symbol": "between",
                    "args": (
                        DataProviderSignatureAnyType,
                        DataProviderSignatureAnyType,
                        DataProviderSignatureAnyType,
                    ),
                    "return_type": AbstractDataProviderTypeMap."bool",
                },
                "impl": auto sub (hash<auto> rec, hash<DataProviderExpression> exp) {
                    auto arg0 = AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[0]);
                    return arg0 > AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[1])
                        && arg0 < AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[2]);
                },
            },
            DP_SEARCH_OP_IN: {
                "exp": <DataProviderExpressionInfo>{
                    "type": DET_Operator,
                    "label": DP_SEARCH_OP_IN,
                    "name": "in",
                    "desc": "A list giving possible values of the field;  if the field's value matches any of the "
                        "values in the list, then the operation returns true; element value types must be equal to "
                        "the field's type",
                    "symbol": "in",
                    "args": (DataProviderSignatureAnyType),
                    "return_type": AbstractDataProviderTypeMap."bool",
                    "varargs": True,
                },
                "impl": auto sub (hash<auto> rec, hash<DataProviderExpression> exp) {
                    return inlist(AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[0]),
                        AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[1]));
                },
            },
            DP_SEARCH_OP_NOT: {
                "exp": <DataProviderExpressionInfo>{
                    "type": DET_Operator,
                    "label": DP_SEARCH_OP_NOT,
                    "name": "logical not (!)",
                    "desc": "This operator reverses the logcal value of the operator expression given as an argument",
                    "symbol": "!",
                    "args": (DataProviderSignatureBoolType,),
                    "return_type": AbstractDataProviderTypeMap."bool",
                },
                "impl": auto sub (hash<auto> rec, hash<DataProviderExpression> exp) {
                    return (!AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[0]));
                },
            },
            DP_SEARCH_OP_REGEX: {
                "exp": <DataProviderExpressionInfo>{
                    "type": DET_Operator,
                    "label": DP_SEARCH_OP_REGEX,
                    "name": "regular expression match",
                    "desc": "regular expression operator; the first argument will be processed with the second as a "
                        "regular expression pattern",
                    "symbol": "regex",
                    "args": (
                        DataProviderSignatureStringType,
                        <DataProviderSignatureTypeInfo>{
                            "type": (new HashDataType())
                                .addField(new QoreDataField("pattern", "the regular expression pattern",
                                    AbstractDataProviderTypeMap."string"))
                                .addField(new QoreDataField("options", "regular expression options",
                                    AbstractDataProviderTypeMap."*int")),
                        },
                    ),
                    "return_type": AbstractDataProviderTypeMap."bool",
                },
                "impl": auto sub (hash<auto> rec, hash<DataProviderExpression> exp) {
                    auto arg1 = AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[1]);
                    return regex(AbstractDataProvider::evalGenericExpressionValue(rec, exp.args[0]).toString(),
                        arg1.pattern, arg1.options);
                },
            },
        };
 
 
        const GenericExpressions = map {$1.key: $1.value.exp}, GenericExpressionImplementations.pairIterator();
 
        const DataProviderSummaryInfoKeys = map $1.getName(),
            TypedHash::forName("DataProviderSummaryInfo").getMembers();
 
protected:
        *Logger logger;
 
        static bool callbacks_locked = False;
 
        static code cb_value_needs_resolution;
 
        static code cb_resolve_value;
 
 
        const GenericRecordSearchOptions = {
            "columns": <DataProviderOptionInfo>{
                "type": AbstractDataProviderTypeMap."any",
                "desc": "allows a subset of fields to be output in searches",
            },
            "limit": <DataProviderOptionInfo>{
                "type": AbstractDataProviderType::get(IntType),
                "desc": "the maximum number of records to return",
            },
            "offset": <DataProviderOptionInfo>{
                "type": AbstractDataProviderType::get(IntType),
                "desc": "the offset number in records to return",
            },
        };
 
public:
 
    constructor();
 
 
    constructor(Logger logger);
 
 
    setLogger(Logger logger);
 
 
 
    hash<auto> getInfoAsData(*bool with_type_info);
 
 
    hash<DataProviderInfo> getInfo();
 
 
    hash<DataProviderSummaryInfo> getSummaryInfo();
 
 
    *string getDesc();
 
 
 
    *hash<auto> createRecord(hash<auto> rec, *hash<auto> create_options);
 
 
 
    string upsertRecord(hash<auto> rec, *hash<auto> upsert_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> 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) {
        checkRead();
        return searchRecordsBulk(block_size, NOTHING, validateSearchOptions(search_options));
    }
 
 
    AbstractDataProviderBulkRecordInterface searchRecordsBulk(int block_size = 1000,
            *hash<DataProviderExpression> where_cond, *hash<auto> search_options) {
        checkRead();
        if (block_size <= 0);
 
        search_options = validateSearchOptions(search_options);
        return searchRecordsBulkImpl(block_size, processSearchParameters(where_cond, search_options),
            search_options);
    }
 
 
    AbstractDataProviderBulkRecordInterface searchRecordsBulk(int block_size = 1000, *hash<auto> where_cond,
            *hash<auto> search_options) {
        checkRead();
        if (block_size <= 0);
 
        search_options = validateSearchOptions(search_options);
        return searchRecordsBulkImpl(block_size, getSearchExpression(where_cond, search_options), search_options);
    }
 
 
    AbstractDataProviderRecordIterator searchRecords(*hash<DataProviderExpression> where_cond,
            *hash<auto> search_options) {
        checkRead();
        search_options = validateSearchOptions(search_options);
        return searchRecordsImpl(processSearchParameters(where_cond, search_options), search_options);
    }
 
 
    AbstractDataProviderRecordIterator searchRecords(*hash<auto> where_cond, *hash<auto> search_options);
 
 
 
    AbstractDataProviderRecordIterator requestSearchRecords(auto req, *hash<DataProviderExpression> where_cond,
            *hash<auto> search_options) {
        checkRead();
        checkRequest();
        return requestSearchRecordsImpl(req, processSearchParameters(where_cond, search_options), search_options);
    }
 
 
    AbstractDataProviderRecordIterator requestSearchRecords(auto req, *hash<auto> where_cond,
            *hash<auto> search_options) {
        checkRead();
        checkRequest();
        return requestSearchRecordsImpl(req, getSearchExpression(where_cond, search_options), search_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 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 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) {
        checkCreateChild();
        child_create_options = validateChildCreateOptions(child_create_options);
        if (!fields);
 
        on_error if (1.err != 'CREATE-CHILD-PROVIDER-ERROR');
 
        return createChildProviderImpl(name, fields, 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 getResponseType();
 
 
 
    *hash<string, AbstractDataProviderType> getErrorResponseTypes();
 
 
 
    AbstractDataProviderType getErrorResponseType(string error_code);
 
 
 
    hash<DataProviderMessageInfo> getEventInfo(string event_id);
 
 
 
    hash<string, hash<DataProviderMessageInfo>> getEventTypes();
 
 
 
    hash<DataProviderMessageInfo> getMessageInfo(string message_id);
 
 
 
    hash<string, hash<DataProviderMessageInfo>> getMessageTypes();
 
 
 
    *list<hash<DataProviderSummaryInfo>> getChildProviderSummaryInfo();
 
 
 
    *list<string> getChildProviderNames();
 
 
 
    *AbstractDataProvider getChildProvider(string name);
 
 
 
    AbstractDataProvider getChildProviderEx(string name);
 
 
 
    AbstractDataProvider getChildProviderPath(string path);
 
 
 
    bool requiresTransactionManagement();
 
 
 
    beginTransaction();
 
 
 
    commit();
 
 
 
    rollback();
 
 
 
    AbstractDataProviderBulkOperation getBulkInserter();
 
 
 
    AbstractDataProviderBulkOperation getBulkUpserter();
 
 
 
    *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);
 
 
 
    private hash<DataProviderExpression> getSimpleArgumentIntern(int role, hash<DataProviderInfo> info,
            hash<DataProviderExpressionInfo> expinfo, string key, auto value) {
        // remove any unique suffix from key to get field name
        key =~ s/:.*//g;
        hash<DataProviderExpression> rv;
        if (value.typeCode() == NT_HASH && value.op && value.hasKey('arg'));
 else {
            rv = getEqualityComparisonExpression(role, info, key, value);
        }
        int caps = role == ER_Search ? info.search_logic_capabilities : 0;
        verifyExpression(role, info.expressions, caps, AbstractDataProviderTypeMap."bool", rv);
        return rv;
    }
 
 
    private hash<DataProviderExpression> getEqualityComparisonExpression(int role, hash<DataProviderInfo> info,
            string key, auto value) {
        if (!info.expressions.'=');
 
        return <DataProviderExpression>{
            "exp": "=",
            "args": (<DataProviderFieldReference>{"field": key},) + value,
        };
    }
 
 
    static private hash<DataProviderExpressionInfo> getExpression(int role, string exp,
            *hash<string, hash<DataProviderExpressionInfo>> expmap) {
        *hash<DataProviderExpressionInfo> expinfo = expmap{exp};
        if (!expinfo);
 
        if (!(expinfo.role & role));
 
        return expinfo;
    }
 
 
      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) {
        hash<DataProviderExpressionInfo> expinfo = AbstractDataProvider::getExpression(role, exp.exp, expmap);
        return AbstractDataProvider::verifyExpression(role, expinfo, caps, expected_type, exp);
    }
 
 
    static verifyExpression(int role, hash<DataProviderExpressionInfo> expinfo, int caps,
            AbstractDataProviderType expected_type, hash<DataProviderExpression> exp) {
        // check arguments
        if (exp.args.lsize() > expinfo.args.size() && !expinfo.varargs);
 
        map AbstractDataProvider::verifyExpressionArgValue(role, caps, expinfo, exp.args, //), expinfo.args;
        if (exp.args.lsize() > expinfo.args.size());
 
        if (!expected_type.isAssignableFrom(expinfo.return_type));
 
    }
 
 
    static verifyExpressionArgValue(int role, int caps, hash<DataProviderExpressionInfo> expinfo,
            softlist<auto> values, int pos) {
        hash<DataProviderSignatureTypeInfo> arginfo = expinfo.args[pos] ?? expinfo.args.last();
        if (arginfo.type_code == ST_Any);
 
        auto val = values[pos];
        bool is_exp = val instanceof hash<DataProviderExpression>;
        bool is_ref = is_exp ? False : val instanceof hash<DataProviderFieldReference>;
 
        switch (arginfo.type_code);
 
    }
 
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);
public:
 
 
    private *hash<auto> checkOptions(string err, *hash<string, hash<DataProviderOptionInfo>> option_desc,
            *hash<auto> uoptions) {
        // to ensure that the return value has type "hash<auto>"
        hash<auto> options += uoptions;
        if (!option_desc && options);
 
        if (*list<string> invalid_keys = keys (options - (keys option_desc)));
 
        // check types and required keys
        foreach hash<auto> i in (option_desc.pairIterator());
 
        return options;
    }
 
 
    private *hash<DataProviderExpression> processSearchParameters(*hash<DataProviderExpression> exp,
            *hash<auto> search_options) {
        if (!exp);
 
        checkSearchExpressions();
        hash<DataProviderInfo> info = getInfo();
        verifyExpression(ER_Search, info.expressions, info.search_logic_capabilities,
            AbstractDataProviderTypeMap."bool", exp);
        return exp;
    }
 
 
protected:
     *hash<auto> processFieldValues(*hash<auto> h, *hash<auto> search_options);
public:
 
 
protected:
     error(string err, string fmt);
public:
 
 
 
    private *hash<auto> searchFirstRecordImpl(hash<auto> where_cond,
            *hash<auto> search_options) {
        // scans the whole data set to find a single record
        AbstractDataProviderRecordIterator i = searchRecordsImpl(where_cond, search_options);
        if (i.next());
 
    }
 
 
    private *hash<auto> searchSingleRecordImpl(hash<auto> where_cond,
            *hash<auto> search_options) {
        // scans the whole data set to find a single record
        *list<*hash<auto>> records = map $1, searchRecordsImpl(where_cond, search_options);
        if (records.lsize() > 1);
 
        return records[0];
    }
 
 
protected:
     *list<string> getChildProviderNamesImpl();
public:
 
 
 
protected:
     *AbstractDataProvider getChildProviderImpl(string name);
public:
 
 
 
    *hash<string, AbstractDataField> getRecordType(*hash<auto> search_options);
 
 
    *hash<string, AbstractDataField> getSoftRecordType(*hash<auto> search_options);
 
 
    *hash<string, AbstractDataField> getOrNothingRecordType(*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();
 
 
 
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 DefaultBulkRecordIterface(block_size, searchRecordsImpl(where_cond, search_options));
    }
 
 
    private AbstractDataProviderRecordIterator searchRecordsImpl(*hash<auto> where_cond,
            *hash<auto> search_options) {
        throwUnimplementedException();
    }
 
 
    private AbstractDataProviderRecordIterator requestSearchRecordsImpl(auto req,
            *hash<auto> where_cond, *hash<auto> search_options) {
        throwUnimplementedException();
    }
 
 
protected:
     *hash<auto> createRecordImpl(hash<auto> rec, *hash<auto> create_options);
public:
 
 
 
protected:
     string upsertRecordImpl(hash<auto> rec, *hash<auto> upsert_options);
public:
 
 
 
    private bool updateSingleRecordImpl(hash<auto> set, hash<auto> where_cond,
            *hash<auto> search_options) {
        throwUnimplementedException();
    }
 
 
    private int updateRecordsImpl(hash<auto> set, *hash<auto> where_cond,
            *hash<auto> search_options) {
        throwUnimplementedException();
    }
 
 
protected:
     int deleteRecordsImpl(*hash<auto> where_cond, *hash<auto> search_options);
public:
 
 
 
protected:
     auto doRequestImpl(auto req, *hash<auto> request_options);
public:
 
 
 
    private AbstractDataProvider createChildProviderImpl(string name, hash<string, AbstractDataField> fields,
            *hash<auto> child_create_options) {
        throwUnimplementedException();
    }
 
 
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 getResponseTypeImpl();
public:
 
 
 
protected:
     *hash<string, AbstractDataProviderType> getErrorResponseTypesImpl();
public:
 
 
 
protected:
     AbstractDataProviderType getErrorResponseTypeImpl(string error_code);
public:
 
 
 
protected:
     hash<DataProviderMessageInfo> getEventInfoImpl(string event_id);
public:
 
 
 
protected:
     hash<string, hash<DataProviderMessageInfo>> getEventTypesImpl();
public:
 
 
 
protected:
     hash<DataProviderMessageInfo> getMessageInfoImpl(string message_id);
public:
 
 
 
protected:
     hash<string, hash<DataProviderMessageInfo>> getMessageTypesImpl();
public:
 
 
 
protected:
     throwUnimplementedException();
public:
 
 
    abstract string getName();
 
protected:
     abstract hash<DataProviderInfo> getStaticInfoImpl();
public:
}
}