def __scan(conn, cache_info, page_size, partitions, local, query_id):
query_struct = Query(
OP_QUERY_SCAN,
[
('cache_info', CacheInfo),
('filter', Null),
('page_size', Int),
('partitions', Int),
('local', Bool),
],
query_id=query_id,
)
return query_perform(query_struct,
conn,
query_params={
'cache_info': cache_info,
'filter': None,
'page_size': page_size,
'partitions': partitions,
'local': 1 if local else 0,
},
response_config=[
('cursor', Long),
('data', Map),
('more', Bool),
],
post_process_fun=__query_result_post_process)
def __cache_local_peek(conn, cache_info, key, key_hint, peek_modes, query_id):
if peek_modes is None:
peek_modes = []
elif not isinstance(peek_modes, (list, tuple)):
peek_modes = [peek_modes]
query_struct = Query(
OP_CACHE_LOCAL_PEEK,
[
('cache_info', CacheInfo),
('key', key_hint or AnyDataObject),
('peek_modes', ByteArray),
],
query_id=query_id,
)
return query_perform(query_struct,
conn,
query_params={
'cache_info': cache_info,
'key': key,
'peek_modes': peek_modes,
},
response_config=[
('value', AnyDataObject),
],
post_process_fun=__post_process_value_by_key('value'))
def __cache_destroy(connection, cache, query_id):
query_struct = Query(OP_CACHE_DESTROY, [('hash_code', Int)],
query_id=query_id)
return query_perform(query_struct,
connection,
query_params={'hash_code': cache_id(cache)})
def __cache_replace_if_equals(connection, cache_info, key, sample, value,
key_hint, sample_hint, value_hint, query_id):
query_struct = Query(
OP_CACHE_REPLACE_IF_EQUALS,
[
('cache_info', CacheInfo),
('key', key_hint or AnyDataObject),
('sample', sample_hint or AnyDataObject),
('value', value_hint or AnyDataObject),
],
query_id=query_id,
)
return query_perform(
query_struct,
connection,
query_params={
'cache_info': cache_info,
'key': key,
'sample': sample,
'value': value,
},
response_config=[
('success', Bool),
],
post_process_fun=__post_process_value_by_key('success'))
def __cluster_get_state(connection, query_id):
if not connection.protocol_context.is_cluster_api_supported():
raise NotSupportedByClusterError(
'Cluster API is not supported by the cluster')
query_struct = Query(OP_CLUSTER_GET_STATE, query_id=query_id)
return query_perform(query_struct,
connection,
response_config=[('state', Byte)],
post_process_fun=__post_process_get_state)
def __resource_close(conn, cursor, query_id):
query_struct = Query(
OP_RESOURCE_CLOSE,
[
('cursor', Long),
],
query_id=query_id,
)
return query_perform(query_struct, conn, query_params={
'cursor': cursor,
})
def __get_binary_type(conn, binary_type, query_id):
query_struct = Query(OP_GET_BINARY_TYPE, [
('type_id', Int),
],
query_id=query_id,
response_type=BinaryTypeResponse)
return query_perform(query_struct,
conn,
query_params={
'type_id': entity_id(binary_type),
})
def __cache_create_with_config(op_code, connection, cache_props, query_id):
prop_types, prop_values = {}, {}
for i, prop_item in enumerate(cache_props.items()):
prop_code, prop_value = prop_item
prop_name = 'property_{}'.format(i)
prop_types[prop_name] = prop_map(prop_code)
prop_values[prop_name] = prop_value
prop_values['param_count'] = len(cache_props)
following = [('param_count', Short)] + list(prop_types.items())
query_struct = ConfigQuery(op_code, following, query_id=query_id)
return query_perform(query_struct, connection, query_params=prop_values)
def __cluster_set_state(connection, state, query_id):
if not connection.protocol_context.is_cluster_api_supported():
raise NotSupportedByClusterError(
'Cluster API is not supported by the cluster')
query_struct = Query(OP_CLUSTER_CHANGE_STATE, [('state', Byte)],
query_id=query_id)
return query_perform(query_struct,
connection,
query_params={
'state': state,
})
def __sql_fields(conn, cache, query_str, page_size, query_args, schema,
statement_type, distributed_joins, local, replicated_only,
enforce_join_order, collocated, lazy, include_field_names,
max_rows, timeout, binary, query_id):
if query_args is None:
query_args = []
query_struct = Query(OP_QUERY_SQL_FIELDS, [
('hash_code', Int),
('flag', Byte),
('schema', String),
('page_size', Int),
('max_rows', Int),
('query_str', String),
('query_args', AnyDataArray()),
('statement_type', StatementType),
('distributed_joins', Bool),
('local', Bool),
('replicated_only', Bool),
('enforce_join_order', Bool),
('collocated', Bool),
('lazy', Bool),
('timeout', Long),
('include_field_names', Bool),
],
query_id=query_id,
response_type=SQLResponse)
return query_perform(
query_struct,
conn,
query_params={
'hash_code': cache_id(cache),
'flag': 1 if binary else 0,
'schema': schema,
'page_size': page_size,
'max_rows': max_rows,
'query_str': query_str,
'query_args': query_args,
'statement_type': statement_type,
'distributed_joins': distributed_joins,
'local': local,
'replicated_only': replicated_only,
'enforce_join_order': enforce_join_order,
'collocated': collocated,
'lazy': lazy,
'timeout': timeout,
'include_field_names': include_field_names,
},
include_field_names=include_field_names,
has_cursor=True,
)
def __cache_remove_all(connection, cache_info, query_id):
query_struct = Query(
OP_CACHE_REMOVE_ALL,
[
('cache_info', CacheInfo),
],
query_id=query_id,
)
return query_perform(
query_struct,
connection,
query_params={
'cache_info': cache_info,
},
)
def __cache_clear(connection, cache_info, query_id):
query_struct = Query(
OP_CACHE_CLEAR,
[
('cache_info', CacheInfo),
],
query_id=query_id,
)
return query_perform(
query_struct,
connection,
query_params={
'cache_info': cache_info,
},
)
def __cache_create_with_config(op_code, connection, cache_props, query_id):
prop_types, prop_values = {}, {}
is_expiry_policy_supported = connection.protocol_context.is_expiry_policy_supported()
for i, prop_item in enumerate(cache_props.items()):
prop_code, prop_value = prop_item
if prop_code == PROP_EXPIRY_POLICY and not is_expiry_policy_supported:
raise NotSupportedByClusterError("'ExpiryPolicy' API is not supported by the cluster")
prop_name = 'property_{}'.format(i)
prop_types[prop_name] = prop_map(prop_code)
prop_values[prop_name] = prop_value
prop_values['param_count'] = len(cache_props)
following = [('param_count', Short)] + list(prop_types.items())
query_struct = ConfigQuery(op_code, following, query_id=query_id)
return query_perform(query_struct, connection, query_params=prop_values)
def __cache_clear_key(connection, cache_info, key, key_hint, query_id):
query_struct = Query(
OP_CACHE_CLEAR_KEY,
[
('cache_info', CacheInfo),
('key', key_hint or AnyDataObject),
],
query_id=query_id,
)
return query_perform(
query_struct,
connection,
query_params={
'cache_info': cache_info,
'key': key,
},
)
def __cache_get_configuration(connection, cache_info, query_id):
query_struct = Query(
OP_CACHE_GET_CONFIGURATION,
[
('cache_info', CacheInfo)
],
query_id=query_id,
)
return query_perform(query_struct, connection,
query_params={
'cache_info': cache_info
},
response_config=[
('cache_config', get_cache_config_struct(connection.protocol_context))
],
post_process_fun=__post_process_cache_config
)
def __cache_clear_keys(connection, cache_info, keys, query_id):
query_struct = Query(
OP_CACHE_CLEAR_KEYS,
[
('cache_info', CacheInfo),
('keys', AnyDataArray()),
],
query_id=query_id,
)
return query_perform(
query_struct,
connection,
query_params={
'cache_info': cache_info,
'keys': keys,
},
)
def __cache_put_all(connection, cache_info, pairs, query_id):
query_struct = Query(
OP_CACHE_PUT_ALL,
[
('cache_info', CacheInfo),
('data', Map),
],
query_id=query_id,
)
return query_perform(
query_struct,
connection,
query_params={
'cache_info': cache_info,
'data': pairs,
},
)
def __cache_put(connection, cache_info, key, value, key_hint, value_hint,
query_id):
query_struct = Query(
OP_CACHE_PUT,
[
('cache_info', CacheInfo),
('key', key_hint or AnyDataObject),
('value', value_hint or AnyDataObject),
],
query_id=query_id,
)
return query_perform(query_struct,
connection,
query_params={
'cache_info': cache_info,
'key': key,
'value': value
})
def __cache_get_configuration(connection, cache, flags, query_id):
query_struct = Query(
OP_CACHE_GET_CONFIGURATION,
[
('hash_code', Int),
('flags', Byte),
],
query_id=query_id,
)
return query_perform(query_struct,
connection,
query_params={
'hash_code': cache_id(cache),
'flags': flags
},
response_config=[('cache_config', cache_config_struct)
],
post_process_fun=__post_process_cache_config)
def __scan_cursor_get_page(conn, cursor, query_id):
query_struct = Query(
OP_QUERY_SCAN_CURSOR_GET_PAGE,
[
('cursor', Long),
],
query_id=query_id,
)
return query_perform(query_struct,
conn,
query_params={
'cursor': cursor,
},
response_config=[
('data', Map),
('more', Bool),
],
post_process_fun=__query_result_post_process)
def __cache_get_and_remove(connection, cache_info, key, key_hint, query_id):
query_struct = Query(
OP_CACHE_GET_AND_REMOVE,
[
('cache_info', CacheInfo),
('key', key_hint or AnyDataObject),
],
query_id=query_id,
)
return query_perform(query_struct,
connection,
query_params={
'cache_info': cache_info,
'key': key,
},
response_config=[
('value', AnyDataObject),
],
post_process_fun=__post_process_value_by_key('value'))
def __cache_contains_keys(connection, cache_info, keys, query_id):
query_struct = Query(
OP_CACHE_CONTAINS_KEYS,
[
('cache_info', CacheInfo),
('keys', AnyDataArray()),
],
query_id=query_id,
)
return query_perform(query_struct,
connection,
query_params={
'cache_info': cache_info,
'keys': keys,
},
response_config=[
('value', Bool),
],
post_process_fun=__post_process_value_by_key('value'))
def __cache_get_all(connection, cache_info, keys, query_id):
query_struct = Query(
OP_CACHE_GET_ALL,
[
('cache_info', CacheInfo),
('keys', AnyDataArray()),
],
query_id=query_id,
)
return query_perform(query_struct,
connection,
query_params={
'cache_info': cache_info,
'keys': keys,
},
response_config=[
('data', Map),
],
post_process_fun=__post_process_value_by_key('data'))
def __sql_fields_cursor_get_page(conn, cursor, field_count, query_id):
query_struct = Query(
OP_QUERY_SQL_FIELDS_CURSOR_GET_PAGE,
[
('cursor', Long),
],
query_id=query_id,
)
return query_perform(query_struct,
conn,
query_params={
'cursor': cursor,
},
response_config=[
('data',
StructArray([(f'field_{i}', AnyDataObject)
for i in range(field_count)])),
('more', Bool),
],
post_process_fun=__post_process_sql_fields_cursor)
def __cache_get_node_partitions(conn, caches, query_id):
query_struct = Query(OP_CACHE_PARTITIONS, [
('cache_ids', cache_ids),
],
query_id=query_id)
if not is_iterable(caches):
caches = [caches]
return query_perform(query_struct,
conn,
query_params={
'cache_ids': [{
'cache_id': cache
} for cache in caches],
},
response_config=[
('version_major', Long),
('version_minor', Int),
('partition_mapping', partition_mapping),
],
post_process_fun=__post_process_partitions)
def __cache_get_and_put_if_absent(connection, cache_info, key, value, key_hint,
value_hint, query_id):
query_struct = Query(
OP_CACHE_GET_AND_PUT_IF_ABSENT,
[
('cache_info', CacheInfo),
('key', key_hint or AnyDataObject),
('value', value_hint or AnyDataObject),
],
query_id=query_id,
)
return query_perform(query_struct,
connection,
query_params={
'cache_info': cache_info,
'key': key,
'value': value,
},
response_config=[
('value', AnyDataObject),
],
post_process_fun=__post_process_value_by_key('value'))
def __cache_get_size(connection, cache_info, peek_modes, query_id):
if peek_modes is None:
peek_modes = []
elif not isinstance(peek_modes, (list, tuple)):
peek_modes = [peek_modes]
query_struct = Query(
OP_CACHE_GET_SIZE,
[
('cache_info', CacheInfo),
('peek_modes', ByteArray),
],
query_id=query_id,
)
return query_perform(query_struct,
connection,
query_params={
'cache_info': cache_info,
'peek_modes': peek_modes,
},
response_config=[
('count', Long),
],
post_process_fun=__post_process_value_by_key('count'))
def __put_binary_type(connection, type_name, affinity_key_field, is_enum,
schema, query_id):
# prepare data
if schema is None:
schema = {}
type_id = entity_id(type_name)
data = {
'type_name': type_name,
'type_id': type_id,
'affinity_key_field': affinity_key_field,
'binary_fields': [],
'is_enum': is_enum,
'schema': [],
}
s_id = None
if is_enum:
data['enums'] = []
for literal, ordinal in schema.items():
data['enums'].append({
'literal': literal,
'type_id': ordinal,
})
else:
# assemble schema and calculate schema ID in one go
s_id = schema_id(schema)
for field_name, data_type in schema.items():
# TODO: check for allowed data types
field_id = entity_id(field_name)
data['binary_fields'].append({
'field_name':
field_name,
'type_id':
int.from_bytes(data_type.type_code,
byteorder=PROTOCOL_BYTE_ORDER),
'field_id':
field_id,
})
data['schema'].append({
'schema_id':
s_id,
'schema_fields': [{
'schema_field_id': entity_id(x)
} for x in schema],
})
# do query
if is_enum:
query_struct = Query(
OP_PUT_BINARY_TYPE,
[
('type_id', Int),
('type_name', String),
('affinity_key_field', String),
('binary_fields', binary_fields_struct),
('is_enum', Bool),
('enums', enum_struct),
('schema', schema_struct),
],
query_id=query_id,
)
else:
query_struct = Query(
OP_PUT_BINARY_TYPE,
[
('type_id', Int),
('type_name', String),
('affinity_key_field', String),
('binary_fields', binary_fields_struct),
('is_enum', Bool),
('schema', schema_struct),
],
query_id=query_id,
)
return query_perform(query_struct,
connection,
query_params=data,
post_process_fun=__post_process_put_binary(type_id))
def __cache_create_with_name(op_code, conn, name, query_id):
query_struct = Query(op_code, [('cache_name', String)], query_id=query_id)
return query_perform(query_struct, conn, query_params={'cache_name': name})
def __cache_get_names(connection, query_id):
query_struct = Query(OP_CACHE_GET_NAMES, query_id=query_id)
return query_perform(query_struct,
connection,
response_config=[('cache_names', StringArray)],
post_process_fun=__post_process_cache_names)
