pyreindexer 0.5.110000
A connector that allows to interact with Reindexer. Reindexer static library or reindexer-dev package must be installed
License: Apache License 2.0
Requires Python: >=3.8
Keywords: reindexer, reindexer-py, in-memory-database, database, python, connector

# The PyReindexer module provides a connector and its auxiliary tools for interaction with Reindexer. Reindexer static library or reindexer-dev package must be installed

- [The PyReindexer module provides a connector and its auxiliary tools for interaction with Reindexer. Reindexer static library or reindexer-dev package must be installed](#the-pyreindexer-module-provides-a-connector-and-its-auxiliary-tools-for-interaction-with-reindexer-reindexer-static-library-or-reindexer-dev-package-must-be-installed)
- [pyreindexer.rx\_connector](#pyreindexerrx_connector)
  - [RxConnector Objects](#rxconnector-objects)
      - [Arguments](#arguments)
      - [Attributes](#attributes)
    - [RxConnector.close](#rxconnectorclose)
      - [Raises](#raises)
    - [RxConnector.namespace\_open](#rxconnectornamespace_open)
      - [Arguments](#arguments-1)
      - [Raises](#raises-1)
    - [RxConnector.namespace\_close](#rxconnectornamespace_close)
      - [Arguments](#arguments-2)
      - [Raises](#raises-2)
    - [RxConnector.namespace\_drop](#rxconnectornamespace_drop)
      - [Arguments](#arguments-3)
      - [Raises](#raises-3)
    - [RxConnector.namespaces\_enum](#rxconnectornamespaces_enum)
      - [Arguments](#arguments-4)
      - [Returns](#returns)
      - [Raises](#raises-4)
    - [RxConnector.index\_add](#rxconnectorindex_add)
      - [Arguments](#arguments-5)
      - [Raises](#raises-5)
    - [RxConnector.index\_update](#rxconnectorindex_update)
      - [Arguments](#arguments-6)
      - [Raises](#raises-6)
    - [RxConnector.index\_drop](#rxconnectorindex_drop)
      - [Arguments](#arguments-7)
      - [Raises](#raises-7)
    - [RxConnector.item\_insert](#rxconnectoritem_insert)
      - [Arguments](#arguments-8)
      - [Raises](#raises-8)
    - [RxConnector.item\_update](#rxconnectoritem_update)
      - [Arguments](#arguments-9)
      - [Raises](#raises-9)
    - [RxConnector.item\_upsert](#rxconnectoritem_upsert)
      - [Arguments](#arguments-10)
      - [Raises](#raises-10)
    - [RxConnector.item\_delete](#rxconnectoritem_delete)
      - [Arguments](#arguments-11)
      - [Raises](#raises-11)
    - [RxConnector.meta\_put](#rxconnectormeta_put)
      - [Arguments](#arguments-12)
      - [Raises](#raises-12)
    - [RxConnector.meta\_get](#rxconnectormeta_get)
      - [Arguments](#arguments-13)
      - [Returns](#returns-1)
      - [Raises](#raises-13)
    - [RxConnector.meta\_delete](#rxconnectormeta_delete)
      - [Arguments](#arguments-14)
      - [Raises](#raises-14)
    - [RxConnector.meta\_enum](#rxconnectormeta_enum)
      - [Arguments](#arguments-15)
      - [Returns](#returns-2)
      - [Raises](#raises-15)
    - [RxConnector.exec\_sql](#rxconnectorexec_sql)
      - [Arguments](#arguments-16)
      - [Returns](#returns-3)
      - [Raises](#raises-16)
    - [RxConnector.new\_transaction](#rxconnectornew_transaction)
      - [Arguments](#arguments-17)
      - [Returns](#returns-4)
      - [Raises](#raises-17)
    - [RxConnector.new\_query](#rxconnectornew_query)
      - [Arguments](#arguments-18)
      - [Returns](#returns-5)
      - [Raises](#raises-18)
- [pyreindexer.query\_results](#pyreindexerquery_results)
  - [QueryResults Objects](#queryresults-objects)
      - [Attributes](#attributes-1)
    - [QueryResults.status](#queryresultsstatus)
      - [Raises](#raises-19)
    - [QueryResults.count](#queryresultscount)
      - [Returns](#returns-6)
    - [QueryResults.total\_count](#queryresultstotal_count)
      - [Returns](#returns-7)
    - [QueryResults.get\_agg\_results](#queryresultsget_agg_results)
      - [Returns](#returns-8)
      - [Raises](#raises-20)
    - [QueryResults.get\_explain\_results](#queryresultsget_explain_results)
      - [Returns](#returns-9)
      - [Raises](#raises-21)
- [pyreindexer.transaction](#pyreindexertransaction)
  - [Transaction Objects](#transaction-objects)
      - [Attributes](#attributes-2)
    - [Transaction.insert](#transactioninsert)
      - [Arguments](#arguments-19)
      - [Raises](#raises-22)
    - [Transaction.update](#transactionupdate)
      - [Arguments](#arguments-20)
      - [Raises](#raises-23)
    - [Transaction.update\_query](#transactionupdate_query)
      - [Arguments](#arguments-21)
      - [Raises](#raises-24)
    - [Transaction.upsert](#transactionupsert)
      - [Arguments](#arguments-22)
      - [Raises](#raises-25)
    - [Transaction.delete](#transactiondelete)
      - [Arguments](#arguments-23)
      - [Raises](#raises-26)
    - [Transaction.delete\_query](#transactiondelete_query)
      - [Arguments](#arguments-24)
      - [Raises](#raises-27)
    - [Transaction.commit](#transactioncommit)
      - [Arguments](#arguments-25)
      - [Raises](#raises-28)
    - [Transaction.commit\_with\_count](#transactioncommit_with_count)
      - [Arguments](#arguments-26)
      - [Raises](#raises-29)
    - [Transaction.rollback](#transactionrollback)
      - [Arguments](#arguments-27)
      - [Raises](#raises-30)
- [pyreindexer.point](#pyreindexerpoint)
  - [Point Objects](#point-objects)
      - [Attributes](#attributes-3)
- [pyreindexer.query](#pyreindexerquery)
  - [Query Objects](#query-objects)
      - [Attributes](#attributes-4)
    - [Query.where](#querywhere)
      - [Arguments](#arguments-28)
      - [Returns](#returns-10)
      - [Raises](#raises-31)
    - [Query.where\_query](#querywhere_query)
      - [Arguments](#arguments-29)
      - [Returns](#returns-11)
      - [Raises](#raises-32)
    - [Query.where\_subquery](#querywhere_subquery)
      - [Arguments](#arguments-30)
      - [Returns](#returns-12)
    - [Query.where\_composite](#querywhere_composite)
      - [Arguments](#arguments-31)
      - [Returns](#returns-13)
      - [Raises](#raises-33)
    - [Query.where\_uuid](#querywhere_uuid)
      - [Arguments](#arguments-32)
      - [Returns](#returns-14)
      - [Raises](#raises-34)
    - [Query.where\_between\_fields](#querywhere_between_fields)
      - [Arguments](#arguments-33)
      - [Returns](#returns-15)
    - [Query.where\_knn](#querywhere_knn)
      - [Arguments](#arguments-34)
      - [Returns](#returns-16)
      - [Raises](#raises-35)
    - [Query.where\_knn\_string](#querywhere_knn_string)
      - [Arguments](#arguments-35)
      - [Returns](#returns-17)
      - [Raises](#raises-36)
    - [Query.open\_bracket](#queryopen_bracket)
      - [Returns](#returns-18)
      - [Raises](#raises-37)
    - [Query.close\_bracket](#queryclose_bracket)
      - [Returns](#returns-19)
      - [Raises](#raises-38)
    - [Query.match](#querymatch)
      - [Arguments](#arguments-36)
      - [Returns](#returns-20)
      - [Raises](#raises-39)
    - [Query.dwithin](#querydwithin)
      - [Arguments](#arguments-37)
      - [Returns](#returns-21)
    - [Query.distinct](#querydistinct)
      - [Arguments](#arguments-38)
      - [Returns](#returns-22)
    - [Query.aggregate\_sum](#queryaggregate_sum)
      - [Arguments](#arguments-39)
      - [Returns](#returns-23)
    - [Query.aggregate\_avg](#queryaggregate_avg)
      - [Arguments](#arguments-40)
      - [Returns](#returns-24)
    - [Query.aggregate\_min](#queryaggregate_min)
      - [Arguments](#arguments-41)
      - [Returns](#returns-25)
    - [Query.aggregate\_max](#queryaggregate_max)
      - [Arguments](#arguments-42)
      - [Returns](#returns-26)
    - [Query.aggregate\_facet](#queryaggregate_facet)
      - [Arguments](#arguments-43)
      - [Returns](#returns-27)
    - [Query.sort](#querysort)
      - [Arguments](#arguments-44)
      - [Returns](#returns-28)
      - [Raises](#raises-40)
    - [Query.sort\_stpoint\_distance](#querysort_stpoint_distance)
      - [Arguments](#arguments-45)
      - [Returns](#returns-29)
    - [Query.sort\_stfield\_distance](#querysort_stfield_distance)
      - [Arguments](#arguments-46)
      - [Returns](#returns-30)
      - [Raises](#raises-41)
    - [Query.op\_and](#queryop_and)
      - [Returns](#returns-31)
    - [Query.op\_or](#queryop_or)
      - [Returns](#returns-32)
    - [Query.op\_not](#queryop_not)
      - [Returns](#returns-33)
    - [Query.request\_total](#queryrequest_total)
      - [Arguments](#arguments-47)
      - [Returns](#returns-34)
    - [Query.cached\_total](#querycached_total)
      - [Arguments](#arguments-48)
      - [Returns](#returns-35)
    - [Query.limit](#querylimit)
      - [Arguments](#arguments-49)
      - [Returns](#returns-36)
    - [Query.offset](#queryoffset)
      - [Arguments](#arguments-50)
      - [Returns](#returns-37)
    - [Query.debug](#querydebug)
      - [Arguments](#arguments-51)
      - [Returns](#returns-38)
    - [Query.strict](#querystrict)
      - [Arguments](#arguments-52)
      - [Returns](#returns-39)
    - [Query.explain](#queryexplain)
      - [Returns](#returns-40)
    - [Query.with\_rank](#querywith_rank)
      - [Returns](#returns-41)
    - [Query.execute](#queryexecute)
      - [Arguments](#arguments-53)
      - [Returns](#returns-42)
      - [Raises](#raises-42)
    - [Query.delete](#querydelete)
      - [Arguments](#arguments-54)
      - [Returns](#returns-43)
      - [Raises](#raises-43)
    - [Query.set\_object](#queryset_object)
      - [Arguments](#arguments-55)
      - [Returns](#returns-44)
      - [Raises](#raises-44)
    - [Query.set](#queryset)
      - [Arguments](#arguments-56)
      - [Returns](#returns-45)
      - [Raises](#raises-45)
    - [Query.drop](#querydrop)
      - [Arguments](#arguments-57)
      - [Returns](#returns-46)
    - [Query.expression](#queryexpression)
      - [Arguments](#arguments-58)
      - [Returns](#returns-47)
    - [Query.update](#queryupdate)
      - [Arguments](#arguments-59)
      - [Returns](#returns-48)
      - [Raises](#raises-46)
    - [Query.must\_execute](#querymust_execute)
      - [Arguments](#arguments-60)
      - [Returns](#returns-49)
      - [Raises](#raises-47)
    - [Query.get](#queryget)
      - [Arguments](#arguments-61)
      - [Returns](#returns-50)
      - [Raises](#raises-48)
    - [Query.inner\_join](#queryinner_join)
      - [Arguments](#arguments-62)
      - [Returns](#returns-51)
    - [Query.join](#queryjoin)
      - [Arguments](#arguments-63)
      - [Returns](#returns-52)
    - [Query.left\_join](#queryleft_join)
      - [Arguments](#arguments-64)
      - [Returns](#returns-53)
    - [Query.merge](#querymerge)
      - [Arguments](#arguments-65)
      - [Returns](#returns-54)
    - [Query.on](#queryon)
      - [Arguments](#arguments-66)
      - [Returns](#returns-55)
      - [Raises](#raises-49)
    - [Query.select\_fields](#queryselect_fields)
      - [Arguments](#arguments-67)
      - [Returns](#returns-56)
      - [Raises](#raises-50)
    - [Query.functions](#queryfunctions)
      - [Arguments](#arguments-68)
      - [Returns](#returns-57)
      - [Raises](#raises-51)
    - [Query.equal\_position](#queryequal_position)
      - [Arguments](#arguments-69)
      - [Returns](#returns-58)
      - [Raises](#raises-52)
- [pyreindexer.index\_search\_params](#pyreindexerindex_search_params)
  - [IndexSearchParamBruteForce Objects](#indexsearchparambruteforce-objects)
      - [Attributes](#attributes-5)
  - [IndexSearchParamHnsw Objects](#indexsearchparamhnsw-objects)
      - [Attributes](#attributes-6)
  - [IndexSearchParamIvf Objects](#indexsearchparamivf-objects)
      - [Attributes](#attributes-7)
- [pyreindexer.index\_definition](#pyreindexerindex_definition)
  - [IndexDefinition Objects](#indexdefinition-objects)
      - [Arguments](#arguments-70)

<a id="pyreindexer.rx_connector"></a>

# pyreindexer.rx\_connector

<a id="pyreindexer.rx_connector.RxConnector"></a>

## RxConnector Objects

```python
class RxConnector(RaiserMixin)
```

RxConnector provides a binding to Reindexer upon two shared libraries (hereinafter - APIs): 'rawpyreindexerb.so'
    and 'rawpyreindexerc.so'. The first one is aimed at built-in usage. That API embeds Reindexer, so it could
    be used right in-place as is. The second one acts as a lightweight client which establishes a connection to
    Reindexer server via RPC. The APIs interfaces are completely the same.

#### Arguments:
        dsn (string): The connection string which contains a protocol
            Examples: 'builtin:///tmp/pyrx', 'cproto://127.0.0.1:6534/pyrx'

        cproto options:
             fetch_amount (int): The number of items that will be fetched by one operation
             reconnect_attempts (int): Number of reconnection attempts when connection is lost
             net_timeout (`datetime.timedelta`): Connection and database login timeout value [milliseconds]
             enable_compression (bool): Flag enable/disable traffic compression
             start_special_thread (bool): Determines whether to request a special thread of execution
                on the server for this connection
             client_name (string): Proper name of the application (as a client for Reindexer-server)
             sync_rxcoro_count (int): Client concurrency per connection [1..10'000], default 10

        built-in options:
            max_replication_updates_size (int): Max pended replication updates size in bytes
            allocator_cache_limit (int): Recommended maximum free cache size of tcmalloc memory allocator in bytes
            allocator_cache_part (float): Recommended maximum free cache size of tcmalloc memory allocator in
                relation to total Reindexer allocated memory size, in units

#### Attributes:
    api (module): An API module loaded dynamically for Reindexer calls
    rx (int): A memory pointer to the Reindexer instance
    err_code (int): The API error code
    err_msg (string): The API error message

<a id="pyreindexer.rx_connector.RxConnector.close"></a>

### RxConnector.close

```python
def close() -> None
```

Closes the API instance and frees Reindexer resources

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet

<a id="pyreindexer.rx_connector.RxConnector.namespace_open"></a>

### RxConnector.namespace\_open

```python
def namespace_open(
    namespace: str, timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Opens a namespace specified or creates a namespace if it does not exist

#### Arguments:
    namespace (string): The name of the namespace
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.namespace_close"></a>

### RxConnector.namespace\_close

```python
def namespace_close(
    namespace: str, timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Closes the specified namespace

#### Arguments:
    namespace (string): The name of the namespace
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.namespace_drop"></a>

### RxConnector.namespace\_drop

```python
def namespace_drop(
    namespace: str, timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Drops the specified namespace

#### Arguments:
    namespace (string): The name of the namespace
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    Exception: Raises with an error message when Reindexer instance is not initialized yet
    Exception: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.namespaces_enum"></a>

### RxConnector.namespaces\_enum

```python
def namespaces_enum(
    enum_not_opened: bool = False,
    timeout: timedelta = timedelta(milliseconds=0)
) -> List[Dict[str, str]]
```

Gets a list of namespaces available

#### Arguments:
    enum_not_opened (bool, optional): An enumeration mode flag. If it is
        set then closed namespaces are in result list too. Defaults to False
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Returns:
    (:obj:`list` of :obj:`dict`): A list of dictionaries which describe each namespace

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.index_add"></a>

### RxConnector.index\_add

```python
def index_add(
    namespace: str,
    index_def: Dict,
    timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Adds an index to the specified namespace

#### Arguments:
    namespace (string): The name of the namespace
    index_def (dict): A dictionary of index definition
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.index_update"></a>

### RxConnector.index\_update

```python
def index_update(
    namespace: str,
    index_def: Dict,
    timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Updates an index in the specified namespace

#### Arguments:
    namespace (string): The name of the namespace
    index_def (dict): A dictionary of index definition
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.index_drop"></a>

### RxConnector.index\_drop

```python
def index_drop(
    namespace: str,
    index_name: str,
    timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Drops an index from the specified namespace

#### Arguments:
    namespace (string): The name of the namespace
    index_name (string): A name of an index
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.item_insert"></a>

### RxConnector.item\_insert

```python
def item_insert(
    namespace: str,
    item_def: Dict,
    precepts: List[str] = None,
    timeout: timedelta = timedelta(milliseconds=0)
) -> None
```

Inserts an item with its precepts into the specified namespace

#### Arguments:
    namespace (string): The name of the namespace
    item_def (dict): A dictionary of item definition
    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.item_update"></a>

### RxConnector.item\_update

```python
def item_update(
    namespace: str,
    item_def: Dict,
    precepts: List[str] = None,
    timeout: timedelta = timedelta(milliseconds=0)
) -> None
```

Updates an item with its precepts in the specified namespace

#### Arguments:
    namespace (string): The name of the namespace
    item_def (dict): A dictionary of item definition
    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.item_upsert"></a>

### RxConnector.item\_upsert

```python
def item_upsert(
    namespace: str,
    item_def: Dict,
    precepts: List[str] = None,
    timeout: timedelta = timedelta(milliseconds=0)
) -> None
```

Updates an item with its precepts in the specified namespace. Creates the item if it does not exist

#### Arguments:
    namespace (string): The name of the namespace
    item_def (dict): A dictionary of item definition
    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.item_delete"></a>

### RxConnector.item\_delete

```python
def item_delete(
    namespace: str,
    item_def: Dict,
    timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Deletes an item from the namespace specified

#### Arguments:
    namespace (string): The name of the namespace
    item_def (dict): A dictionary of item definition
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.meta_put"></a>

### RxConnector.meta\_put

```python
def meta_put(
    namespace: str,
    key: str,
    value: str,
    timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Puts metadata to a storage of Reindexer by key

#### Arguments:
    namespace (string): The name of the namespace
    key (string): A key in a storage of Reindexer for metadata keeping
    value (string): A metadata for storage
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.meta_get"></a>

### RxConnector.meta\_get

```python
def meta_get(namespace: str,
             key: str,
             timeout: timedelta = timedelta(milliseconds=0)) -> str
```

Gets metadata from a storage of Reindexer by key specified

#### Arguments:
    namespace (string): The name of the namespace
    key (string): A key in a storage of Reindexer where metadata is kept
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Returns:
    string: A metadata value

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.meta_delete"></a>

### RxConnector.meta\_delete

```python
def meta_delete(
    namespace: str, key: str,
    timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Deletes metadata from a storage of Reindexer by key specified

#### Arguments:
    namespace (string): The name of the namespace
    key (string): A key in a storage of Reindexer where metadata is kept
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.meta_enum"></a>

### RxConnector.meta\_enum

```python
def meta_enum(
    namespace: str,
    timeout: timedelta = timedelta(milliseconds=0)) -> List[str]
```

Gets a list of metadata keys from a storage of Reindexer

#### Arguments:
    namespace (string): The name of the namespace
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Returns:
    (:obj:`list` of :obj:`str`): A list of all metadata keys

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.exec_sql"></a>

### RxConnector.exec_sql

```python
def exec_sql(
    query: str,
    timeout: timedelta = timedelta(milliseconds=0)) -> QueryResults
```

Executes an SQL query and returns query results

#### Arguments:
    query (string): An SQL query
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Returns:
    (:obj:`QueryResults`): A QueryResults iterator

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.new_transaction"></a>

### RxConnector.new\_transaction

```python
def new_transaction(
    namespace: str,
    timeout: timedelta = timedelta(milliseconds=0)) -> Transaction
```

Starts a new transaction and return the transaction object to processing.
    Warning: once a timeout is set, it will apply to all subsequent steps in the transaction

#### Arguments:
    namespace (string): The name of the namespace
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Returns:
    (:obj:`Transaction`): A new transaction

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.rx_connector.RxConnector.new_query"></a>

### RxConnector.new\_query

```python
def new_query(namespace: str) -> Query
```

Creates a new query and return the query object to processing

#### Arguments:
    namespace (string): The name of the namespace

#### Returns:
    (:obj:`Query`): A new query

#### Raises:
    ConnectionError: Raises with an error message when Reindexer instance is not initialized yet

<a id="pyreindexer.query_results"></a>

# pyreindexer.query\_results

<a id="pyreindexer.query_results.QueryResults"></a>

## QueryResults Objects

```python
class QueryResults()
```

QueryResults is a disposable iterator of Reindexer results for such queries as SELECT etc.
    When the results are fetched the iterator closes and frees a memory of results buffer of Reindexer

#### Attributes:
    api (module): An API module for Reindexer calls
    err_code (int): The API error code
    err_msg (string): The API error message
    qres_wrapper_ptr (int): A memory pointer to Reindexer iterator object
    qres_iter_count (int): A count of results for iterations
    pos (int): The current result position in iterator

<a id="pyreindexer.query_results.QueryResults.status"></a>

### QueryResults.status

```python
def status() -> None
```

Check status

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query_results.QueryResults.count"></a>

### QueryResults.count

```python
def count() -> int
```

Returns a count of results for iterations

#### Returns
    int: A count of results

<a id="pyreindexer.query_results.QueryResults.total_count"></a>

### QueryResults.total\_count

```python
def total_count() -> int
```

Returns a total or cached count of results

#### Returns
    int: A total or cached count of results

<a id="pyreindexer.query_results.QueryResults.get_agg_results"></a>

### QueryResults.get\_agg\_results

```python
def get_agg_results() -> dict
```

Returns aggregation results for the current query

#### Returns
    (:obj:`dict`): Dictionary with all results for the current query

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query_results.QueryResults.get_explain_results"></a>

### QueryResults.get\_explain\_results

```python
def get_explain_results() -> str
```

Returns explain results for the current query

#### Returns
    (string): Formatted string with explain of results for the current query

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction"></a>

# pyreindexer.transaction

<a id="pyreindexer.transaction.Transaction"></a>

## Transaction Objects

```python
class Transaction()
```

An object representing the context of a Reindexer transaction

#### Attributes:
    api (module): An API module for Reindexer calls
    transaction_wrapper_ptr (int): A memory pointer to Reindexer transaction object
    err_code (int): The API error code
    err_msg (string): The API error message

<a id="pyreindexer.transaction.Transaction.insert"></a>

### Transaction.insert

```python
def insert(item_def: Dict, precepts: List[str] = None) -> None
```

Inserts an item with its precepts to the transaction
    Warning: the timeout set when the transaction was created is used

#### Arguments:
    item_def (dict): A dictionary of item definition
    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.update"></a>

### Transaction.update

```python
def update(item_def: Dict, precepts: List[str] = None) -> None
```

Updates an item with its precepts to the transaction
    Warning: the timeout set when the transaction was created is used

#### Arguments:
    item_def (dict): A dictionary of item definition
    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.update_query"></a>

### Transaction.update\_query

```python
def update_query(query: Query) -> None
```

Updates items with the transaction
    Read-committed isolation is available for read operations.
    Changes made in active transaction is invisible to current and another transactions.

#### Arguments:
    query (:obj:`Query`): A query object to modify

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.upsert"></a>

### Transaction.upsert

```python
def upsert(item_def: Dict, precepts: List[str] = None) -> None
```

Updates an item with its precepts to the transaction. Creates the item if it does not exist
    Warning: the timeout set when the transaction was created is used

#### Arguments:
    item_def (dict): A dictionary of item definition
    precepts (:obj:`list` of :obj:`str`): A dictionary of index definition

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.delete"></a>

### Transaction.delete

```python
def delete(item_def: Dict) -> None
```

Deletes an item from the transaction
    Warning: the timeout set when the transaction was created is used

#### Arguments:
    item_def (dict): A dictionary of item definition

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.delete_query"></a>

### Transaction.delete\_query

```python
def delete_query(query: Query)
```

Deletes items with the transaction
    Read-committed isolation is available for read operations.
    Changes made in active transaction is invisible to current and another transactions.

#### Arguments:
    query (:obj:`Query`): A query object to modify

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.commit"></a>

### Transaction.commit

```python
def commit(timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Applies changes

#### Arguments:
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.commit_with_count"></a>

### Transaction.commit\_with\_count

```python
def commit_with_count(timeout: timedelta = timedelta(milliseconds=0)) -> int
```

Applies changes and return the number of count of changed items

#### Arguments:
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.transaction.Transaction.rollback"></a>

### Transaction.rollback

```python
def rollback(timeout: timedelta = timedelta(milliseconds=0)) -> None
```

Rollbacks changes

#### Arguments:
    timeout (`datetime.timedelta`): Optional timeout for performing a server-side operation.
        Minimum is 1 millisecond; if set to a lower value, it corresponds to disabling the timeout.
        A value of 0 disables the timeout (default value)

#### Raises:
    TransactionError: Raises with an error message of API return if Transaction is over
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.point"></a>

# pyreindexer.point

<a id="pyreindexer.point.Point"></a>

## Point Objects

```python
class Point()
```

An object representing the context of a Reindexer 2D point

#### Attributes:
    x (float): x coordinate of the point
    y (float): y coordinate of the point

<a id="pyreindexer.query"></a>

# pyreindexer.query

<a id="pyreindexer.query.Query"></a>

## Query Objects

```python
class Query()
```

An object representing the context of a Reindexer query

#### Attributes:
    api (module): An API module for Reindexer calls
    query_wrapper_ptr (int): A memory pointer to Reindexer query object
    err_code (int): The API error code
    err_msg (string): The API error message
    root (:object: Optional[`Query`]): The root query of the Reindexer query
    join_queries (list[:object:`Query`]): The list of join Reindexer query objects
    merged_queries (list[:object:`Query`]): The list of merged Reindexer query objects

<a id="pyreindexer.query.Query.where"></a>

### Query.where

```python
def where(
        index: str,
        condition: CondType,
        keys: Union[simple_types, tuple[list[simple_types],
                                        ...]] = None) -> Query
```

Adds where condition to DB query with args

#### Arguments:
    index (string): Field name used in condition clause
    condition (:enum:`CondType`): Type of condition
    keys (union[simple_types, (list[simple_types], ...)]):
        Value of index to be compared with. For composite indexes keys must be list,
        with value of each sub-index

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.where_query"></a>

### Query.where\_query

```python
def where_query(
        sub_query: Query,
        condition: CondType,
        keys: Union[simple_types, tuple[list[simple_types],
                                        ...]] = None) -> Query
```

Adds sub-query where condition to DB query with args

#### Arguments:
    sub_query (:obj:`Query`): Field name used in condition clause
    condition (:enum:`CondType`): Type of condition
    keys (union[simple_types, (list[simple_types], ...)]):
        Value of index to be compared with. For composite indexes keys must be list,
        with value of each sub-index

#### Returns:
    (:obj:`Query`): Query object for further customizations

#### Raises:
    ApiError: Raises with an error message of API return on non-zero error code

<a id="pyreindexer.query.Query.where_subquery"></a>

### Query.where\_subquery

```python
def where_subquery(index: str, condition: CondType, sub_query: Query) -> Query
```

Adds su