pyignite/api/key_value.py

# Licensed to the Apache Software Foundation (ASF) under one or more
# contributor license agreements.  See the NOTICE file distributed with
# this work for additional information regarding copyright ownership.
# The ASF licenses this file to You under the Apache License, Version 2.0
# (the "License"); you may not use this file except in compliance with
# the License.  You may obtain a copy of the License at
#
#      http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.

from typing import Any, Iterable, Union

from pyignite.connection import AioConnection, Connection
from pyignite.queries.op_codes import (
    OP_CACHE_PUT, OP_CACHE_GET, OP_CACHE_GET_ALL, OP_CACHE_PUT_ALL, OP_CACHE_CONTAINS_KEY, OP_CACHE_CONTAINS_KEYS,
    OP_CACHE_GET_AND_PUT, OP_CACHE_GET_AND_REPLACE, OP_CACHE_GET_AND_REMOVE, OP_CACHE_PUT_IF_ABSENT,
    OP_CACHE_GET_AND_PUT_IF_ABSENT, OP_CACHE_REPLACE, OP_CACHE_REPLACE_IF_EQUALS, OP_CACHE_CLEAR, OP_CACHE_CLEAR_KEY,
    OP_CACHE_CLEAR_KEYS, OP_CACHE_REMOVE_KEY, OP_CACHE_REMOVE_IF_EQUALS, OP_CACHE_REMOVE_KEYS, OP_CACHE_REMOVE_ALL,
    OP_CACHE_GET_SIZE, OP_CACHE_LOCAL_PEEK
)
from pyignite.datatypes import Map, Bool, Long, AnyDataArray, AnyDataObject, ByteArray
from pyignite.datatypes.base import IgniteDataType
from pyignite.queries import Query, query_perform

from .result import APIResult
from ..queries.cache_info import CacheInfo


def cache_put(connection: 'Connection', cache_info: CacheInfo, key: Any, value: Any,
              key_hint: 'IgniteDataType' = None, value_hint: 'IgniteDataType' = None) -> 'APIResult':
    """
    Puts a value with a given key to cache (overwriting existing value if any).

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param key: key for the cache entry. Can be of any supported type,
    :param value: value for the key,
    :param key_hint: (optional) Ignite data type, for which the given key
     should be converted,
    :param value_hint: (optional) Ignite data type, for which the given value
     should be converted.
    :return: API result data object. Contains zero status if a value
     is written, non-zero status and an error description otherwise.
    """
    return __cache_put(connection, cache_info, key, value, key_hint, value_hint)


async def cache_put_async(connection: 'AioConnection', cache_info: CacheInfo, key: Any, value: Any,
                          key_hint: 'IgniteDataType' = None, value_hint: 'IgniteDataType' = None) -> 'APIResult':
    """
    Async version of cache_put
    """
    return await __cache_put(connection, cache_info, key, value, key_hint, value_hint)


def __cache_put(connection, cache_info, key, value, key_hint, value_hint):
    query_struct = Query(
        OP_CACHE_PUT,
        [
            ('cache_info', CacheInfo),
            ('key', key_hint or AnyDataObject),
            ('value', value_hint or AnyDataObject),
        ]
    )
    return query_perform(
        query_struct, connection,
        query_params={
            'cache_info': cache_info,
            'key': key,
            'value': value
        }
    )


def cache_get(connection: 'Connection', cache_info: CacheInfo, key: Any,
              key_hint: 'IgniteDataType' = None) -> 'APIResult':
    """
    Retrieves a value from cache by key.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param key: key for the cache entry. Can be of any supported type,
    :param key_hint: (optional) Ignite data type, for which the given key
     should be converted
    :return: API result data object. Contains zero status and a value
     retrieved on success, non-zero status and an error description on failure.
    """
    return __cache_get(connection, cache_info, key, key_hint)


async def cache_get_async(connection: 'AioConnection', cache_info: CacheInfo, key: Any,
                          key_hint: 'IgniteDataType' = None) -> 'APIResult':
    """
    Async version of cache_get
    """
    return await __cache_get(connection, cache_info, key, key_hint)


def __cache_get(connection, cache_info, key, key_hint):
    query_struct = Query(
        OP_CACHE_GET,
        [
            ('cache_info', CacheInfo),
            ('key', key_hint or AnyDataObject),
        ]
    )
    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_get_all(connection: 'Connection', cache_info: CacheInfo, keys: Iterable) -> 'APIResult':
    """
    Retrieves multiple key-value pairs from cache.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param keys: list of keys or tuples of (key, key_hint),
    :return: API result data object. Contains zero status and a dict, made of
     retrieved key-value pairs, non-zero status and an error description
     on failure.
    """
    return __cache_get_all(connection, cache_info, keys)


async def cache_get_all_async(connection: 'AioConnection', cache_info: CacheInfo, keys: Iterable) -> 'APIResult':
    """
    Async version of cache_get_all.
    """
    return await __cache_get_all(connection, cache_info, keys)


def __cache_get_all(connection, cache_info, keys):
    query_struct = Query(
        OP_CACHE_GET_ALL,
        [
            ('cache_info', CacheInfo),
            ('keys', AnyDataArray()),
        ]
    )
    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 cache_put_all(connection: 'Connection', cache_info: CacheInfo, pairs: dict) -> 'APIResult':
    """
    Puts multiple key-value pairs to cache (overwriting existing associations
    if any).

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param pairs: dictionary type parameters, contains key-value pairs to save.
     Each key or value can be an item of representable Python type or a tuple
     of (item, hint),
    :return: API result data object. Contains zero status if key-value pairs
     are written, non-zero status and an error description otherwise.
    """
    return __cache_put_all(connection, cache_info, pairs)


async def cache_put_all_async(connection: 'AioConnection', cache_info: CacheInfo, pairs: dict) -> 'APIResult':
    """
    Async version of cache_put_all.
    """
    return await __cache_put_all(connection, cache_info, pairs)


def __cache_put_all(connection, cache_info, pairs):
    query_struct = Query(
        OP_CACHE_PUT_ALL,
        [
            ('cache_info', CacheInfo),
            ('data', Map),
        ]
    )
    return query_perform(
        query_struct, connection,
        query_params={
            'cache_info': cache_info,
            'data': pairs,
        },
    )


def cache_contains_key(connection: 'Connection', cache_info: CacheInfo, key: Any,
                       key_hint: 'IgniteDataType' = None) -> 'APIResult':
    """
    Returns a value indicating whether given key is present in cache.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param key: key for the cache entry. Can be of any supported type,
    :param key_hint: (optional) Ignite data type, for which the given key
     should be converted
    :return: API result data object. Contains zero status and a bool value
     retrieved on success: `True` when key is present, `False` otherwise,
     non-zero status and an error description on failure.
    """
    return __cache_contains_key(connection, cache_info, key, key_hint)


async def cache_contains_key_async(connection: 'AioConnection', cache_info: CacheInfo, key: Any,
                                   key_hint: 'IgniteDataType' = None) -> 'APIResult':
    """
    Async version of cache_contains_key.
    """
    return await __cache_contains_key(connection, cache_info, key, key_hint)


def __cache_contains_key(connection, cache_info, key, key_hint):
    query_struct = Query(
        OP_CACHE_CONTAINS_KEY,
        [
            ('cache_info', CacheInfo),
            ('key', key_hint or AnyDataObject),
        ]
    )
    return query_perform(
        query_struct, connection,
        query_params={
            'cache_info': cache_info,
            'key': key,
        },
        response_config=[
            ('value', Bool),
        ],
        post_process_fun=__post_process_value_by_key('value')
    )


def cache_contains_keys(connection: 'Connection', cache_info: CacheInfo, keys: Iterable,
                        ) -> 'APIResult':
    """
    Returns a value indicating whether all given keys are present in cache.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param keys: a list of keys or (key, type hint) tuples,
    :return: API result data object. Contains zero status and a bool value
     retrieved on success: `True` when all keys are present, `False` otherwise,
     non-zero status and an error description on failure.
    """
    return __cache_contains_keys(connection, cache_info, keys)


async def cache_contains_keys_async(connection: 'AioConnection', cache_info: CacheInfo, keys: Iterable) -> 'APIResult':
    """
    Async version of cache_contains_keys.
    """
    return await __cache_contains_keys(connection, cache_info, keys)


def __cache_contains_keys(connection, cache_info, keys):
    query_struct = Query(
        OP_CACHE_CONTAINS_KEYS,
        [
            ('cache_info', CacheInfo),
            ('keys', AnyDataArray()),
        ]
    )
    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_and_put(connection: 'Connection', cache_info: CacheInfo, key: Any, value: Any,
                      key_hint: 'IgniteDataType' = None, value_hint: 'IgniteDataType' = None) -> 'APIResult':
    """
    Puts a value with a given key to cache_info, and returns the previous value
    for that key, or null value if there was not such key.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param key: key for the cache entry. Can be of any supported type,
    :param value: value for the key,
    :param key_hint: (optional) Ignite data type, for which the given key
     should be converted,
    :param value_hint: (optional) Ignite data type, for which the given value
     should be converted.
    :return: API result data object. Contains zero status and an old value
     or None if a value is written, non-zero status and an error description
     in case of error.
    """
    return __cache_get_and_put(connection, cache_info, key, value, key_hint, value_hint)


async def cache_get_and_put_async(
        connection: 'AioConnection', cache_info: CacheInfo, key: Any, value: Any,
        key_hint: 'IgniteDataType' = None, value_hint: 'IgniteDataType' = None
) -> 'APIResult':
    """
    Async version of cache_get_and_put.
    """
    return await __cache_get_and_put(connection, cache_info, key, value, key_hint, value_hint)


def __cache_get_and_put(connection, cache_info, key, value, key_hint, value_hint):
    query_struct = Query(
        OP_CACHE_GET_AND_PUT,
        [
            ('cache_info', CacheInfo),
            ('key', key_hint or AnyDataObject),
            ('value', value_hint or AnyDataObject),
        ],
    )
    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_and_replace(connection: 'Connection', cache_info: CacheInfo, key: Any, value: Any,
                          key_hint: 'IgniteDataType' = None, value_hint: 'IgniteDataType' = None) -> 'APIResult':
    """
    Puts a value with a given key to cache, returning previous value
    for that key, if and only if there is a value currently mapped
    for that key.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param key: key for the cache entry. Can be of any supported type,
    :param value: value for the key,
    :param key_hint: (optional) Ignite data type, for which the given key
     should be converted,
    :param value_hint: (optional) Ignite data type, for which the given value
     should be converted.
    :return: API result data object. Contains zero status and an old value
     or None on success, non-zero status and an error description otherwise.
    """
    return __cache_get_and_replace(connection, cache_info, key, key_hint, value, value_hint)


async def cache_get_and_replace_async(
        connection: 'AioConnection', cache_info: CacheInfo, key: Any, value: Any,
        key_hint: 'IgniteDataType' = None, value_hint: 'IgniteDataType' = None
) -> 'APIResult':
    """
    Async version of cache_get_and_replace.
    """
    return await __cache_get_and_replace(connection, cache_info, key, key_hint, value, value_hint)


def __cache_get_and_replace(connection, cache_info, key, key_hint, value, value_hint):
    query_struct = Query(
        OP_CACHE_GET_AND_REPLACE, [
            ('cache_info', CacheInfo),
            ('key', key_hint or AnyDataObject),
            ('value', value_hint or AnyDataObject),
        ]
    )
    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_and_remove(
        connection: 'Connection', cache_info: CacheInfo, key: Any, key_hint: 'IgniteDataType' = None
) -> 'APIResult':
    """
    Removes the cache entry with specified key, returning the value.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param key: key for the cache entry. Can be of any supported type,
    :param key_hint: (optional) Ignite data type, for which the given key
     should be converted,
    :return: API result data object. Contains zero status and an old value
     or None, non-zero status and an error description otherwise.
    """
    return __cache_get_and_remove(connection, cache_info, key, key_hint)


async def cache_get_and_remove_async(
        connection: 'AioConnection', cache_info: CacheInfo, key: Any, key_hint: 'IgniteDataType' = None
) -> 'APIResult':
    return await __cache_get_and_remove(connection, cache_info, key, key_hint)


def __cache_get_and_remove(connection, cache_info, key, key_hint):
    query_struct = Query(
        OP_CACHE_GET_AND_REMOVE, [
            ('cache_info', CacheInfo),
            ('key', key_hint or AnyDataObject),
        ]
    )
    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_put_if_absent(connection: 'Connection', cache_info: CacheInfo, key: Any, value: Any,
                        key_hint: 'IgniteDataType' = None, value_hint: 'IgniteDataType' = None) -> 'APIResult':
    """
    Puts a value with a given key to cache only if the key
    does not already exist.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param key: key for the cache entry. Can be of any supported type,
    :param value: value for the key,
    :param key_hint: (optional) Ignite data type, for which the given key
     should be converted,
    :param value_hint: (optional) Ignite data type, for which the given value
     should be converted.
    :return: API result data object. Contains zero status on success,
     non-zero status and an error description otherwise.
    """
    return __cache_put_if_absent(connection, cache_info, key, value, key_hint, value_hint)


async def cache_put_if_absent_async(
        connection: 'AioConnection', cache_info: CacheInfo, key: Any, value: Any,
        key_hint: 'IgniteDataType' = None, value_hint: 'IgniteDataType' = None
) -> 'APIResult':
    """
    Async version of cache_put_if_absent.
    """
    return await __cache_put_if_absent(connection, cache_info, key, value, key_hint, value_hint)


def __cache_put_if_absent(connection, cache_info, key, value, key_hint, value_hint):
    query_struct = Query(
        OP_CACHE_PUT_IF_ABSENT,
        [
            ('cache_info', CacheInfo),
            ('key', key_hint or AnyDataObject),
            ('value', value_hint or AnyDataObject),
        ]
    )
    return query_perform(
        query_struct, connection,
        query_params={
            'cache_info': cache_info,
            'key': key,
            'value': value,
        },
        response_config=[
            ('success', Bool),
        ],
        post_process_fun=__post_process_value_by_key('success')
    )


def cache_get_and_put_if_absent(connection: 'Connection', cache_info: CacheInfo, key: Any, value: Any,
                                key_hint: 'IgniteDataType' = None, value_hint: 'IgniteDataType' = None) -> 'APIResult':
    """
    Puts a value with a given key to cache only if the key does not
    already exist.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param key: key for the cache entry. Can be of any supported type,
    :param value: value for the key,
    :param key_hint: (optional) Ignite data type, for which the given key
     should be converted,
    :param value_hint: (optional) Ignite data type, for which the given value
     should be converted.
    :return: API result data object. Contains zero status and an old value
     or None on success, non-zero status and an error description otherwise.
    """
    return __cache_get_and_put_if_absent(connection, cache_info, key, value, key_hint, value_hint)


async def cache_get_and_put_if_absent_async(
        connection: 'AioConnection', cache_info: CacheInfo, key: Any, value: Any,
        key_hint: 'IgniteDataType' = None, value_hint: 'IgniteDataType' = None
) -> 'APIResult':
    """
    Async version of cache_get_and_put_if_absent.
    """
    return await __cache_get_and_put_if_absent(connection, cache_info, key, value, key_hint, value_hint)


def __cache_get_and_put_if_absent(connection, cache_info, key, value, key_hint, value_hint):
    query_struct = Query(
        OP_CACHE_GET_AND_PUT_IF_ABSENT,
        [
            ('cache_info', CacheInfo),
            ('key', key_hint or AnyDataObject),
            ('value', value_hint or AnyDataObject),
        ]
    )
    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_replace(connection: 'Connection', cache_info: CacheInfo, key: Any, value: Any,
                  key_hint: 'IgniteDataType' = None, value_hint: 'IgniteDataType' = None) -> 'APIResult':
    """
    Puts a value with a given key to cache only if the key already exist.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param key: key for the cache entry. Can be of any supported type,
    :param value: value for the key,
    :param key_hint: (optional) Ignite data type, for which the given key
     should be converted,
    :param value_hint: (optional) Ignite data type, for which the given value
     should be converted.
    :return: API result data object. Contains zero status and a boolean
     success code, or non-zero status and an error description if something
     has gone wrong.
    """
    return __cache_replace(connection, cache_info, key, value, key_hint, value_hint)


async def cache_replace_async(
        connection: 'AioConnection', cache_info: CacheInfo, key: Any, value: Any,
        key_hint: 'IgniteDataType' = None, value_hint: 'IgniteDataType' = None
) -> 'APIResult':
    """
    Async version of cache_replace.
    """
    return await __cache_replace(connection, cache_info, key, value, key_hint, value_hint)


def __cache_replace(connection, cache_info, key, value, key_hint, value_hint):
    query_struct = Query(
        OP_CACHE_REPLACE,
        [
            ('cache_info', CacheInfo),
            ('key', key_hint or AnyDataObject),
            ('value', value_hint or AnyDataObject),
        ]
    )
    return query_perform(
        query_struct, connection,
        query_params={
            'cache_info': cache_info,
            'key': key,
            'value': value,
        },
        response_config=[
            ('success', Bool),
        ],
        post_process_fun=__post_process_value_by_key('success')
    )


def cache_replace_if_equals(connection: 'Connection', cache_info: CacheInfo, key: Any, sample: Any, value: Any,
                            key_hint: 'IgniteDataType' = None, sample_hint: 'IgniteDataType' = None,
                            value_hint: 'IgniteDataType' = None) -> 'APIResult':
    """
    Puts a value with a given key to cache only if the key already exists
    and value equals provided sample.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param key:  key for the cache entry,
    :param sample: a sample to compare the stored value with,
    :param value: new value for the given key,
    :param key_hint: (optional) Ignite data type, for which the given key
     should be converted,
    :param sample_hint: (optional) Ignite data type, for whic
     the given sample should be converted
    :param value_hint: (optional) Ignite data type, for which the given value
     should be converted,
    :return: API result data object. Contains zero status and a boolean
     success code, or non-zero status and an error description if something
     has gone wrong.
    """
    return __cache_replace_if_equals(connection, cache_info, key, sample, value, key_hint,
                                     sample_hint, value_hint)


async def cache_replace_if_equals_async(
        connection: 'AioConnection', cache_info: CacheInfo, key: Any, sample: Any, value: Any,
        key_hint: 'IgniteDataType' = None, sample_hint: 'IgniteDataType' = None, value_hint: 'IgniteDataType' = None
) -> 'APIResult':
    """
    Async version of cache_replace_if_equals.
    """
    return await __cache_replace_if_equals(connection, cache_info, key, sample, value, key_hint,
                                           sample_hint, value_hint)


def __cache_replace_if_equals(connection, cache_info, key, sample, value, key_hint, sample_hint, value_hint):
    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),
        ]
    )
    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 cache_clear(connection: 'Connection', cache_info: CacheInfo) -> 'APIResult':
    """
    Clears the cache without notifying listeners or cache writers.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :return: API result data object. Contains zero status on success,
     non-zero status and an error description otherwise.
    """
    return __cache_clear(connection, cache_info)


async def cache_clear_async(connection: 'AioConnection', cache_info: CacheInfo) -> 'APIResult':
    """
    Async version of cache_clear.
    """
    return await __cache_clear(connection, cache_info)


def __cache_clear(connection, cache_info):
    query_struct = Query(
        OP_CACHE_CLEAR,
        [
            ('cache_info', CacheInfo),
        ]
    )
    return query_perform(
        query_struct, connection,
        query_params={
            'cache_info': cache_info,
        },
    )


def cache_clear_key(
        connection: 'Connection', cache_info: CacheInfo, key: Any, key_hint: 'IgniteDataType' = None
) -> 'APIResult':
    """
    Clears the cache key without notifying listeners or cache writers.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param key:  key for the cache entry,
    :param key_hint: (optional) Ignite data type, for which the given key
     should be converted,
    :return: API result data object. Contains zero status on success,
     non-zero status and an error description otherwise.
    """
    return __cache_clear_key(connection, cache_info, key, key_hint)


async def cache_clear_key_async(
        connection: 'AioConnection', cache_info: CacheInfo, key: Any, key_hint: 'IgniteDataType' = None
) -> 'APIResult':
    """
    Async version of cache_clear_key.
    """
    return await __cache_clear_key(connection, cache_info, key, key_hint)


def __cache_clear_key(connection, cache_info, key, key_hint):
    query_struct = Query(
        OP_CACHE_CLEAR_KEY,
        [
            ('cache_info', CacheInfo),
            ('key', key_hint or AnyDataObject),
        ]
    )
    return query_perform(
        query_struct, connection,
        query_params={
            'cache_info': cache_info,
            'key': key,
        },
    )


def cache_clear_keys(connection: 'Connection', cache_info: CacheInfo, keys: Iterable) -> 'APIResult':
    """
    Clears the cache keys without notifying listeners or cache writers.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param keys: list of keys or tuples of (key, key_hint),
    :return: API result data object. Contains zero status on success,
     non-zero status and an error description otherwise.
    """
    return __cache_clear_keys(connection, cache_info, keys)


async def cache_clear_keys_async(connection: 'AioConnection', cache_info: CacheInfo, keys: Iterable) -> 'APIResult':
    """
    Async version of cache_clear_keys.
    """
    return await __cache_clear_keys(connection, cache_info, keys)


def __cache_clear_keys(connection, cache_info, keys):
    query_struct = Query(
        OP_CACHE_CLEAR_KEYS,
        [
            ('cache_info', CacheInfo),
            ('keys', AnyDataArray()),
        ]
    )
    return query_perform(
        query_struct, connection,
        query_params={
            'cache_info': cache_info,
            'keys': keys,
        },
    )


def cache_remove_key(
        connection: 'Connection', cache_info: CacheInfo, key: Any, key_hint: 'IgniteDataType' = None
) -> 'APIResult':
    """
    Clears the cache key without notifying listeners or cache writers.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param key:  key for the cache entry,
    :param key_hint: (optional) Ignite data type, for which the given key
     should be converted
    :return: API result data object. Contains zero status and a boolean
     success code, or non-zero status and an error description if something
     has gone wrong.
    """
    return __cache_remove_key(connection, cache_info, key, key_hint)


async def cache_remove_key_async(
        connection: 'AioConnection', cache_info: CacheInfo, key: Any, key_hint: 'IgniteDataType' = None
) -> 'APIResult':
    """
    Async version of cache_remove_key.
    """
    return await __cache_remove_key(connection, cache_info, key, key_hint)


def __cache_remove_key(connection, cache_info, key, key_hint):
    query_struct = Query(
        OP_CACHE_REMOVE_KEY,
        [
            ('cache_info', CacheInfo),
            ('key', key_hint or AnyDataObject),
        ]
    )
    return query_perform(
        query_struct, connection,
        query_params={
            'cache_info': cache_info,
            'key': key,
        },
        response_config=[
            ('success', Bool),
        ],
        post_process_fun=__post_process_value_by_key('success')
    )


def cache_remove_if_equals(connection: 'Connection', cache_info: CacheInfo, key: Any, sample: Any,
                           key_hint: 'IgniteDataType' = None, sample_hint: 'IgniteDataType' = None) -> 'APIResult':
    """
    Removes an entry with a given key if provided value is equal to
    actual value, notifying listeners and cache writers.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param key:  key for the cache entry,
    :param sample: a sample to compare the stored value with,
    :param key_hint: (optional) Ignite data type, for which the given key
     should be converted,
    :param sample_hint: (optional) Ignite data type, for whic
     the given sample should be converted,
    :return: API result data object. Contains zero status and a boolean
     success code, or non-zero status and an error description if something
     has gone wrong.
    """
    return __cache_remove_if_equals(connection, cache_info, key, sample, key_hint, sample_hint)


async def cache_remove_if_equals_async(
        connection: 'AioConnection', cache_info: CacheInfo, key: Any, sample: Any,
        key_hint: 'IgniteDataType' = None, sample_hint: 'IgniteDataType' = None
) -> 'APIResult':
    """
    Async version of cache_remove_if_equals.
    """
    return await __cache_remove_if_equals(connection, cache_info, key, sample, key_hint, sample_hint)


def __cache_remove_if_equals(connection, cache_info, key, sample, key_hint, sample_hint):
    query_struct = Query(
        OP_CACHE_REMOVE_IF_EQUALS,
        [
            ('cache_info', CacheInfo),
            ('key', key_hint or AnyDataObject),
            ('sample', sample_hint or AnyDataObject),
        ]
    )
    return query_perform(
        query_struct, connection,
        query_params={
            'cache_info': cache_info,
            'key': key,
            'sample': sample,
        },
        response_config=[
            ('success', Bool),
        ],
        post_process_fun=__post_process_value_by_key('success')
    )


def cache_remove_keys(connection: 'Connection', cache_info: CacheInfo, keys: Iterable) -> 'APIResult':
    """
    Removes entries with given keys, notifying listeners and cache writers.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param keys: list of keys or tuples of (key, key_hint),
    :return: API result data object. Contains zero status on success,
     non-zero status and an error description otherwise.
    """
    return __cache_remove_keys(connection, cache_info, keys)


async def cache_remove_keys_async(connection: 'AioConnection', cache_info: CacheInfo, keys: Iterable) -> 'APIResult':
    """
    Async version of cache_remove_keys.
    """
    return await __cache_remove_keys(connection, cache_info, keys)


def __cache_remove_keys(connection, cache_info, keys):
    query_struct = Query(
        OP_CACHE_REMOVE_KEYS,
        [
            ('cache_info', CacheInfo),
            ('keys', AnyDataArray()),
        ]
    )
    return query_perform(
        query_struct, connection,
        query_params={
            'cache_info': cache_info,
            'keys': keys,
        },
    )


def cache_remove_all(connection: 'Connection', cache_info: CacheInfo) -> 'APIResult':
    """
    Removes all entries from cache_info, notifying listeners and cache writers.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :return: API result data object. Contains zero status on success,
     non-zero status and an error description otherwise.
    """
    return __cache_remove_all(connection, cache_info)


async def cache_remove_all_async(connection: 'AioConnection', cache_info: CacheInfo) -> 'APIResult':
    """
    Async version of cache_remove_all.
    """
    return await __cache_remove_all(connection, cache_info)


def __cache_remove_all(connection, cache_info):
    query_struct = Query(
        OP_CACHE_REMOVE_ALL,
        [
            ('cache_info', CacheInfo),
        ]
    )
    return query_perform(
        query_struct, connection,
        query_params={
            'cache_info': cache_info,
        },
    )


def cache_get_size(
        connection: 'Connection', cache_info: CacheInfo, peek_modes: Union[int, list, tuple] = None
) -> 'APIResult':
    """
    Gets the number of entries in cache.

    :param connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param peek_modes: (optional) limit count to near cache partition
     (PeekModes.NEAR), primary cache (PeekModes.PRIMARY), or backup cache
     (PeekModes.BACKUP). Defaults to pimary cache partitions (PeekModes.PRIMARY),
    :return: API result data object. Contains zero status and a number of
     cache entries on success, non-zero status and an error description
     otherwise.
    """
    return __cache_get_size(connection, cache_info, peek_modes)


async def cache_get_size_async(
        connection: 'AioConnection', cache_info: CacheInfo, peek_modes: Union[int, list, tuple] = None
) -> 'APIResult':
    return await __cache_get_size(connection, cache_info, peek_modes)


def __cache_get_size(connection, cache_info, peek_modes):
    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),
        ]
    )
    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 cache_local_peek(
        conn: 'Connection', cache_info: CacheInfo, key: Any, key_hint: 'IgniteDataType' = None,
        peek_modes: Union[int, list, tuple] = None
) -> 'APIResult':
    """
    Peeks at in-memory cached value using default optional peek mode.

    This method will not load value from any cache store or from a remote
    node.

    :param conn: connection: connection to Ignite server,
    :param cache_info: cache meta info,
    :param key: entry key,
    :param key_hint: (optional) Ignite data type, for which the given key
     should be converted,
    :param peek_modes: (optional) limit count to near cache partition
     (PeekModes.NEAR), primary cache (PeekModes.PRIMARY), or backup cache
     (PeekModes.BACKUP). Defaults to primary cache partitions (PeekModes.PRIMARY),
    :return: API result data object. Contains zero status and a peeked value
     (null if not found).
    """
    return __cache_local_peek(conn, cache_info, key, key_hint, peek_modes)


async def cache_local_peek_async(
        conn: 'AioConnection', cache_info: CacheInfo, key: Any, key_hint: 'IgniteDataType' = None,
        peek_modes: Union[int, list, tuple] = None,
) -> 'APIResult':
    """
    Async version of cache_local_peek.
    """
    return await __cache_local_peek(conn, cache_info, key, key_hint, peek_modes)


def __cache_local_peek(conn, cache_info, key, key_hint, peek_modes):
    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),
        ]
    )
    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 __post_process_value_by_key(key):
    def internal(result):
        if result.status == 0:
            result.value = result.value[key]

        return result
    return internal