diff --git a/LICENSE b/LICENSE
new file mode 100644
index 0000000..d645695
--- /dev/null
+++ b/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed 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.
diff --git a/README.md b/README.md
new file mode 100644
index 0000000..22732ce
--- /dev/null
+++ b/README.md
@@ -0,0 +1,75 @@
+# ignite-python-client
+Apache Ignite thin (binary protocol) client, written in Python 3.
+
+## Prerequisites
+
+- Python 3.4 or above (3.6 is tested),
+- Access to Apache Ignite node, local or remote. The current thin client
+  version was tested on Apache Ignite 2.7.0 (binary client protocol 1.2.0).
+
+## Installation
+
+#### *for end user*
+If you only want to use the `pyignite` module in your project, do:
+```
+$ pip install pyignite
+```
+
+#### *for developer*
+If you want to run tests, examples or build documentation, clone
+the whole repository:
+```
+$ git clone git@github.com:apache/ignite.git
+$ cd ignite/modules/platforms/python
+$ pip install -e .
+```
+
+This will install the repository version of `pyignite` into your environment
+in so-called “develop” or “editable” mode. You may read more about
+[editable installs](https://pip.pypa.io/en/stable/reference/pip_install/#editable-installs)
+in the `pip` manual.
+
+Then run through the contents of `requirements` folder to install
+the additional requirements into your working Python environment using
+```
+$ pip install -r requirements/<your task>.txt
+```
+
+You may also want to consult the `setuptools` manual about using `setup.py`.
+
+## Documentation
+[The package documentation](https://apache-ignite-binary-protocol-client.readthedocs.io)
+is available at *RTD* for your convenience.
+
+If you want to build the documentation from source, do the developer
+installation as described above, then run the following commands:
+```
+$ cd ignite/modules/platforms/python
+$ pip install -r requirements/docs.txt
+$ cd docs
+$ make html
+```
+
+Then open `ignite/modules/platforms/python/docs/generated/html/index.html`
+in your browser.
+
+## Examples
+Some examples of using pyignite are provided in
+`ignite/modules/platforms/python/examples` folder. They are extensively
+commented in the
+“[Examples of usage](https://apache-ignite-binary-protocol-client.readthedocs.io/en/latest/examples.html)”
+section of the documentation.
+
+This code implies that it is run in the environment with `pyignite` package
+installed, and Apache Ignite node is running on localhost:10800.
+
+## Testing
+Run
+```
+$ cd ignite/modules/platforms/python
+$ python setup.py pytest
+```
+
+*NB!* All tests require Apache Ignite node running on localhost:10800.
+If you need to change the connection parameters, see the documentation on
+[testing](https://apache-ignite-binary-protocol-client.readthedocs.io/en/latest/readme.html#testing).
diff --git a/docs/Makefile b/docs/Makefile
new file mode 100644
index 0000000..e80dcf6
--- /dev/null
+++ b/docs/Makefile
@@ -0,0 +1,20 @@
+# Minimal makefile for Sphinx documentation
+#
+
+# You can set these variables from the command line.
+SPHINXOPTS    =
+SPHINXBUILD   = sphinx-build
+SPHINXPROJ    = ApacheIgnitebinaryclientPythonAPI
+SOURCEDIR     = .
+BUILDDIR      = generated
+
+# Put it first so that "make" without argument is like "make help".
+help:
+	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
+
+.PHONY: help Makefile
+
+# Catch-all target: route all unknown targets to Sphinx using the new
+# "make mode" option.  $(O) is meant as a shortcut for $(SPHINXOPTS).
+%: Makefile
+	@$(SPHINXBUILD) -M $@ "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
\ No newline at end of file
diff --git a/docs/conf.py b/docs/conf.py
new file mode 100644
index 0000000..8c498aa
--- /dev/null
+++ b/docs/conf.py
@@ -0,0 +1,176 @@
+# -*- coding: utf-8 -*-
+#
+# Configuration file for the Sphinx documentation builder.
+#
+# This file does only contain a selection of the most common options. For a
+# full list see the documentation:
+# http://www.sphinx-doc.org/en/master/config
+
+# -- Path setup --------------------------------------------------------------
+
+# If extensions (or modules to document with autodoc) are in another directory,
+# add these directories to sys.path here. If the directory is relative to the
+# documentation root, use os.path.abspath to make it absolute, like shown here.
+#
+import os
+import sys
+sys.path.insert(0, os.path.abspath('../'))
+
+
+# -- Project information -----------------------------------------------------
+
+project = 'Apache Ignite binary client Python API'
+copyright = '2018, Apache Software Foundation (ASF)'
+author = 'Dmitry Melnichuk'
+
+# The short X.Y version
+version = ''
+# The full version, including alpha/beta/rc tags
+release = '0.1.0'
+
+
+# -- General configuration ---------------------------------------------------
+
+# If your documentation needs a minimal Sphinx version, state it here.
+#
+# needs_sphinx = '1.0'
+
+# Add any Sphinx extension module names here, as strings. They can be
+# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
+# ones.
+extensions = [
+    'sphinx.ext.autodoc',
+    'sphinx.ext.todo',
+    'sphinxcontrib.fulltoc',
+]
+
+# Add any paths that contain templates here, relative to this directory.
+templates_path = ['_templates']
+
+# The suffix(es) of source filenames.
+# You can specify multiple suffix as a list of string:
+#
+# source_suffix = ['.rst', '.md']
+source_suffix = '.rst'
+
+# The master toctree document.
+master_doc = 'index'
+
+# The language for content autogenerated by Sphinx. Refer to documentation
+# for a list of supported languages.
+#
+# This is also used if you do content translation via gettext catalogs.
+# Usually you set "language" from the command line for these cases.
+language = None
+
+# List of patterns, relative to source directory, that match files and
+# directories to ignore when looking for source files.
+# This pattern also affects html_static_path and html_extra_path .
+exclude_patterns = ['_build', 'Thumbs.db', '.DS_Store']
+
+# The name of the Pygments (syntax highlighting) style to use.
+pygments_style = 'sphinx'
+
+
+# -- Options for HTML output -------------------------------------------------
+
+# The theme to use for HTML and HTML Help pages.  See the documentation for
+# a list of builtin themes.
+#
+html_theme = 'alabaster'
+
+# Theme options are theme-specific and customize the look and feel of a theme
+# further.  For a list of options available for each theme, see the
+# documentation.
+#
+# html_theme_options = {}
+
+# Add any paths that contain custom static files (such as style sheets) here,
+# relative to this directory. They are copied after the builtin static files,
+# so a file named "default.css" will overwrite the builtin "default.css".
+html_static_path = []
+
+# Custom sidebar templates, must be a dictionary that maps document names
+# to template names.
+#
+# The default sidebars (for documents that don't match any pattern) are
+# defined by theme itself.  Builtin themes are using these templates by
+# default: ``['localtoc.html', 'relations.html', 'sourcelink.html',
+# 'searchbox.html']``.
+#
+# html_sidebars = {}
+
+
+# -- Options for HTMLHelp output ---------------------------------------------
+
+# Output file base name for HTML help builder.
+htmlhelp_basename = 'ApacheIgnitebinaryclientPythonAPIdoc'
+
+
+# -- Options for LaTeX output ------------------------------------------------
+
+latex_elements = {
+    # The paper size ('letterpaper' or 'a4paper').
+    #
+    # 'papersize': 'letterpaper',
+
+    # The font size ('10pt', '11pt' or '12pt').
+    #
+    # 'pointsize': '10pt',
+
+    # Additional stuff for the LaTeX preamble.
+    #
+    # 'preamble': '',
+
+    # Latex figure (float) alignment
+    #
+    # 'figure_align': 'htbp',
+}
+
+# Grouping the document tree into LaTeX files. List of tuples
+# (source start file, target name, title,
+#  author, documentclass [howto, manual, or own class]).
+latex_documents = [
+    (master_doc, 'ApacheIgnitebinaryclientPythonAPI.tex', 'Apache Ignite binary client Python API Documentation',
+     'Apache Software Foundation (ASF)', 'manual'),
+]
+
+
+# -- Options for manual page output ------------------------------------------
+
+# One entry per manual page. List of tuples
+# (source start file, name, description, authors, manual section).
+man_pages = [
+    (master_doc, 'apacheignitebinaryclientpythonapi', 'Apache Ignite binary client Python API Documentation',
+     [author], 1)
+]
+
+
+# -- Options for Texinfo output ----------------------------------------------
+
+# Grouping the document tree into Texinfo files. List of tuples
+# (source start file, target name, title, author,
+#  dir menu entry, description, category)
+texinfo_documents = [
+    (master_doc, 'ApacheIgnitebinaryclientPythonAPI', 'Apache Ignite binary client Python API Documentation',
+     author, 'ApacheIgnitebinaryclientPythonAPI', 'One line description of project.',
+     'Miscellaneous'),
+]
+
+
+# -- Extension configuration -------------------------------------------------
+
+# -- Options for todo extension ----------------------------------------------
+
+# If true, `todo` and `todoList` produce output, else they produce nothing.
+todo_include_todos = True
+
+
+def skip_fn(app, what, name, obj, skip, options):
+    if name == "__init__":
+        return False
+    return skip
+
+
+def setup(app):
+    app.connect("autodoc-skip-member", skip_fn)
diff --git a/docs/datatypes/cache_props.rst b/docs/datatypes/cache_props.rst
new file mode 100644
index 0000000..03443b9
--- /dev/null
+++ b/docs/datatypes/cache_props.rst
@@ -0,0 +1,163 @@
+..  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.
+
+.. _cache_props:
+
+================
+Cache Properties
+================
+
+The :mod:`~pyignite.datatypes.prop_codes` module contains a list of ordinal
+values, that represent various cache settings.
+
+Please refer to the `Apache Ignite Data Grid`_ documentation on cache
+synchronization, rebalance, affinity and other cache configuration-related
+matters.
+
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| Property                              | Ordinal  | Property | Description                                           |
+| name                                  | value    | type     |                                                       |
++=======================================+==========+==========+=======================================================+
+| Read/write cache properties, used to configure cache via :py:meth:`~pyignite.client.Client.create_cache` or         |
+| :py:meth:`~pyignite.client.Client.get_or_create_cache`                                                              |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_NAME                             |        0 | str      | Cache name. This is the only *required* property.     |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_CACHE_MODE                       |        1 | int      | Cache mode: LOCAL=0, REPLICATED=1, PARTITIONED=2      |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_CACHE_ATOMICITY_MODE             |        2 | int      | Cache atomicity mode: TRANSACTIONAL=0, ATOMIC=1       |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_BACKUPS_NUMBER                   |        3 | int      | Number of backups                                     |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_WRITE_SYNCHRONIZATION_MODE       |        4 | int      | Write synchronization mode: FULL_SYNC=0,              |
+|                                       |          |          | FULL_ASYNC=1, PRIMARY_SYNC=2                          |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_COPY_ON_READ                     |        5 | bool     | Copy-on-read                                          |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_READ_FROM_BACKUP                 |        6 | bool     | Read from backup                                      |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_DATA_REGION_NAME                 |      100 | str      | Data region name                                      |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_IS_ONHEAP_CACHE_ENABLED          |      101 | bool     | Is OnHeap cache enabled?                              |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_QUERY_ENTITIES                   |      200 | list     | A list of query entities (see `Query entity`_)        |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_QUERY_PARALLELISM                |      201 | int      | Query parallelism                                     |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_QUERY_DETAIL_METRIC_SIZE         |      202 | int      | Query detail metric size                              |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_SQL_SCHEMA                       |      203 | str      | SQL schema                                            |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_SQL_INDEX_INLINE_MAX_SIZE        |      204 | int      | SQL index inline maximum size                         |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_SQL_ESCAPE_ALL                   |      205 | bool     | Turns on SQL escapes                                  |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_MAX_QUERY_ITERATORS              |      206 | int      | Maximum number of query iterators                     |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_REBALANCE_MODE                   |      300 | int      | Rebalance mode: SYNC=0, ASYNC=1, NONE=2               |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_REBALANCE_DELAY                  |      301 | int      | Rebalance delay (ms)                                  |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_REBALANCE_TIMEOUT                |      302 | int      | Rebalance timeout (ms)                                |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_REBALANCE_BATCH_SIZE             |      303 | int      | Rebalance batch size                                  |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_REBALANCE_BATCHES_PREFETCH_COUNT |      304 | int      | Rebalance batches prefetch count                      |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_REBALANCE_ORDER                  |      305 | int      | Rebalance order                                       |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_REBALANCE_THROTTLE               |      306 | int      | Rebalance throttle (ms)                               |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_GROUP_NAME                       |      400 | str      | Group name                                            |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_CACHE_KEY_CONFIGURATION          |      401 | list     | Cache key configuration (see `Cache key`_)            |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_DEFAULT_LOCK_TIMEOUT             |      402 | int      | Default lock timeout (ms)                             |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_MAX_CONCURRENT_ASYNC_OPERATIONS  |      403 | int      | Maximum number of concurrent asynchronous operations  |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_PARTITION_LOSS_POLICY            |      404 | int      | Partition loss policy: READ_ONLY_SAFE=0,              |
+|                                       |          |          | READ_ONLY_ALL=1, READ_WRITE_SAFE=2, READ_WRITE_ALL=3, |
+|                                       |          |          | IGNORE=4                                              |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_EAGER_TTL                        |      405 | bool     | Eager TTL                                             |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_STATISTICS_ENABLED               |      406 | bool     | Statistics enabled                                    |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| Read-only cache properties. Can not be set, but only retrieved via :py:meth:`~pyignite.cache.Cache.settings`        |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+| PROP_INVALIDATE                       |       -1 | bool     | Invalidate                                            |
++---------------------------------------+----------+----------+-------------------------------------------------------+
+
+Query entity
+------------
+
+A dict with all ot the following keys:
+
+- `table_name`: SQL table name,
+- `key_field_name`: name of the key field,
+- `key_type_name`: name of the key type (Java type or complex object),
+- `value_field_name`: name of the value field,
+- `value_type_name`: name of the value type,
+- `field_name_aliases`: a list of 0 or more dicts of aliases
+  (see `Field name alias`_),
+- `query_fields`: a list of 0 or more query field names (see `Query field`_),
+- `query_indexes`: a list of 0 or more query indexes (see `Query index`_).
+
+Field name alias
+================
+
+- `field_name`: field name,
+- `alias`: alias (str).
+
+Query field
+===========
+
+- `name`: field name,
+- `type_name`: name of Java type or complex object,
+- `is_key_field`: (optional) boolean value, `False` by default,
+- `is_notnull_constraint_field`: boolean value,
+- `default_value`: (optional) anything that can be converted to `type_name`
+  type. `None` (:py:class:`~pyignite.datatypes.null_object.Null`) by default,
+- `precision` − (optional) decimal precision: total number of digits
+  in decimal value. Defaults to -1 (use cluster default). Ignored for
+  non-decimal SQL types (other than `java.math.BigDecimal`),
+- `scale` − (optional) decimal precision: number of digits after the decimal
+  point. Defaults to -1 (use cluster default). Ignored for non-decimal SQL
+  types.
+
+Query index
+===========
+
+- `index_name`: index name,
+- `index_type`: index type code as an integer value in unsigned byte range,
+- `inline_size`: integer value,
+- `fields`: a list of 0 or more indexed fields (see `Fields`_).
+
+Fields
+======
+
+- `name`: field name,
+- `is_descending`: (optional) boolean value, `False` by default.
+
+Cache key
+---------
+
+A dict of the following format:
+
+- `type_name`: name of the complex object,
+- `affinity_key_field_name`: name of the affinity key field.
+
+.. _Apache Ignite Data Grid: https://apacheignite.readme.io/docs/data-grid
diff --git a/docs/datatypes/parsers.rst b/docs/datatypes/parsers.rst
new file mode 100644
index 0000000..a717f4c
--- /dev/null
+++ b/docs/datatypes/parsers.rst
@@ -0,0 +1,175 @@
+..  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.
+
+.. _data_types:
+
+==========
+Data Types
+==========
+
+Apache Ignite uses a sophisticated system of serializable data types
+to store and retrieve user data, as well as to manage the configuration
+of its caches through the Ignite binary protocol.
+
+The complexity of data types varies from simple integer or character types
+to arrays, maps, collections and structures.
+
+Each data type is defined by its code. `Type code` is byte-sized. Thus,
+every data object can be represented as a payload of fixed or variable size,
+logically divided into one or more fields, prepended by the `type_code` field.
+
+Most of Ignite data types can be represented by some of the standard Python
+data type or class. Some of them, however, are conceptually alien, overly
+complex, or ambiguous to Python dynamic type system.
+
+The following table summarizes the notion of Apache Ignite data types,
+as well as their representation and handling in Python. For the nice
+description, as well as gory implementation details, you may follow the link
+to the parser/constructor class definition. Note that parser/constructor
+classes are not instantiatable. The `class` here is used mostly as a sort of
+tupperware for organizing methods together.
+
+*Note:* you are not obliged to actually use those parser/constructor classes.
+Pythonic types will suffice to interact with Apache Ignite binary API.
+However, in some rare cases of type ambiguity, as well as for the needs
+of interoperability, you may have to sneak one or the other class, along
+with your data, in to some API function as a *type conversion hint*.
+
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|`type_code`|Apache Ignite       |Python type                    |Parser/constructor                                               |
+|           |docs reference      |or class                       |class                                                            |
++===========+====================+===============================+=================================================================+
+|*Primitive data types*                                                                                                            |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x01       |Byte_               |int                            |:class:`~pyignite.datatypes.primitive_objects.ByteObject`        |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x02       |Short_              |int                            |:class:`~pyignite.datatypes.primitive_objects.ShortObject`       |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x03       |Int_                |int                            |:class:`~pyignite.datatypes.primitive_objects.IntObject`         |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x04       |Long_               |int                            |:class:`~pyignite.datatypes.primitive_objects.LongObject`        |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x05       |Float_              |float                          |:class:`~pyignite.datatypes.primitive_objects.FloatObject`       |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x06       |Double_             |float                          |:class:`~pyignite.datatypes.primitive_objects.DoubleObject`      |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x07       |Char_               |str                            |:class:`~pyignite.datatypes.primitive_objects.CharObject`        |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x08       |Bool_               |bool                           |:class:`~pyignite.datatypes.primitive_objects.BoolObject`        |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x65       |Null_               |NoneType                       |:class:`~pyignite.datatypes.null_object.Null`                    |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|*Standard objects*                                                                                                                |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x09       |String_             |Str                            |:class:`~pyignite.datatypes.standard.String`                     |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x0a       |UUID_               |uuid.UUID                      |:class:`~pyignite.datatypes.standard.UUIDObject`                 |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x21       |Timestamp_          |tuple                          |:class:`~pyignite.datatypes.standard.TimestampObject`            |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x0b       |Date_               |datetime.datetime              |:class:`~pyignite.datatypes.standard.DateObject`                 |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x24       |Time_               |datetime.timedelta             |:class:`~pyignite.datatypes.standard.TimeObject`                 |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x1e       |Decimal_            |decimal.Decimal                |:class:`~pyignite.datatypes.standard.DecimalObject`              |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x1c       |Enum_               |tuple                          |:class:`~pyignite.datatypes.standard.EnumObject`                 |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x67       |`Binary enum`_      |tuple                          |:class:`~pyignite.datatypes.standard.BinaryEnumObject`           |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|*Arrays of primitives*                                                                                                            |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x0c       |`Byte array`_       |iterable/list                  |:class:`~pyignite.datatypes.primitive_arrays.ByteArrayObject`    |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x0d       |`Short array`_      |iterable/list                  |:class:`~pyignite.datatypes.primitive_arrays.ShortArrayObject`   |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x0e       |`Int array`_        |iterable/list                  |:class:`~pyignite.datatypes.primitive_arrays.IntArrayObject`     |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x0f       |`Long array`_       |iterable/list                  |:class:`~pyignite.datatypes.primitive_arrays.LongArrayObject`    |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x10       |`Float array`_      |iterable/list                  |:class:`~pyignite.datatypes.primitive_arrays.FloatArrayObject`   |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x11       |`Double array`_     |iterable/list                  |:class:`~pyignite.datatypes.primitive_arrays.DoubleArrayObject`  |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x12       |`Char array`_       |iterable/list                  |:class:`~pyignite.datatypes.primitive_arrays.CharArrayObject`    |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x13       |`Bool array`_       |iterable/list                  |:class:`~pyignite.datatypes.primitive_arrays.BoolArrayObject`    |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|*Arrays of standard objects*                                                                                                      |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x14       |`String array`_     |iterable/list                  |:class:`~pyignite.datatypes.standard.StringArrayObject`          |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x15       |`UUID array`_       |iterable/list                  |:class:`~pyignite.datatypes.standard.UUIDArrayObject`            |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x22       |`Timestamp array`_  |iterable/list                  |:class:`~pyignite.datatypes.standard.TimestampArrayObject`       |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x16       |`Date array`_       |iterable/list                  |:class:`~pyignite.datatypes.standard.DateArrayObject`            |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x23       |`Time array`_       |iterable/list                  |:class:`~pyignite.datatypes.standard.TimeArrayObject`            |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x1f       |`Decimal array`_    |iterable/list                  |:class:`~pyignite.datatypes.standard.DecimalArrayObject`         |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|*Object collections, special types, and complex object*                                                                           |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x17       |`Object array`_     |iterable/list                  |:class:`~pyignite.datatypes.complex.ObjectArrayObject`           |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x18       |`Collection`_       |tuple                          |:class:`~pyignite.datatypes.complex.CollectionObject`            |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x19       |`Map`_              |dict, collections.OrderedDict  |:class:`~pyignite.datatypes.complex.MapObject`                   |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x1d       |`Enum array`_       |iterable/list                  |:class:`~pyignite.datatypes.standard.EnumArrayObject`            |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x67       |`Complex object`_   |object                         |:class:`~pyignite.datatypes.complex.BinaryObject`                |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+|0x1b       |`Wrapped data`_     |tuple                          |:class:`~pyignite.datatypes.complex.WrappedDataObject`           |
++-----------+--------------------+-------------------------------+-----------------------------------------------------------------+
+
+.. _Byte: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-byte
+.. _Short: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-short
+.. _Int: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-int
+.. _Long: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-long
+.. _Float: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-float
+.. _Double: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-double
+.. _Char: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-char
+.. _Bool: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-bool
+.. _Null: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-null
+.. _String: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-string
+.. _UUID: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-uuid-guid-
+.. _Timestamp: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-timestamp
+.. _Date: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-date
+.. _Time: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-time
+.. _Decimal: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-decimal
+.. _Enum: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-enum
+.. _Byte array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-byte-array
+.. _Short array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-short-array
+.. _Int array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-int-array
+.. _Long array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-long-array
+.. _Float array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-float-array
+.. _Double array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-double-array
+.. _Char array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-char-array
+.. _Bool array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-bool-array
+.. _String array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-string-array
+.. _UUID array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-uuid-guid-array
+.. _Timestamp array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-timestamp-array
+.. _Date array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-date-array
+.. _Time array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-time-array
+.. _Decimal array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-decimal-array
+.. _Object array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-object-collections
+.. _Collection: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-collection
+.. _Map: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-map
+.. _Enum array: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-enum-array
+.. _Binary enum: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-binary-enum
+.. _Wrapped data: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-wrapped-data
+.. _Complex object: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-complex-object
diff --git a/docs/examples.rst b/docs/examples.rst
new file mode 100644
index 0000000..3d8d2d9
--- /dev/null
+++ b/docs/examples.rst
@@ -0,0 +1,624 @@
+..  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.
+
+.. _examples_of_usage:
+
+=================
+Examples of usage
+=================
+File: `get_and_put.py`_.
+
+Key-value
+---------
+
+Open connection
+===============
+
+.. literalinclude:: ../examples/get_and_put.py
+  :language: python
+  :lines: 16-19
+
+.. _create_cache:
+
+Create cache
+============
+
+.. literalinclude:: ../examples/get_and_put.py
+  :language: python
+  :lines: 21
+
+Put value in cache
+==================
+
+.. literalinclude:: ../examples/get_and_put.py
+  :language: python
+  :lines: 23
+
+Get value from cache
+====================
+
+.. literalinclude:: ../examples/get_and_put.py
+  :language: python
+  :lines: 25-29
+
+Get multiple values from cache
+==============================
+
+.. literalinclude:: ../examples/get_and_put.py
+  :language: python
+  :lines: 31-36
+
+Type hints usage
+================
+File: `type_hints.py`_
+
+.. literalinclude:: ../examples/type_hints.py
+  :language: python
+  :lines: 24-48
+
+As a rule of thumb:
+
+- when a `pyignite` method or function deals with a single value or key, it
+  has an additional parameter, like `value_hint` or `key_hint`, which accepts
+  a parser/constructor class,
+
+- nearly any structure element (inside dict or list) can be replaced with
+  a two-tuple of (said element, type hint).
+
+Refer the :ref:`data_types` section for the full list
+of parser/constructor classes you can use as type hints.
+
+Scan
+====
+File: `scans.py`_.
+
+Cache's :py:meth:`~pyignite.cache.Cache.scan` method queries allows you
+to get the whole contents of the cache, element by element.
+
+Let us put some data in cache.
+
+.. literalinclude:: ../examples/scans.py
+  :language: python
+  :lines: 23-33
+
+:py:meth:`~pyignite.cache.Cache.scan` returns a generator, that yields
+two-tuples of key and value. You can iterate through the generated pairs
+in a safe manner:
+
+.. literalinclude:: ../examples/scans.py
+  :language: python
+  :lines: 34-41
+
+Or, alternatively, you can convert the generator to dictionary in one go:
+
+.. literalinclude:: ../examples/scans.py
+  :language: python
+  :lines: 44-52
+
+But be cautious: if the cache contains a large set of data, the dictionary
+may eat too much memory!
+
+Do cleanup
+==========
+
+Destroy created cache and close connection.
+
+.. literalinclude:: ../examples/scans.py
+  :language: python
+  :lines: 54-55
+
+.. _sql_examples:
+
+SQL
+---
+File: `sql.py`_.
+
+These examples are similar to the ones given in the Apache Ignite SQL
+Documentation: `Getting Started`_.
+
+Setup
+=====
+
+First let us establish a connection.
+
+.. literalinclude:: ../examples/sql.py
+  :language: python
+  :lines: 195-196
+
+Then create tables. Begin with `Country` table, than proceed with related
+tables `City` and `CountryLanguage`.
+
+.. literalinclude:: ../examples/sql.py
+  :language: python
+  :lines: 25-42, 51-59, 67-74, 199-204
+
+Create indexes.
+
+.. literalinclude:: ../examples/sql.py
+  :language: python
+  :lines: 60-62, 75-77, 207-208
+
+Fill tables with data.
+
+.. literalinclude:: ../examples/sql.py
+  :language: python
+  :lines: 43-50, 63-66, 78-81, 211-218
+
+Data samples are taken from `Ignite GitHub repository`_.
+
+That concludes the preparation of data. Now let us answer some questions.
+
+What are the 10 largest cities in our data sample (population-wise)?
+====================================================================
+
+.. literalinclude:: ../examples/sql.py
+  :language: python
+  :lines: 24, 221-238
+
+The :py:meth:`~pyignite.client.Client.sql` method returns a generator,
+that yields the resulting rows.
+
+What are the 10 most populated cities throughout the 3 chosen countries?
+========================================================================
+
+If you set the `include_field_names` argument to `True`, the
+:py:meth:`~pyignite.client.Client.sql` method will generate a list of
+column names as a first yield. You can access field names with Python built-in
+`next` function.
+
+.. literalinclude:: ../examples/sql.py
+  :language: python
+  :lines: 241-269
+
+Display all the information about a given city
+==============================================
+
+.. literalinclude:: ../examples/sql.py
+  :language: python
+  :lines: 272-290
+
+Finally, delete the tables used in this example with the following queries:
+
+.. literalinclude:: ../examples/sql.py
+  :language: python
+  :lines: 82-83, 293-298
+
+.. _complex_object_usage:
+
+Complex objects
+---------------
+File: `binary_basics.py`_.
+
+`Complex object`_ (that is often called ‘Binary object’) is an Ignite data
+type, that is designed to represent a Java class. It have the following
+features:
+
+- have a unique ID (type id), which is derives from a class name (type name),
+- have one or more associated schemas, that describes its inner structure (the
+  order, names and types of its fields). Each schema have its own ID,
+- have an optional version number, that is aimed towards the end users
+  to help them distinguish between objects of the same type, serialized
+  with different schemas.
+
+Unfortunately, these distinctive features of the Complex object have few to no
+meaning outside of Java language. Python class can not be defined by its name
+(it is not unique), ID (object ID in Python is volatile; in CPython it is just
+a pointer in the interpreter's memory heap), or complex of its fields (they
+do not have an associated data types, moreover, they can be added or deleted
+in run-time). For the `pyignite` user it means that for all purposes
+of storing native Python data it is better to use Ignite
+:class:`~pyignite.datatypes.complex.CollectionObject`
+or :class:`~pyignite.datatypes.complex.MapObject` data types.
+
+However, for interoperability purposes, `pyignite` has a mechanism of creating
+special Python classes to read or write Complex objects. These classes have
+an interface, that simulates all the features of the Complex object: type name,
+type ID, schema, schema ID, and version number.
+
+Assuming that one concrete class for representing one Complex object can
+severely limit the user's data manipulation capabilities, all the
+functionality said above is implemented through the metaclass:
+:class:`~pyignite.binary.GenericObjectMeta`. This metaclass is used
+automatically when reading Complex objects.
+
+.. literalinclude:: ../examples/binary_basics.py
+  :language: python
+  :lines: 18-20, 30-34, 39-42, 48-49
+
+Here you can see how :class:`~pyignite.binary.GenericObjectMeta` uses
+`attrs`_ package internally for creating nice `__init__()` and `__repr__()`
+methods.
+
+You can reuse the autogenerated class for subsequent writes:
+
+.. literalinclude:: ../examples/binary_basics.py
+  :language: python
+  :lines: 53, 34-37
+
+:class:`~pyignite.binary.GenericObjectMeta` can also be used directly
+for creating custom classes:
+
+.. literalinclude:: ../examples/binary_basics.py
+  :language: python
+  :lines: 22-27
+
+Note how the `Person` class is defined. `schema` is a
+:class:`~pyignite.binary.GenericObjectMeta` metaclass parameter.
+Another important :class:`~pyignite.binary.GenericObjectMeta` parameter
+is a `type_name`, but it is optional and defaults to the class name (‘Person’
+in our example).
+
+Note also, that `Person` do not have to define its own attributes, methods and
+properties (`pass`), although it is completely possible.
+
+Now, when your custom `Person` class is created, you are ready to send data
+to Ignite server using its objects. The client will implicitly register your
+class as soon as the first Complex object is sent. If you intend to use your
+custom class for reading existing Complex objects' values before all, you must
+register said class explicitly with your client:
+
+.. literalinclude:: ../examples/binary_basics.py
+  :language: python
+  :lines: 51
+
+Now, when we dealt with the basics of `pyignite` implementation of Complex
+Objects, let us move on to more elaborate examples.
+
+.. _sql_cache_read:
+
+Read
+====
+File: `read_binary.py`_.
+
+Ignite SQL uses Complex objects internally to represent keys and rows
+in SQL tables. Normally SQL data is accessed via queries (see `SQL`_),
+so we will consider the following example solely for the demonstration
+of how Binary objects (not Ignite SQL) work.
+
+In the :ref:`previous examples <sql_examples>` we have created some SQL tables.
+Let us do it again and examine the Ignite storage afterwards.
+
+.. literalinclude:: ../examples/read_binary.py
+  :language: python
+  :lines: 222-229
+
+We can see that Ignite created a cache for each of our tables. The caches are
+conveniently named using ‘`SQL_<schema name>_<table name>`’ pattern.
+
+Now let us examine a configuration of a cache that contains SQL data
+using a :py:attr:`~pyignite.cache.Cache.settings` property.
+
+.. literalinclude:: ../examples/read_binary.py
+  :language: python
+  :lines: 231-251
+
+The values of `value_type_name` and `key_type_name` are names of the binary
+types. The `City` table's key fields are stored using `key_type_name` type,
+and the other fields − `value_type_name` type.
+
+Now when we have the cache, in which the SQL data resides, and the names
+of the key and value data types, we can read the data without using SQL
+functions and verify the correctness of the result.
+
+.. literalinclude:: ../examples/read_binary.py
+  :language: python
+  :lines: 253-267
+
+What we see is a tuple of key and value, extracted from the cache. Both key
+and value are represent Complex objects. The dataclass names are the same
+as the `value_type_name` and `key_type_name` cache settings. The objects'
+fields correspond to the SQL query.
+
+.. _sql_cache_create:
+
+Create
+======
+File: `create_binary.py`_.
+
+Now, that we aware of the internal structure of the Ignite SQL storage,
+we can create a table and put data in it using only key-value functions.
+
+For example, let us create a table to register High School students:
+a rough equivalent of the following SQL DDL statement:
+
+::
+
+    CREATE TABLE Student (
+        sid CHAR(9),
+        name VARCHAR(20),
+        login CHAR(8),
+        age INTEGER(11),
+        gpa REAL
+    )
+
+These are the necessary steps to perform the task.
+
+1. Create table cache.
+
+.. literalinclude:: ../examples/create_binary.py
+  :language: python
+  :lines: 22-63
+
+2. Define Complex object data class.
+
+.. literalinclude:: ../examples/create_binary.py
+  :language: python
+  :lines: 66-76
+
+3. Insert row.
+
+.. literalinclude:: ../examples/create_binary.py
+  :language: python
+  :lines: 79-83
+
+Now let us make sure that our cache really can be used with SQL functions.
+
+.. literalinclude:: ../examples/create_binary.py
+  :language: python
+  :lines: 85-93
+
+Note, however, that the cache we create can not be dropped with DDL command.
+
+.. literalinclude:: ../examples/create_binary.py
+  :language: python
+  :lines: 95-100
+
+It should be deleted as any other key-value cache.
+
+.. literalinclude:: ../examples/create_binary.py
+  :language: python
+  :lines: 102
+
+Migrate
+=======
+File: `migrate_binary.py`_.
+
+Suppose we have an accounting app that stores its data in key-value format.
+Our task would be to introduce the following changes to the original expense
+voucher's format and data:
+
+- rename `date` to `expense_date`,
+- add `report_date`,
+- set `report_date` to the current date if `reported` is True, None if False,
+- delete `reported`.
+
+First get the vouchers' cache.
+
+.. literalinclude:: ../examples/migrate_binary.py
+  :language: python
+  :lines: 108-111
+
+If you do not store the schema of the Complex object in code, you can obtain
+it as a dataclass property with
+:py:meth:`~pyignite.client.Client.query_binary_type` method.
+
+.. literalinclude:: ../examples/migrate_binary.py
+  :language: python
+  :lines: 116-123
+
+Let us modify the schema and create a new Complex object class with an updated
+schema.
+
+.. literalinclude:: ../examples/migrate_binary.py
+  :language: python
+  :lines: 125-138
+
+Now migrate the data from the old schema to the new one.
+
+.. literalinclude:: ../examples/migrate_binary.py
+  :language: python
+  :lines: 141-190
+
+At this moment all the fields, defined in both of our schemas, can be
+available in the resulting binary object, depending on which schema was used
+when writing it using :py:meth:`~pyignite.cache.Cache.put` or similar methods.
+Ignite Binary API do not have the method to delete Complex object schema;
+all the schemas ever defined will stay in cluster until its shutdown.
+
+This versioning mechanism is quite simple and robust, but it have its
+limitations. The main thing is: you can not change the type of the existing
+field. If you try, you will be greeted with the following message:
+
+```org.apache.ignite.binary.BinaryObjectException: Wrong value has been set
+[typeName=SomeType, fieldName=f1, fieldType=String, assignedValueType=int]```
+
+As an alternative, you can rename the field or create a new Complex object.
+
+Failover
+--------
+File: `failover.py`_.
+
+When connection to the server is broken or timed out,
+:class:`~pyignite.client.Client` object propagates an original exception
+(`OSError` or `SocketError`), but keeps its constructor's parameters intact
+and tries to reconnect transparently.
+
+When there's no way for :class:`~pyignite.client.Client` to reconnect, it
+raises a special :class:`~pyignite.exceptions.ReconnectError` exception.
+
+The following example features a simple node list traversal failover mechanism.
+Gather 3 Ignite nodes on `localhost` into one cluster and run:
+
+.. literalinclude:: ../examples/failover.py
+  :language: python
+  :lines: 16-49
+
+Then try shutting down and restarting nodes, and see what happens.
+
+.. literalinclude:: ../examples/failover.py
+  :language: python
+  :lines: 51-61
+
+Client reconnection do not require an explicit user action, like calling
+a special method or resetting a parameter. Note, however, that reconnection
+is lazy: it happens only if (and when) it is needed. In this example,
+the automatic reconnection happens, when the script checks upon the last
+saved value:
+
+.. literalinclude:: ../examples/failover.py
+  :language: python
+  :lines: 48
+
+It means that instead of checking the connection status it is better for
+`pyignite` user to just try the supposed data operations and catch
+the resulting exception.
+
+:py:meth:`~pyignite.connection.Connection.connect` method accepts any
+iterable, not just list. It means that you can implement any reconnection
+policy (round-robin, nodes prioritization, pause on reconnect or graceful
+backoff) with a generator.
+
+`pyignite` comes with a sample
+:class:`~pyignite.connection.generators.RoundRobin` generator. In the above
+example try to replace
+
+.. literalinclude:: ../examples/failover.py
+  :language: python
+  :lines: 29
+
+with
+
+.. code-block:: python3
+
+    client.connect(RoundRobin(nodes, max_reconnects=20))
+
+The client will try to reconnect to node 1 after node 3 is crashed, then to
+node 2, et c. At least one node should be active for the
+:class:`~pyignite.connection.generators.RoundRobin` to work properly.
+
+SSL/TLS
+-------
+
+There are some special requirements for testing SSL connectivity.
+
+The Ignite server must be configured for securing the binary protocol port.
+The server configuration process can be split up into these basic steps:
+
+1. Create a key store and a trust store using `Java keytool`_. When creating
+   the trust store, you will probably need a client X.509 certificate. You
+   will also need to export the server X.509 certificate to include in the
+   client chain of trust.
+
+2. Turn on the `SslContextFactory` for your Ignite cluster according to this
+   document: `Securing Connection Between Nodes`_.
+
+3. Tell Ignite to encrypt data on its thin client port, using the settings for
+   `ClientConnectorConfiguration`_. If you only want to encrypt connection,
+   not to validate client's certificate, set `sslClientAuth` property to
+   `false`. You'll still have to set up the trust store on step 1 though.
+
+Client SSL settings is summarized here:
+:class:`~pyignite.client.Client`.
+
+To use the SSL encryption without certificate validation just `use_ssl`.
+
+.. code-block:: python3
+
+    from pyignite import Client
+
+    client = Client(use_ssl=True)
+    client.connect('127.0.0.1', 10800)
+
+To identify the client, create an SSL keypair and a certificate with
+`openssl`_ command and use them in this manner:
+
+.. code-block:: python3
+
+    from pyignite import Client
+
+    client = Client(
+        use_ssl=True,
+        ssl_keyfile='etc/.ssl/keyfile.key',
+        ssl_certfile='etc/.ssl/certfile.crt',
+    )
+    client.connect('ignite-example.com', 10800)
+
+To check the authenticity of the server, get the server certificate or
+certificate chain and provide its path in the `ssl_ca_certfile` parameter.
+
+.. code-block:: python3
+
+    import ssl
+
+    from pyignite import Client
+
+    client = Client(
+        use_ssl=True,
+        ssl_ca_certfile='etc/.ssl/ca_certs',
+        ssl_cert_reqs=ssl.CERT_REQUIRED,
+    )
+    client.connect('ignite-example.com', 10800)
+
+You can also provide such parameters as the set of ciphers (`ssl_ciphers`) and
+the SSL version (`ssl_version`), if the defaults
+(:py:obj:`ssl._DEFAULT_CIPHERS` and TLS 1.1) do not suit you.
+
+Password authentication
+-----------------------
+
+To authenticate you must set `authenticationEnabled` property to `true` and
+enable persistance in Ignite XML configuration file, as described in
+`Authentication`_ section of Ignite documentation.
+
+Be advised that sending credentials over the open channel is greatly
+discouraged, since they can be easily intercepted. Supplying credentials
+automatically turns SSL on from the client side. It is highly recommended
+to secure the connection to the Ignite server, as described
+in `SSL/TLS`_ example, in order to use password authentication.
+
+Then just supply `username` and `password` parameters to
+:class:`~pyignite.client.Client` constructor.
+
+.. code-block:: python3
+
+    from pyignite import Client
+
+    client = Client(username='ignite', password='ignite')
+    client.connect('ignite-example.com', 10800)
+
+If you still do not wish to secure the connection is spite of the warning,
+then disable SSL explicitly on creating the client object:
+
+.. code-block:: python3
+
+    client = Client(username='ignite', password='ignite', use_ssl=False)
+
+Note, that it is not possible for Ignite thin client to obtain the cluster's
+authentication settings through the binary protocol. Unexpected credentials
+are simply ignored by the server. In the opposite case, the user is greeted
+with the following message:
+
+.. code-block:: python3
+
+    # pyignite.exceptions.HandshakeError: Handshake error: Unauthenticated sessions are prohibited.
+
+.. _get_and_put.py: https://github.com/apache/ignite/tree/master/modules/platforms/python/examples/get_and_put.py
+.. _type_hints.py: https://github.com/apache/ignite/tree/master/modules/platforms/python/examples/type_hints.py
+.. _failover.py: https://github.com/apache/ignite/tree/master/modules/platforms/python/examples/failover.py
+.. _scans.py: https://github.com/apache/ignite/tree/master/modules/platforms/python/examples/scans.py
+.. _sql.py: https://github.com/apache/ignite/tree/master/modules/platforms/python/examples/sql.py
+.. _binary_basics.py: https://github.com/apache/ignite/tree/master/modules/platforms/python/examples/binary_basics.py
+.. _read_binary.py: https://github.com/apache/ignite/tree/master/modules/platforms/python/examples/read_binary.py
+.. _create_binary.py: https://github.com/apache/ignite/tree/master/modules/platforms/python/examples/create_binary.py
+.. _migrate_binary.py: https://github.com/apache/ignite/tree/master/modules/platforms/python/examples/migrate_binary.py
+.. _Getting Started: https://apacheignite-sql.readme.io/docs/getting-started
+.. _Ignite GitHub repository: https://github.com/apache/ignite/blob/master/examples/sql/world.sql
+.. _Complex object: https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-complex-object
+.. _Java keytool: https://docs.oracle.com/javase/8/docs/technotes/tools/unix/keytool.html
+.. _Securing Connection Between Nodes: https://apacheignite.readme.io/docs/ssltls#section-securing-connection-between-nodes
+.. _ClientConnectorConfiguration: https://ignite.apache.org/releases/latest/javadoc/org/apache/ignite/configuration/ClientConnectorConfiguration.html
+.. _openssl: https://www.openssl.org/docs/manmaster/man1/openssl.html
+.. _Authentication: https://apacheignite.readme.io/docs/advanced-security#section-authentication
+.. _attrs: https://pypi.org/project/attrs/
diff --git a/docs/index.rst b/docs/index.rst
new file mode 100644
index 0000000..35bd18c
--- /dev/null
+++ b/docs/index.rst
@@ -0,0 +1,33 @@
+..  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.
+
+Welcome to Apache Ignite binary client Python API documentation!
+================================================================
+
+.. toctree::
+   :maxdepth: 2
+   :caption: Contents:
+
+   readme
+   modules
+   examples
+
+
+Indices and tables
+==================
+
+* :ref:`genindex`
+* :ref:`modindex`
+* :ref:`search`
diff --git a/docs/modules.rst b/docs/modules.rst
new file mode 100644
index 0000000..cabc915
--- /dev/null
+++ b/docs/modules.rst
@@ -0,0 +1,31 @@
+..  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.
+
+=================
+API Specification
+=================
+
+The modules and subpackages listed here are the basis of a stable API
+of `pyignite`, intended for end users.
+
+.. toctree::
+   :maxdepth: 1
+   :caption: Modules:
+
+   Client <source/pyignite.client>
+   Cache <source/pyignite.cache>
+   datatypes/parsers
+   datatypes/cache_props
+   Exceptions <source/pyignite.exceptions>
diff --git a/docs/readme.rst b/docs/readme.rst
new file mode 100644
index 0000000..f91274e
--- /dev/null
+++ b/docs/readme.rst
@@ -0,0 +1,202 @@
+..  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.
+
+=================
+Basic Information
+=================
+
+What it is
+----------
+
+This is an Apache Ignite thin (binary protocol) client library,
+written in Python 3, abbreviated as *pyignite*.
+
+`Apache Ignite`_ is a memory-centric distributed database, caching,
+and processing platform for transactional, analytical, and streaming
+workloads delivering in-memory speeds at petabyte scale.
+
+Ignite `binary client protocol`_ provides user applications the ability
+to communicate with an existing Ignite cluster without starting
+a full-fledged Ignite node. An application can connect to the cluster
+through a raw TCP socket.
+
+Prerequisites
+-------------
+
+- *Python 3.4* or above (3.6 is tested),
+- Access to *Apache Ignite* node, local or remote. The current thin client
+  version was tested on *Apache Ignite 2.7.0* (binary client protocol 1.2.0).
+
+Installation
+------------
+
+for end user
+""""""""""""
+
+If you want to use *pyignite* in your project, you may install it from PyPI:
+
+::
+
+$ pip install pyignite
+
+for developer
+"""""""""""""
+
+If you want to run tests, examples or build documentation, clone
+the whole repository:
+
+::
+
+$ git clone git@github.com:apache/ignite.git
+$ cd ignite/modules/platforms/python
+$ pip install -e .
+
+This will install the repository version of `pyignite` into your environment
+in so-called “develop” or “editable” mode. You may read more about
+`editable installs`_ in the `pip` manual.
+
+Then run through the contents of `requirements` folder to install
+the the additional requirements into your working Python environment using
+
+::
+
+$ pip install -r requirements/<your task>.txt
+
+You may also want to consult the `setuptools`_ manual about using `setup.py`.
+
+Examples
+--------
+
+Some examples of using pyignite are provided in
+`ignite/modules/platforms/python/examples` folder. They are extensively
+commented in the :ref:`examples_of_usage` section of the documentation.
+
+This code implies that it is run in the environment with `pyignite` package
+installed, and Apache Ignite node is running on localhost:10800, unless
+otherwise noted.
+
+There is also a possibility to run examples alone with tests. For
+the explanation of testing, look up the `Testing`_ section.
+
+Testing
+-------
+
+Create and activate virtualenv_ environment. Run
+
+::
+
+$ cd ignite/modules/platforms/python
+$ python ./setup.py pytest
+
+This does not require `pytest` and other test dependencies to be installed
+in your environment.
+
+Some or all tests require Apache Ignite node running on localhost:10800.
+To override the default parameters, use command line options
+``--ignite-host`` and ``--ignite-port``:
+
+::
+
+$ python ./setup.py pytest --addopts "--ignite-host=example.com --ignite-port=19840"
+
+You can use each of these two options multiple times. All combinations
+of given host and port will be tested.
+
+You can also test client against a server with SSL-encrypted connection.
+SSL-related `pytest` parameters are:
+
+``--use-ssl`` − use SSL encryption,
+
+``--ssl-certfile`` − a path to ssl certificate file to identify local party,
+
+``--ssl-ca-certfile`` − a path to a trusted certificate or a certificate chain,
+
+``--ssl-cert-reqs`` − determines how the remote side certificate is treated:
+
+- ``NONE`` (ignore, default),
+- ``OPTIONAL`` (validate, if provided),
+- ``REQUIRED`` (valid remote certificate is required),
+
+``--ssl-ciphers`` − ciphers to use,
+
+``--ssl-version`` − SSL version:
+
+- ``TLSV1_1`` (default),
+- ``TLSV1_2``.
+
+Other `pytest` parameters:
+
+``--timeout`` − timeout (in seconds) for each socket operation, including
+`connect`. Accepts integer or float value. Default is None (blocking mode),
+
+``--username`` and ``--password`` − credentials to authenticate to Ignite
+cluster. Used in conjunction with `authenticationEnabled` property in cluster
+configuration.
+
+``--examples`` − run the examples as one test. If you wish to run *only*
+the examples, supply also the name of the test function to `pytest` launcher:
+
+::
+
+$ pytest --examples ../tests/test_examples.py::test_examples
+
+In this test assertion fails if any of the examples' processes ends with
+non-zero exit code.
+
+Examples are not parameterized for the sake of simplicity. They always run
+with default parameters (host and port) regardless of any other
+`pytest` option.
+
+Since failover, SSL and authentication examples are meant to be controlled
+by user or depend on special configuration of the Ignite cluster, they
+can not be automated.
+
+Documentation
+-------------
+To recompile this documentation, do this from your virtualenv_ environment:
+
+::
+
+$ cd ignite/modules/platforms/python
+$ pip install -r requirements/docs.txt
+$ cd docs
+$ make html
+
+Then open `ignite/modules/platforms/python/docs/generated/html/index.html`_
+in your browser.
+
+If you feel that old version is stuck, do
+
+::
+
+$ cd ignite/modules/platforms/python/docs
+$ make clean
+$ sphinx-apidoc -feM -o source/ ../ ../setup.py
+$ make html
+
+And that should be it.
+
+Licensing
+---------
+
+This is a free software, brought to you on terms of the `Apache License v2`_.
+
+.. _Apache Ignite: https://apacheignite.readme.io/docs/what-is-ignite
+.. _binary client protocol: https://apacheignite.readme.io/docs/binary-client-protocol
+.. _Apache License v2: http://www.apache.org/licenses/LICENSE-2.0
+.. _virtualenv: https://virtualenv.pypa.io/
+.. _setuptools: https://setuptools.readthedocs.io/
+.. _ignite/modules/platforms/python/docs/generated/html/index.html: .
+.. _editable installs: https://pip.pypa.io/en/stable/reference/pip_install/#editable-installs
diff --git a/docs/source/modules.rst b/docs/source/modules.rst
new file mode 100644
index 0000000..c125dd3
--- /dev/null
+++ b/docs/source/modules.rst
@@ -0,0 +1,7 @@
+python
+======
+
+.. toctree::
+   :maxdepth: 4
+
+   pyignite
diff --git a/docs/source/pyignite.api.binary.rst b/docs/source/pyignite.api.binary.rst
new file mode 100644
index 0000000..49f1c86
--- /dev/null
+++ b/docs/source/pyignite.api.binary.rst
@@ -0,0 +1,7 @@
+pyignite.api.binary module
+==========================
+
+.. automodule:: pyignite.api.binary
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.api.cache_config.rst b/docs/source/pyignite.api.cache_config.rst
new file mode 100644
index 0000000..599c857
--- /dev/null
+++ b/docs/source/pyignite.api.cache_config.rst
@@ -0,0 +1,7 @@
+pyignite.api.cache\_config module
+=================================
+
+.. automodule:: pyignite.api.cache_config
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.api.key_value.rst b/docs/source/pyignite.api.key_value.rst
new file mode 100644
index 0000000..52d6c3f
--- /dev/null
+++ b/docs/source/pyignite.api.key_value.rst
@@ -0,0 +1,7 @@
+pyignite.api.key\_value module
+==============================
+
+.. automodule:: pyignite.api.key_value
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.api.result.rst b/docs/source/pyignite.api.result.rst
new file mode 100644
index 0000000..21398e3
--- /dev/null
+++ b/docs/source/pyignite.api.result.rst
@@ -0,0 +1,7 @@
+pyignite.api.result module
+==========================
+
+.. automodule:: pyignite.api.result
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.api.rst b/docs/source/pyignite.api.rst
new file mode 100644
index 0000000..e18d4a3
--- /dev/null
+++ b/docs/source/pyignite.api.rst
@@ -0,0 +1,19 @@
+pyignite.api package
+====================
+
+.. automodule:: pyignite.api
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+Submodules
+----------
+
+.. toctree::
+
+   pyignite.api.binary
+   pyignite.api.cache_config
+   pyignite.api.key_value
+   pyignite.api.result
+   pyignite.api.sql
+
diff --git a/docs/source/pyignite.api.sql.rst b/docs/source/pyignite.api.sql.rst
new file mode 100644
index 0000000..84479ad
--- /dev/null
+++ b/docs/source/pyignite.api.sql.rst
@@ -0,0 +1,7 @@
+pyignite.api.sql module
+=======================
+
+.. automodule:: pyignite.api.sql
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.binary.rst b/docs/source/pyignite.binary.rst
new file mode 100644
index 0000000..6b21582
--- /dev/null
+++ b/docs/source/pyignite.binary.rst
@@ -0,0 +1,7 @@
+pyignite.binary module
+======================
+
+.. automodule:: pyignite.binary
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.cache.rst b/docs/source/pyignite.cache.rst
new file mode 100644
index 0000000..e6e83c5
--- /dev/null
+++ b/docs/source/pyignite.cache.rst
@@ -0,0 +1,7 @@
+pyignite.cache module
+=====================
+
+.. automodule:: pyignite.cache
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.client.rst b/docs/source/pyignite.client.rst
new file mode 100644
index 0000000..fef316b
--- /dev/null
+++ b/docs/source/pyignite.client.rst
@@ -0,0 +1,7 @@
+pyignite.client module
+======================
+
+.. automodule:: pyignite.client
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.connection.generators.rst b/docs/source/pyignite.connection.generators.rst
new file mode 100644
index 0000000..daecda3
--- /dev/null
+++ b/docs/source/pyignite.connection.generators.rst
@@ -0,0 +1,7 @@
+pyignite.connection.generators module
+=====================================
+
+.. automodule:: pyignite.connection.generators
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.connection.handshake.rst b/docs/source/pyignite.connection.handshake.rst
new file mode 100644
index 0000000..28e83df
--- /dev/null
+++ b/docs/source/pyignite.connection.handshake.rst
@@ -0,0 +1,7 @@
+pyignite.connection.handshake module
+====================================
+
+.. automodule:: pyignite.connection.handshake
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.connection.rst b/docs/source/pyignite.connection.rst
new file mode 100644
index 0000000..92b07a7
--- /dev/null
+++ b/docs/source/pyignite.connection.rst
@@ -0,0 +1,17 @@
+pyignite.connection package
+===========================
+
+.. automodule:: pyignite.connection
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+Submodules
+----------
+
+.. toctree::
+
+   pyignite.connection.generators
+   pyignite.connection.handshake
+   pyignite.connection.ssl
+
diff --git a/docs/source/pyignite.connection.ssl.rst b/docs/source/pyignite.connection.ssl.rst
new file mode 100644
index 0000000..8eebf43
--- /dev/null
+++ b/docs/source/pyignite.connection.ssl.rst
@@ -0,0 +1,7 @@
+pyignite.connection.ssl module
+==============================
+
+.. automodule:: pyignite.connection.ssl
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.constants.rst b/docs/source/pyignite.constants.rst
new file mode 100644
index 0000000..f71e4f1
--- /dev/null
+++ b/docs/source/pyignite.constants.rst
@@ -0,0 +1,7 @@
+pyignite.constants module
+=========================
+
+.. automodule:: pyignite.constants
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.datatypes.binary.rst b/docs/source/pyignite.datatypes.binary.rst
new file mode 100644
index 0000000..0d175de
--- /dev/null
+++ b/docs/source/pyignite.datatypes.binary.rst
@@ -0,0 +1,7 @@
+pyignite.datatypes.binary module
+================================
+
+.. automodule:: pyignite.datatypes.binary
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.datatypes.cache_config.rst b/docs/source/pyignite.datatypes.cache_config.rst
new file mode 100644
index 0000000..3d5eaeb
--- /dev/null
+++ b/docs/source/pyignite.datatypes.cache_config.rst
@@ -0,0 +1,7 @@
+pyignite.datatypes.cache\_config module
+=======================================
+
+.. automodule:: pyignite.datatypes.cache_config
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.datatypes.cache_properties.rst b/docs/source/pyignite.datatypes.cache_properties.rst
new file mode 100644
index 0000000..57f0e9f
--- /dev/null
+++ b/docs/source/pyignite.datatypes.cache_properties.rst
@@ -0,0 +1,7 @@
+pyignite.datatypes.cache\_properties module
+===========================================
+
+.. automodule:: pyignite.datatypes.cache_properties
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.datatypes.complex.rst b/docs/source/pyignite.datatypes.complex.rst
new file mode 100644
index 0000000..1e3f21e
--- /dev/null
+++ b/docs/source/pyignite.datatypes.complex.rst
@@ -0,0 +1,7 @@
+pyignite.datatypes.complex module
+=================================
+
+.. automodule:: pyignite.datatypes.complex
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.datatypes.internal.rst b/docs/source/pyignite.datatypes.internal.rst
new file mode 100644
index 0000000..5dc5535
--- /dev/null
+++ b/docs/source/pyignite.datatypes.internal.rst
@@ -0,0 +1,7 @@
+pyignite.datatypes.internal module
+==================================
+
+.. automodule:: pyignite.datatypes.internal
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.datatypes.key_value.rst b/docs/source/pyignite.datatypes.key_value.rst
new file mode 100644
index 0000000..0b3aa88
--- /dev/null
+++ b/docs/source/pyignite.datatypes.key_value.rst
@@ -0,0 +1,7 @@
+pyignite.datatypes.key\_value module
+====================================
+
+.. automodule:: pyignite.datatypes.key_value
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.datatypes.null_object.rst b/docs/source/pyignite.datatypes.null_object.rst
new file mode 100644
index 0000000..05f22b1
--- /dev/null
+++ b/docs/source/pyignite.datatypes.null_object.rst
@@ -0,0 +1,7 @@
+pyignite.datatypes.null\_object module
+======================================
+
+.. automodule:: pyignite.datatypes.null_object
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.datatypes.primitive.rst b/docs/source/pyignite.datatypes.primitive.rst
new file mode 100644
index 0000000..8a53604
--- /dev/null
+++ b/docs/source/pyignite.datatypes.primitive.rst
@@ -0,0 +1,7 @@
+pyignite.datatypes.primitive module
+===================================
+
+.. automodule:: pyignite.datatypes.primitive
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.datatypes.primitive_arrays.rst b/docs/source/pyignite.datatypes.primitive_arrays.rst
new file mode 100644
index 0000000..b4b94bf
--- /dev/null
+++ b/docs/source/pyignite.datatypes.primitive_arrays.rst
@@ -0,0 +1,7 @@
+pyignite.datatypes.primitive\_arrays module
+===========================================
+
+.. automodule:: pyignite.datatypes.primitive_arrays
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.datatypes.primitive_objects.rst b/docs/source/pyignite.datatypes.primitive_objects.rst
new file mode 100644
index 0000000..a74db38
--- /dev/null
+++ b/docs/source/pyignite.datatypes.primitive_objects.rst
@@ -0,0 +1,7 @@
+pyignite.datatypes.primitive\_objects module
+============================================
+
+.. automodule:: pyignite.datatypes.primitive_objects
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.datatypes.prop_codes.rst b/docs/source/pyignite.datatypes.prop_codes.rst
new file mode 100644
index 0000000..d23596b
--- /dev/null
+++ b/docs/source/pyignite.datatypes.prop_codes.rst
@@ -0,0 +1,7 @@
+pyignite.datatypes.prop\_codes module
+=====================================
+
+.. automodule:: pyignite.datatypes.prop_codes
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.datatypes.rst b/docs/source/pyignite.datatypes.rst
new file mode 100644
index 0000000..77e7183
--- /dev/null
+++ b/docs/source/pyignite.datatypes.rst
@@ -0,0 +1,28 @@
+pyignite.datatypes package
+==========================
+
+.. automodule:: pyignite.datatypes
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+Submodules
+----------
+
+.. toctree::
+
+   pyignite.datatypes.binary
+   pyignite.datatypes.cache_config
+   pyignite.datatypes.cache_properties
+   pyignite.datatypes.complex
+   pyignite.datatypes.internal
+   pyignite.datatypes.key_value
+   pyignite.datatypes.null_object
+   pyignite.datatypes.primitive
+   pyignite.datatypes.primitive_arrays
+   pyignite.datatypes.primitive_objects
+   pyignite.datatypes.prop_codes
+   pyignite.datatypes.sql
+   pyignite.datatypes.standard
+   pyignite.datatypes.type_codes
+
diff --git a/docs/source/pyignite.datatypes.sql.rst b/docs/source/pyignite.datatypes.sql.rst
new file mode 100644
index 0000000..e20f084
--- /dev/null
+++ b/docs/source/pyignite.datatypes.sql.rst
@@ -0,0 +1,7 @@
+pyignite.datatypes.sql module
+=============================
+
+.. automodule:: pyignite.datatypes.sql
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.datatypes.standard.rst b/docs/source/pyignite.datatypes.standard.rst
new file mode 100644
index 0000000..e46d339
--- /dev/null
+++ b/docs/source/pyignite.datatypes.standard.rst
@@ -0,0 +1,7 @@
+pyignite.datatypes.standard module
+==================================
+
+.. automodule:: pyignite.datatypes.standard
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.datatypes.type_codes.rst b/docs/source/pyignite.datatypes.type_codes.rst
new file mode 100644
index 0000000..47baa4b
--- /dev/null
+++ b/docs/source/pyignite.datatypes.type_codes.rst
@@ -0,0 +1,7 @@
+pyignite.datatypes.type\_codes module
+=====================================
+
+.. automodule:: pyignite.datatypes.type_codes
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.exceptions.rst b/docs/source/pyignite.exceptions.rst
new file mode 100644
index 0000000..dd24687
--- /dev/null
+++ b/docs/source/pyignite.exceptions.rst
@@ -0,0 +1,7 @@
+pyignite.exceptions module
+==========================
+
+.. automodule:: pyignite.exceptions
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.queries.op_codes.rst b/docs/source/pyignite.queries.op_codes.rst
new file mode 100644
index 0000000..bc556ec
--- /dev/null
+++ b/docs/source/pyignite.queries.op_codes.rst
@@ -0,0 +1,7 @@
+pyignite.queries.op\_codes module
+=================================
+
+.. automodule:: pyignite.queries.op_codes
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/docs/source/pyignite.queries.rst b/docs/source/pyignite.queries.rst
new file mode 100644
index 0000000..6dd81a2
--- /dev/null
+++ b/docs/source/pyignite.queries.rst
@@ -0,0 +1,15 @@
+pyignite.queries package
+========================
+
+.. automodule:: pyignite.queries
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+Submodules
+----------
+
+.. toctree::
+
+   pyignite.queries.op_codes
+
diff --git a/docs/source/pyignite.rst b/docs/source/pyignite.rst
new file mode 100644
index 0000000..947cab2
--- /dev/null
+++ b/docs/source/pyignite.rst
@@ -0,0 +1,30 @@
+pyignite package
+================
+
+.. automodule:: pyignite
+    :members:
+    :undoc-members:
+    :show-inheritance:
+
+Subpackages
+-----------
+
+.. toctree::
+
+    pyignite.api
+    pyignite.connection
+    pyignite.datatypes
+    pyignite.queries
+
+Submodules
+----------
+
+.. toctree::
+
+   pyignite.binary
+   pyignite.cache
+   pyignite.client
+   pyignite.constants
+   pyignite.exceptions
+   pyignite.utils
+
diff --git a/docs/source/pyignite.utils.rst b/docs/source/pyignite.utils.rst
new file mode 100644
index 0000000..5ee42ab
--- /dev/null
+++ b/docs/source/pyignite.utils.rst
@@ -0,0 +1,7 @@
+pyignite.utils module
+=====================
+
+.. automodule:: pyignite.utils
+    :members:
+    :undoc-members:
+    :show-inheritance:
diff --git a/examples/binary_basics.py b/examples/binary_basics.py
new file mode 100644
index 0000000..96a9058
--- /dev/null
+++ b/examples/binary_basics.py
@@ -0,0 +1,53 @@
+# 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 collections import OrderedDict
+
+from pyignite import Client, GenericObjectMeta
+from pyignite.datatypes import *
+
+
+class Person(metaclass=GenericObjectMeta, schema=OrderedDict([
+    ('first_name', String),
+    ('last_name', String),
+    ('age', IntObject),
+])):
+    pass
+
+
+client = Client()
+client.connect('localhost', 10800)
+
+person_cache = client.get_or_create_cache('person')
+
+person_cache.put(
+    1, Person(first_name='Ivan', last_name='Ivanov', age=33)
+)
+
+person = person_cache.get(1)
+print(person.__class__.__name__)
+# Person
+
+print(person.__class__ is Person)
+# True if `Person` was registered automatically (on writing)
+# or manually (using `client.register_binary_type()` method).
+# False otherwise
+
+print(person)
+# Person(first_name='Ivan', last_name='Ivanov', age=33, version=1)
+
+client.register_binary_type(Person)
+
+Person = person.__class__
diff --git a/examples/create_binary.py b/examples/create_binary.py
new file mode 100644
index 0000000..c963796
--- /dev/null
+++ b/examples/create_binary.py
@@ -0,0 +1,103 @@
+# 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 collections import OrderedDict
+
+from pyignite import Client, GenericObjectMeta
+from pyignite.datatypes import DoubleObject, IntObject, String
+from pyignite.datatypes.prop_codes import *
+
+client = Client()
+client.connect('127.0.0.1', 10800)
+
+student_cache = client.create_cache({
+        PROP_NAME: 'SQL_PUBLIC_STUDENT',
+        PROP_SQL_SCHEMA: 'PUBLIC',
+        PROP_QUERY_ENTITIES: [
+            {
+                'table_name': 'Student'.upper(),
+                'key_field_name': 'SID',
+                'key_type_name': 'java.lang.Integer',
+                'field_name_aliases': [],
+                'query_fields': [
+                    {
+                        'name': 'SID',
+                        'type_name': 'java.lang.Integer',
+                        'is_key_field': True,
+                        'is_notnull_constraint_field': True,
+                    },
+                    {
+                        'name': 'NAME',
+                        'type_name': 'java.lang.String',
+                    },
+                    {
+                        'name': 'LOGIN',
+                        'type_name': 'java.lang.String',
+                    },
+                    {
+                        'name': 'AGE',
+                        'type_name': 'java.lang.Integer',
+                    },
+                    {
+                        'name': 'GPA',
+                        'type_name': 'java.math.Double',
+                    },
+                ],
+                'query_indexes': [],
+                'value_type_name': 'SQL_PUBLIC_STUDENT_TYPE',
+                'value_field_name': None,
+            },
+        ],
+    })
+
+
+class Student(
+    metaclass=GenericObjectMeta,
+    type_name='SQL_PUBLIC_STUDENT_TYPE',
+    schema=OrderedDict([
+        ('NAME', String),
+        ('LOGIN', String),
+        ('AGE', IntObject),
+        ('GPA', DoubleObject),
+    ])
+):
+    pass
+
+
+student_cache.put(
+    1,
+    Student(LOGIN='jdoe', NAME='John Doe', AGE=17, GPA=4.25),
+    key_hint=IntObject
+)
+
+result = client.sql(
+    r'SELECT * FROM Student',
+    include_field_names=True
+)
+print(next(result))
+# ['SID', 'NAME', 'LOGIN', 'AGE', 'GPA']
+
+print(*result)
+# [1, 'John Doe', 'jdoe', 17, 4.25]
+
+# DROP_QUERY = 'DROP TABLE Student'
+# client.sql(DROP_QUERY)
+#
+# pyignite.exceptions.SQLError: class org.apache.ignite.IgniteCheckedException:
+# Only cache created with CREATE TABLE may be removed with DROP TABLE
+# [cacheName=SQL_PUBLIC_STUDENT]
+
+student_cache.destroy()
+client.close()
diff --git a/examples/failover.py b/examples/failover.py
new file mode 100644
index 0000000..3a5fcce
--- /dev/null
+++ b/examples/failover.py
@@ -0,0 +1,61 @@
+# 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 pyignite import Client
+from pyignite.datatypes.cache_config import CacheMode
+from pyignite.datatypes.prop_codes import *
+from pyignite.exceptions import SocketError
+
+
+nodes = [
+    ('127.0.0.1', 10800),
+    ('127.0.0.1', 10801),
+    ('127.0.0.1', 10802),
+]
+
+client = Client(timeout=4.0)
+client.connect(nodes)
+print('Connected to {}'.format(client))
+
+my_cache = client.get_or_create_cache({
+    PROP_NAME: 'my_cache',
+    PROP_CACHE_MODE: CacheMode.REPLICATED,
+})
+my_cache.put('test_key', 0)
+
+# abstract main loop
+while True:
+    try:
+        # do the work
+        test_value = my_cache.get('test_key')
+        my_cache.put('test_key', test_value + 1)
+    except (OSError, SocketError) as e:
+        # recover from error (repeat last command, check data
+        # consistency or just continue − depends on the task)
+        print('Error: {}'.format(e))
+        print('Last value: {}'.format(my_cache.get('test_key')))
+        print('Reconnected to {}'.format(client))
+
+# Connected to 127.0.0.1:10800
+# Error: [Errno 104] Connection reset by peer
+# Last value: 6999
+# Reconnected to 127.0.0.1:10801
+# Error: Socket connection broken.
+# Last value: 12302
+# Reconnected to 127.0.0.1:10802
+# Error: [Errno 111] Client refused
+# Traceback (most recent call last):
+#     ...
+# pyignite.exceptions.ReconnectError: Can not reconnect: out of nodes
diff --git a/examples/get_and_put.py b/examples/get_and_put.py
new file mode 100644
index 0000000..49c5108
--- /dev/null
+++ b/examples/get_and_put.py
@@ -0,0 +1,41 @@
+# 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 pyignite import Client
+
+client = Client()
+client.connect('127.0.0.1', 10800)
+
+my_cache = client.create_cache('my cache')
+
+my_cache.put('my key', 42)
+
+result = my_cache.get('my key')
+print(result)  # 42
+
+result = my_cache.get('non-existent key')
+print(result)  # None
+
+result = my_cache.get_all([
+    'my key',
+    'non-existent key',
+    'other-key',
+])
+print(result)  # {'my key': 42}
+
+my_cache.clear_key('my key')
+
+my_cache.destroy()
+client.close()
diff --git a/examples/migrate_binary.py b/examples/migrate_binary.py
new file mode 100644
index 0000000..f0b0f74
--- /dev/null
+++ b/examples/migrate_binary.py
@@ -0,0 +1,190 @@
+# 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 collections import OrderedDict
+from datetime import date
+from decimal import Decimal
+
+from pyignite import Client, GenericObjectMeta
+from pyignite.datatypes import (
+    BoolObject, DateObject, DecimalObject, LongObject, String,
+)
+
+
+# prepare old data
+old_schema = OrderedDict([
+    ('date', DateObject),
+    ('reported', BoolObject),
+    ('purpose', String),
+    ('sum', DecimalObject),
+    ('recipient', String),
+    ('cashier_id', LongObject),
+])
+
+old_data = [
+    (1, {
+        'date': date(2017, 9, 21),
+        'reported': True,
+        'purpose': 'Praesent eget fermentum massa',
+        'sum': Decimal('666.67'),
+        'recipient': 'John Doe',
+        'cashier_id': 8,
+    }),
+    (2, {
+        'date': date(2017, 10, 11),
+        'reported': True,
+        'purpose': 'Proin in bibendum nulla',
+        'sum': Decimal('333.33'),
+        'recipient': 'Jane Roe',
+        'cashier_id': 9,
+    }),
+    (3, {
+        'date': date(2017, 10, 11),
+        'reported': True,
+        'purpose': 'Suspendisse nec dolor auctor, scelerisque ex eu, iaculis odio',
+        'sum': Decimal('400.0'),
+        'recipient': 'Jane Roe',
+        'cashier_id': 8,
+    }),
+    (4, {
+        'date': date(2017, 10, 24),
+        'reported': False,
+        'purpose': 'Quisque ut leo ligula',
+        'sum': Decimal('1234.5'),
+        'recipient': 'Joe Bloggs',
+        'cashier_id': 10,
+    }),
+    (5, {
+        'date': date(2017, 12, 1),
+        'reported': True,
+        'purpose': 'Quisque ut leo ligula',
+        'sum': Decimal('800.0'),
+        'recipient': 'Richard Public',
+        'cashier_id': 12,
+    }),
+    (6, {
+        'date': date(2017, 12, 1),
+        'reported': True,
+        'purpose': 'Aenean eget bibendum lorem, a luctus libero',
+        'sum': Decimal('135.79'),
+        'recipient': 'Joe Bloggs',
+        'cashier_id': 10,
+    }),
+]
+
+# - add `report_date`
+# - set `report_date` to the current date if `reported` is True, None if False
+# - delete `reported`
+#
+# new_schema = {
+#     'date': DateObject,
+#     'report_date': DateObject,
+#     'purpose': String,
+#     'sum': DecimalObject,
+#     'recipient': String,
+#     'cashier_id': LongObject,
+# }
+
+
+class ExpenseVoucher(
+    metaclass=GenericObjectMeta,
+    schema=old_schema,
+):
+    pass
+
+
+client = Client()
+client.connect('127.0.0.1', 10800)
+
+accounting = client.get_or_create_cache('accounting')
+
+for key, value in old_data:
+    accounting.put(key, ExpenseVoucher(**value))
+
+data_classes = client.query_binary_type('ExpenseVoucher')
+print(data_classes)
+# {
+#     -231598180: <class '__main__.ExpenseVoucher'>
+# }
+
+s_id, data_class = data_classes.popitem()
+schema = data_class.schema
+
+schema['expense_date'] = schema['date']
+del schema['date']
+schema['report_date'] = DateObject
+del schema['reported']
+schema['sum'] = DecimalObject
+
+
+# define new data class
+class ExpenseVoucherV2(
+    metaclass=GenericObjectMeta,
+    type_name='ExpenseVoucher',
+    schema=schema,
+):
+    pass
+
+
+def migrate(cache, data, new_class):
+    """ Migrate given data pages. """
+    for key, old_value in data:
+        # read data
+        print(old_value)
+        # ExpenseVoucher(
+        #     date=datetime(2017, 9, 21, 0, 0),
+        #     reported=True,
+        #     purpose='Praesent eget fermentum massa',
+        #     sum=Decimal('666.67'),
+        #     recipient='John Doe',
+        #     cashier_id=8,
+        #     version=1
+        # )
+
+        # create new binary object
+        new_value = new_class()
+
+        # process data
+        new_value.sum = old_value.sum
+        new_value.purpose = old_value.purpose
+        new_value.recipient = old_value.recipient
+        new_value.cashier_id = old_value.cashier_id
+        new_value.expense_date = old_value.date
+        new_value.report_date = date.today() if old_value.reported else None
+
+        # replace data
+        cache.put(key, new_value)
+
+        # verify data
+        verify = cache.get(key)
+        print(verify)
+        # ExpenseVoucherV2(
+        #     purpose='Praesent eget fermentum massa',
+        #     sum=Decimal('666.67'),
+        #     recipient='John Doe',
+        #     cashier_id=8,
+        #     expense_date=datetime(2017, 9, 21, 0, 0),
+        #     report_date=datetime(2018, 8, 29, 0, 0),
+        #     version=1,
+        # )
+
+
+# migrate data
+result = accounting.scan()
+migrate(accounting, result, ExpenseVoucherV2)
+
+# cleanup
+accounting.destroy()
+client.close()
diff --git a/examples/read_binary.py b/examples/read_binary.py
new file mode 100644
index 0000000..3a8e9e2
--- /dev/null
+++ b/examples/read_binary.py
@@ -0,0 +1,275 @@
+# 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 decimal import Decimal
+
+from pyignite import Client
+from pyignite.datatypes.prop_codes import *
+
+
+COUNTRY_TABLE_NAME = 'Country'
+CITY_TABLE_NAME = 'City'
+LANGUAGE_TABLE_NAME = 'CountryLanguage'
+
+COUNTRY_CREATE_TABLE_QUERY = '''CREATE TABLE Country (
+    Code CHAR(3) PRIMARY KEY,
+    Name CHAR(52),
+    Continent CHAR(50),
+    Region CHAR(26),
+    SurfaceArea DECIMAL(10,2),
+    IndepYear SMALLINT(6),
+    Population INT(11),
+    LifeExpectancy DECIMAL(3,1),
+    GNP DECIMAL(10,2),
+    GNPOld DECIMAL(10,2),
+    LocalName CHAR(45),
+    GovernmentForm CHAR(45),
+    HeadOfState CHAR(60),
+    Capital INT(11),
+    Code2 CHAR(2)
+)'''
+
+COUNTRY_INSERT_QUERY = '''INSERT INTO Country(
+    Code, Name, Continent, Region,
+    SurfaceArea, IndepYear, Population,
+    LifeExpectancy, GNP, GNPOld,
+    LocalName, GovernmentForm, HeadOfState,
+    Capital, Code2
+) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'''
+
+CITY_CREATE_TABLE_QUERY = '''CREATE TABLE City (
+    ID INT(11),
+    Name CHAR(35),
+    CountryCode CHAR(3),
+    District CHAR(20),
+    Population INT(11),
+    PRIMARY KEY (ID, CountryCode)
+) WITH "affinityKey=CountryCode"'''
+
+CITY_CREATE_INDEX = '''
+CREATE INDEX idx_country_code ON city (CountryCode)'''
+
+CITY_INSERT_QUERY = '''INSERT INTO City(
+    ID, Name, CountryCode, District, Population
+) VALUES (?, ?, ?, ?, ?)'''
+
+LANGUAGE_CREATE_TABLE_QUERY = '''CREATE TABLE CountryLanguage (
+    CountryCode CHAR(3),
+    Language CHAR(30),
+    IsOfficial BOOLEAN,
+    Percentage DECIMAL(4,1),
+    PRIMARY KEY (CountryCode, Language)
+) WITH "affinityKey=CountryCode"'''
+
+LANGUAGE_CREATE_INDEX = '''
+CREATE INDEX idx_lang_country_code ON CountryLanguage (CountryCode)'''
+
+LANGUAGE_INSERT_QUERY = '''INSERT INTO CountryLanguage(
+    CountryCode, Language, IsOfficial, Percentage
+) VALUES (?, ?, ?, ?)'''
+
+DROP_TABLE_QUERY = '''DROP TABLE {} IF EXISTS'''
+
+COUNTRY_DATA = [
+    [
+        'USA', 'United States', 'North America', 'North America',
+        Decimal('9363520.00'), 1776, 278357000,
+        Decimal('77.1'), Decimal('8510700.00'), Decimal('8110900.00'),
+        'United States', 'Federal Republic', 'George W. Bush',
+        3813, 'US',
+    ],
+    [
+        'IND', 'India', 'Asia', 'Southern and Central Asia',
+        Decimal('3287263.00'), 1947, 1013662000,
+        Decimal('62.5'), Decimal('447114.00'), Decimal('430572.00'),
+        'Bharat/India', 'Federal Republic', 'Kocheril Raman Narayanan',
+        1109, 'IN',
+    ],
+    [
+        'CHN', 'China', 'Asia', 'Eastern Asia',
+        Decimal('9572900.00'), -1523, 1277558000,
+        Decimal('71.4'), Decimal('982268.00'), Decimal('917719.00'),
+        'Zhongquo', 'PeoplesRepublic', 'Jiang Zemin',
+        1891, 'CN',
+    ],
+]
+
+CITY_DATA = [
+    [3793, 'New York', 'USA', 'New York', 8008278],
+    [3794, 'Los Angeles', 'USA', 'California', 3694820],
+    [3795, 'Chicago', 'USA', 'Illinois', 2896016],
+    [3796, 'Houston', 'USA', 'Texas', 1953631],
+    [3797, 'Philadelphia', 'USA', 'Pennsylvania', 1517550],
+    [3798, 'Phoenix', 'USA', 'Arizona', 1321045],
+    [3799, 'San Diego', 'USA', 'California', 1223400],
+    [3800, 'Dallas', 'USA', 'Texas', 1188580],
+    [3801, 'San Antonio', 'USA', 'Texas', 1144646],
+    [3802, 'Detroit', 'USA', 'Michigan', 951270],
+    [3803, 'San Jose', 'USA', 'California', 894943],
+    [3804, 'Indianapolis', 'USA', 'Indiana', 791926],
+    [3805, 'San Francisco', 'USA', 'California', 776733],
+    [1024, 'Mumbai (Bombay)', 'IND', 'Maharashtra', 10500000],
+    [1025, 'Delhi', 'IND', 'Delhi', 7206704],
+    [1026, 'Calcutta [Kolkata]', 'IND', 'West Bengali', 4399819],
+    [1027, 'Chennai (Madras)', 'IND', 'Tamil Nadu', 3841396],
+    [1028, 'Hyderabad', 'IND', 'Andhra Pradesh', 2964638],
+    [1029, 'Ahmedabad', 'IND', 'Gujarat', 2876710],
+    [1030, 'Bangalore', 'IND', 'Karnataka', 2660088],
+    [1031, 'Kanpur', 'IND', 'Uttar Pradesh', 1874409],
+    [1032, 'Nagpur', 'IND', 'Maharashtra', 1624752],
+    [1033, 'Lucknow', 'IND', 'Uttar Pradesh', 1619115],
+    [1034, 'Pune', 'IND', 'Maharashtra', 1566651],
+    [1035, 'Surat', 'IND', 'Gujarat', 1498817],
+    [1036, 'Jaipur', 'IND', 'Rajasthan', 1458483],
+    [1890, 'Shanghai', 'CHN', 'Shanghai', 9696300],
+    [1891, 'Peking', 'CHN', 'Peking', 7472000],
+    [1892, 'Chongqing', 'CHN', 'Chongqing', 6351600],
+    [1893, 'Tianjin', 'CHN', 'Tianjin', 5286800],
+    [1894, 'Wuhan', 'CHN', 'Hubei', 4344600],
+    [1895, 'Harbin', 'CHN', 'Heilongjiang', 4289800],
+    [1896, 'Shenyang', 'CHN', 'Liaoning', 4265200],
+    [1897, 'Kanton [Guangzhou]', 'CHN', 'Guangdong', 4256300],
+    [1898, 'Chengdu', 'CHN', 'Sichuan', 3361500],
+    [1899, 'Nanking [Nanjing]', 'CHN', 'Jiangsu', 2870300],
+    [1900, 'Changchun', 'CHN', 'Jilin', 2812000],
+    [1901, 'Xi´an', 'CHN', 'Shaanxi', 2761400],
+    [1902, 'Dalian', 'CHN', 'Liaoning', 2697000],
+    [1903, 'Qingdao', 'CHN', 'Shandong', 2596000],
+    [1904, 'Jinan', 'CHN', 'Shandong', 2278100],
+    [1905, 'Hangzhou', 'CHN', 'Zhejiang', 2190500],
+    [1906, 'Zhengzhou', 'CHN', 'Henan', 2107200],
+]
+
+LANGUAGE_DATA = [
+    ['USA', 'Chinese', False, Decimal('0.6')],
+    ['USA', 'English', True, Decimal('86.2')],
+    ['USA', 'French', False, Decimal('0.7')],
+    ['USA', 'German', False, Decimal('0.7')],
+    ['USA', 'Italian', False, Decimal('0.6')],
+    ['USA', 'Japanese', False, Decimal('0.2')],
+    ['USA', 'Korean', False, Decimal('0.3')],
+    ['USA', 'Polish', False, Decimal('0.3')],
+    ['USA', 'Portuguese', False, Decimal('0.2')],
+    ['USA', 'Spanish', False, Decimal('7.5')],
+    ['USA', 'Tagalog', False, Decimal('0.4')],
+    ['USA', 'Vietnamese', False, Decimal('0.2')],
+    ['IND', 'Asami', False, Decimal('1.5')],
+    ['IND', 'Bengali', False, Decimal('8.2')],
+    ['IND', 'Gujarati', False, Decimal('4.8')],
+    ['IND', 'Hindi', True, Decimal('39.9')],
+    ['IND', 'Kannada', False, Decimal('3.9')],
+    ['IND', 'Malajalam', False, Decimal('3.6')],
+    ['IND', 'Marathi', False, Decimal('7.4')],
+    ['IND', 'Orija', False, Decimal('3.3')],
+    ['IND', 'Punjabi', False, Decimal('2.8')],
+    ['IND', 'Tamil', False, Decimal('6.3')],
+    ['IND', 'Telugu', False, Decimal('7.8')],
+    ['IND', 'Urdu', False, Decimal('5.1')],
+    ['CHN', 'Chinese', True, Decimal('92.0')],
+    ['CHN', 'Dong', False, Decimal('0.2')],
+    ['CHN', 'Hui', False, Decimal('0.8')],
+    ['CHN', 'Mantšu', False, Decimal('0.9')],
+    ['CHN', 'Miao', False, Decimal('0.7')],
+    ['CHN', 'Mongolian', False, Decimal('0.4')],
+    ['CHN', 'Puyi', False, Decimal('0.2')],
+    ['CHN', 'Tibetan', False, Decimal('0.4')],
+    ['CHN', 'Tujia', False, Decimal('0.5')],
+    ['CHN', 'Uighur', False, Decimal('0.6')],
+    ['CHN', 'Yi', False, Decimal('0.6')],
+    ['CHN', 'Zhuang', False, Decimal('1.4')],
+]
+
+
+# establish connection
+client = Client()
+client.connect('127.0.0.1', 10800)
+
+# create tables
+for query in [
+    COUNTRY_CREATE_TABLE_QUERY,
+    CITY_CREATE_TABLE_QUERY,
+    LANGUAGE_CREATE_TABLE_QUERY,
+]:
+    client.sql(query)
+
+# create indices
+for query in [CITY_CREATE_INDEX, LANGUAGE_CREATE_INDEX]:
+    client.sql(query)
+
+# load data
+for row in COUNTRY_DATA:
+    client.sql(COUNTRY_INSERT_QUERY, query_args=row)
+
+for row in CITY_DATA:
+    client.sql(CITY_INSERT_QUERY, query_args=row)
+
+for row in LANGUAGE_DATA:
+    client.sql(LANGUAGE_INSERT_QUERY, query_args=row)
+
+# examine the storage
+result = client.get_cache_names()
+print(result)
+# [
+#     'SQL_PUBLIC_CITY',
+#     'SQL_PUBLIC_COUNTRY',
+#     'PUBLIC',
+#     'SQL_PUBLIC_COUNTRYLANGUAGE'
+# ]
+
+city_cache = client.get_or_create_cache('SQL_PUBLIC_CITY')
+print(city_cache.settings[PROP_NAME])
+# 'SQL_PUBLIC_CITY'
+
+print(city_cache.settings[PROP_QUERY_ENTITIES])
+# {
+#     'key_type_name': (
+#         'SQL_PUBLIC_CITY_9ac8e17a_2f99_45b7_958e_06da32882e9d_KEY'
+#     ),
+#     'value_type_name': (
+#         'SQL_PUBLIC_CITY_9ac8e17a_2f99_45b7_958e_06da32882e9d'
+#     ),
+#     'table_name': 'CITY',
+#     'query_fields': [
+#         ...
+#     ],
+#     'field_name_aliases': [
+#         ...
+#     ],
+#     'query_indexes': []
+# }
+
+result = city_cache.scan()
+print(next(result))
+# (
+#     SQL_PUBLIC_CITY_6fe650e1_700f_4e74_867d_58f52f433c43_KEY(
+#         ID=1890,
+#         COUNTRYCODE='CHN',
+#         version=1
+#     ),
+#     SQL_PUBLIC_CITY_6fe650e1_700f_4e74_867d_58f52f433c43(
+#         NAME='Shanghai',
+#         DISTRICT='Shanghai',
+#         POPULATION=9696300,
+#         version=1
+#     )
+# )
+
+# clean up
+for table_name in [
+    CITY_TABLE_NAME,
+    LANGUAGE_TABLE_NAME,
+    COUNTRY_TABLE_NAME,
+]:
+    result = client.sql(DROP_TABLE_QUERY.format(table_name))
diff --git a/examples/readme.md b/examples/readme.md
new file mode 100644
index 0000000..3628c82
--- /dev/null
+++ b/examples/readme.md
@@ -0,0 +1,17 @@
+# Examples
+
+This directory contains the following example files:
+
+- `binary_basics.py` − basic operations with Complex objects,
+- `binary_types.py` - read SQL table as a key-value cache,
+- `create_binary.py` − create SQL row with key-value operation,
+- `failover.py` − fail-over connection to Ignite cluster,
+- `get_and_put.py` − basic key-value operations,
+- `migrate_binary.py` − work with Complex object schemas,
+- `scans.py` − cache scan operation,
+- `sql.py` − use Ignite SQL,
+- `type_hints.py` − type hints.
+
+For the explanation of the examples please refer to the
+[Examples of usage](https://apache-ignite-binary-protocol-client.readthedocs.io/en/latest/examples.html)
+section of the `pyignite` documentation.
diff --git a/examples/scans.py b/examples/scans.py
new file mode 100644
index 0000000..d5f2b48
--- /dev/null
+++ b/examples/scans.py
@@ -0,0 +1,55 @@
+# 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 pyignite import Client
+
+client = Client()
+client.connect('127.0.0.1', 10800)
+
+my_cache = client.create_cache('my cache')
+
+my_cache.put_all({'key_{}'.format(v): v for v in range(20)})
+# {
+#     'key_0': 0,
+#     'key_1': 1,
+#     'key_2': 2,
+#     ... 20 elements in total...
+#     'key_18': 18,
+#     'key_19': 19
+# }
+
+result = my_cache.scan()
+for k, v in result:
+    print(k, v)
+# 'key_17' 17
+# 'key_10' 10
+# 'key_6' 6,
+# ... 20 elements in total...
+# 'key_16' 16
+# 'key_12' 12
+
+result = my_cache.scan()
+print(dict(result))
+# {
+#     'key_17': 17,
+#     'key_10': 10,
+#     'key_6': 6,
+#     ... 20 elements in total...
+#     'key_16': 16,
+#     'key_12': 12
+# }
+
+my_cache.destroy()
+client.close()
diff --git a/examples/sql.py b/examples/sql.py
new file mode 100644
index 0000000..8f0ee7c
--- /dev/null
+++ b/examples/sql.py
@@ -0,0 +1,298 @@
+# 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 decimal import Decimal
+
+from pyignite import Client
+
+
+COUNTRY_TABLE_NAME = 'Country'
+CITY_TABLE_NAME = 'City'
+LANGUAGE_TABLE_NAME = 'CountryLanguage'
+
+COUNTRY_CREATE_TABLE_QUERY = '''CREATE TABLE Country (
+    Code CHAR(3) PRIMARY KEY,
+    Name CHAR(52),
+    Continent CHAR(50),
+    Region CHAR(26),
+    SurfaceArea DECIMAL(10,2),
+    IndepYear SMALLINT(6),
+    Population INT(11),
+    LifeExpectancy DECIMAL(3,1),
+    GNP DECIMAL(10,2),
+    GNPOld DECIMAL(10,2),
+    LocalName CHAR(45),
+    GovernmentForm CHAR(45),
+    HeadOfState CHAR(60),
+    Capital INT(11),
+    Code2 CHAR(2)
+)'''
+
+COUNTRY_INSERT_QUERY = '''INSERT INTO Country(
+    Code, Name, Continent, Region,
+    SurfaceArea, IndepYear, Population,
+    LifeExpectancy, GNP, GNPOld,
+    LocalName, GovernmentForm, HeadOfState,
+    Capital, Code2
+) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)'''
+
+CITY_CREATE_TABLE_QUERY = '''CREATE TABLE City (
+    ID INT(11),
+    Name CHAR(35),
+    CountryCode CHAR(3),
+    District CHAR(20),
+    Population INT(11),
+    PRIMARY KEY (ID, CountryCode)
+) WITH "affinityKey=CountryCode"'''
+
+CITY_CREATE_INDEX = '''
+CREATE INDEX idx_country_code ON city (CountryCode)'''
+
+CITY_INSERT_QUERY = '''INSERT INTO City(
+    ID, Name, CountryCode, District, Population
+) VALUES (?, ?, ?, ?, ?)'''
+
+LANGUAGE_CREATE_TABLE_QUERY = '''CREATE TABLE CountryLanguage (
+    CountryCode CHAR(3),
+    Language CHAR(30),
+    IsOfficial BOOLEAN,
+    Percentage DECIMAL(4,1),
+    PRIMARY KEY (CountryCode, Language)
+) WITH "affinityKey=CountryCode"'''
+
+LANGUAGE_CREATE_INDEX = '''
+CREATE INDEX idx_lang_country_code ON CountryLanguage (CountryCode)'''
+
+LANGUAGE_INSERT_QUERY = '''INSERT INTO CountryLanguage(
+    CountryCode, Language, IsOfficial, Percentage
+) VALUES (?, ?, ?, ?)'''
+
+DROP_TABLE_QUERY = '''DROP TABLE {} IF EXISTS'''
+
+COUNTRY_DATA = [
+    [
+        'USA', 'United States', 'North America', 'North America',
+        Decimal('9363520.00'), 1776, 278357000,
+        Decimal('77.1'), Decimal('8510700.00'), Decimal('8110900.00'),
+        'United States', 'Federal Republic', 'George W. Bush',
+        3813, 'US',
+    ],
+    [
+        'IND', 'India', 'Asia', 'Southern and Central Asia',
+        Decimal('3287263.00'), 1947, 1013662000,
+        Decimal('62.5'), Decimal('447114.00'), Decimal('430572.00'),
+        'Bharat/India', 'Federal Republic', 'Kocheril Raman Narayanan',
+        1109, 'IN',
+    ],
+    [
+        'CHN', 'China', 'Asia', 'Eastern Asia',
+        Decimal('9572900.00'), -1523, 1277558000,
+        Decimal('71.4'), Decimal('982268.00'), Decimal('917719.00'),
+        'Zhongquo', 'PeoplesRepublic', 'Jiang Zemin',
+        1891, 'CN',
+    ],
+]
+
+CITY_DATA = [
+    [3793, 'New York', 'USA', 'New York', 8008278],
+    [3794, 'Los Angeles', 'USA', 'California', 3694820],
+    [3795, 'Chicago', 'USA', 'Illinois', 2896016],
+    [3796, 'Houston', 'USA', 'Texas', 1953631],
+    [3797, 'Philadelphia', 'USA', 'Pennsylvania', 1517550],
+    [3798, 'Phoenix', 'USA', 'Arizona', 1321045],
+    [3799, 'San Diego', 'USA', 'California', 1223400],
+    [3800, 'Dallas', 'USA', 'Texas', 1188580],
+    [3801, 'San Antonio', 'USA', 'Texas', 1144646],
+    [3802, 'Detroit', 'USA', 'Michigan', 951270],
+    [3803, 'San Jose', 'USA', 'California', 894943],
+    [3804, 'Indianapolis', 'USA', 'Indiana', 791926],
+    [3805, 'San Francisco', 'USA', 'California', 776733],
+    [1024, 'Mumbai (Bombay)', 'IND', 'Maharashtra', 10500000],
+    [1025, 'Delhi', 'IND', 'Delhi', 7206704],
+    [1026, 'Calcutta [Kolkata]', 'IND', 'West Bengali', 4399819],
+    [1027, 'Chennai (Madras)', 'IND', 'Tamil Nadu', 3841396],
+    [1028, 'Hyderabad', 'IND', 'Andhra Pradesh', 2964638],
+    [1029, 'Ahmedabad', 'IND', 'Gujarat', 2876710],
+    [1030, 'Bangalore', 'IND', 'Karnataka', 2660088],
+    [1031, 'Kanpur', 'IND', 'Uttar Pradesh', 1874409],
+    [1032, 'Nagpur', 'IND', 'Maharashtra', 1624752],
+    [1033, 'Lucknow', 'IND', 'Uttar Pradesh', 1619115],
+    [1034, 'Pune', 'IND', 'Maharashtra', 1566651],
+    [1035, 'Surat', 'IND', 'Gujarat', 1498817],
+    [1036, 'Jaipur', 'IND', 'Rajasthan', 1458483],
+    [1890, 'Shanghai', 'CHN', 'Shanghai', 9696300],
+    [1891, 'Peking', 'CHN', 'Peking', 7472000],
+    [1892, 'Chongqing', 'CHN', 'Chongqing', 6351600],
+    [1893, 'Tianjin', 'CHN', 'Tianjin', 5286800],
+    [1894, 'Wuhan', 'CHN', 'Hubei', 4344600],
+    [1895, 'Harbin', 'CHN', 'Heilongjiang', 4289800],
+    [1896, 'Shenyang', 'CHN', 'Liaoning', 4265200],
+    [1897, 'Kanton [Guangzhou]', 'CHN', 'Guangdong', 4256300],
+    [1898, 'Chengdu', 'CHN', 'Sichuan', 3361500],
+    [1899, 'Nanking [Nanjing]', 'CHN', 'Jiangsu', 2870300],
+    [1900, 'Changchun', 'CHN', 'Jilin', 2812000],
+    [1901, 'Xi´an', 'CHN', 'Shaanxi', 2761400],
+    [1902, 'Dalian', 'CHN', 'Liaoning', 2697000],
+    [1903, 'Qingdao', 'CHN', 'Shandong', 2596000],
+    [1904, 'Jinan', 'CHN', 'Shandong', 2278100],
+    [1905, 'Hangzhou', 'CHN', 'Zhejiang', 2190500],
+    [1906, 'Zhengzhou', 'CHN', 'Henan', 2107200],
+]
+
+LANGUAGE_DATA = [
+    ['USA', 'Chinese', False, Decimal('0.6')],
+    ['USA', 'English', True, Decimal('86.2')],
+    ['USA', 'French', False, Decimal('0.7')],
+    ['USA', 'German', False, Decimal('0.7')],
+    ['USA', 'Italian', False, Decimal('0.6')],
+    ['USA', 'Japanese', False, Decimal('0.2')],
+    ['USA', 'Korean', False, Decimal('0.3')],
+    ['USA', 'Polish', False, Decimal('0.3')],
+    ['USA', 'Portuguese', False, Decimal('0.2')],
+    ['USA', 'Spanish', False, Decimal('7.5')],
+    ['USA', 'Tagalog', False, Decimal('0.4')],
+    ['USA', 'Vietnamese', False, Decimal('0.2')],
+    ['IND', 'Asami', False, Decimal('1.5')],
+    ['IND', 'Bengali', False, Decimal('8.2')],
+    ['IND', 'Gujarati', False, Decimal('4.8')],
+    ['IND', 'Hindi', True, Decimal('39.9')],
+    ['IND', 'Kannada', False, Decimal('3.9')],
+    ['IND', 'Malajalam', False, Decimal('3.6')],
+    ['IND', 'Marathi', False, Decimal('7.4')],
+    ['IND', 'Orija', False, Decimal('3.3')],
+    ['IND', 'Punjabi', False, Decimal('2.8')],
+    ['IND', 'Tamil', False, Decimal('6.3')],
+    ['IND', 'Telugu', False, Decimal('7.8')],
+    ['IND', 'Urdu', False, Decimal('5.1')],
+    ['CHN', 'Chinese', True, Decimal('92.0')],
+    ['CHN', 'Dong', False, Decimal('0.2')],
+    ['CHN', 'Hui', False, Decimal('0.8')],
+    ['CHN', 'Mantšu', False, Decimal('0.9')],
+    ['CHN', 'Miao', False, Decimal('0.7')],
+    ['CHN', 'Mongolian', False, Decimal('0.4')],
+    ['CHN', 'Puyi', False, Decimal('0.2')],
+    ['CHN', 'Tibetan', False, Decimal('0.4')],
+    ['CHN', 'Tujia', False, Decimal('0.5')],
+    ['CHN', 'Uighur', False, Decimal('0.6')],
+    ['CHN', 'Yi', False, Decimal('0.6')],
+    ['CHN', 'Zhuang', False, Decimal('1.4')],
+]
+
+
+# establish connection
+client = Client()
+client.connect('127.0.0.1', 10800)
+
+# create tables
+for query in [
+    COUNTRY_CREATE_TABLE_QUERY,
+    CITY_CREATE_TABLE_QUERY,
+    LANGUAGE_CREATE_TABLE_QUERY,
+]:
+    client.sql(query)
+
+# create indices
+for query in [CITY_CREATE_INDEX, LANGUAGE_CREATE_INDEX]:
+    client.sql(query)
+
+# load data
+for row in COUNTRY_DATA:
+    client.sql(COUNTRY_INSERT_QUERY, query_args=row)
+
+for row in CITY_DATA:
+    client.sql(CITY_INSERT_QUERY, query_args=row)
+
+for row in LANGUAGE_DATA:
+    client.sql(LANGUAGE_INSERT_QUERY, query_args=row)
+
+# 10 most populated cities (with pagination)
+MOST_POPULATED_QUERY = '''
+SELECT name, population FROM City ORDER BY population DESC LIMIT 10'''
+
+result = client.sql(MOST_POPULATED_QUERY)
+print('Most 10 populated cities:')
+for row in result:
+    print(row)
+# Most 10 populated cities:
+# ['Mumbai (Bombay)', 10500000]
+# ['Shanghai', 9696300]
+# ['New York', 8008278]
+# ['Peking', 7472000]
+# ['Delhi', 7206704]
+# ['Chongqing', 6351600]
+# ['Tianjin', 5286800]
+# ['Calcutta [Kolkata]', 4399819]
+# ['Wuhan', 4344600]
+# ['Harbin', 4289800]
+
+# 10 most populated cities in 3 countries (with pagination and header row)
+MOST_POPULATED_IN_3_COUNTRIES_QUERY = '''
+SELECT country.name as country_name, city.name as city_name, MAX(city.population) AS max_pop FROM country
+    JOIN city ON city.countrycode = country.code
+    WHERE country.code IN ('USA','IND','CHN')
+    GROUP BY country.name, city.name ORDER BY max_pop DESC LIMIT 10
+'''
+
+result = client.sql(
+    MOST_POPULATED_IN_3_COUNTRIES_QUERY,
+    include_field_names=True,
+)
+print('Most 10 populated cities in USA, India and China:')
+print(next(result))
+print('----------------------------------------')
+for row in result:
+    print(row)
+# Most 10 populated cities in USA, India and China:
+# ['COUNTRY_NAME', 'CITY_NAME', 'MAX_POP']
+# ----------------------------------------
+# ['India', 'Mumbai (Bombay)', 10500000]
+# ['China', 'Shanghai', 9696300]
+# ['United States', 'New York', 8008278]
+# ['China', 'Peking', 7472000]
+# ['India', 'Delhi', 7206704]
+# ['China', 'Chongqing', 6351600]
+# ['China', 'Tianjin', 5286800]
+# ['India', 'Calcutta [Kolkata]', 4399819]
+# ['China', 'Wuhan', 4344600]
+# ['China', 'Harbin', 4289800]
+
+# show city info
+CITY_INFO_QUERY = '''SELECT * FROM City WHERE id = ?'''
+
+result = client.sql(
+    CITY_INFO_QUERY,
+    query_args=[3802],
+    include_field_names=True,
+)
+field_names = next(result)
+field_data = list(*result)
+
+print('City info:')
+for field_name, field_value in zip(field_names*len(field_data), field_data):
+    print('{}: {}'.format(field_name, field_value))
+# City info:
+# ID: 3802
+# NAME: Detroit
+# COUNTRYCODE: USA
+# DISTRICT: Michigan
+# POPULATION: 951270
+
+# clean up
+for table_name in [
+    CITY_TABLE_NAME,
+    LANGUAGE_TABLE_NAME,
+    COUNTRY_TABLE_NAME,
+]:
+    result = client.sql(DROP_TABLE_QUERY.format(table_name))
diff --git a/examples/type_hints.py b/examples/type_hints.py
new file mode 100644
index 0000000..4cc44c0
--- /dev/null
+++ b/examples/type_hints.py
@@ -0,0 +1,51 @@
+# 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 pyignite import Client
+from pyignite.datatypes import CharObject, ShortObject
+
+client = Client()
+client.connect('127.0.0.1', 10800)
+
+my_cache = client.get_or_create_cache('my cache')
+
+my_cache.put('my key', 42)
+# value ‘42’ takes 9 bytes of memory as a LongObject
+
+my_cache.put('my key', 42, value_hint=ShortObject)
+# value ‘42’ takes only 3 bytes as a ShortObject
+
+my_cache.put('a', 1)
+# ‘a’ is a key of type String
+
+my_cache.put('a', 2, key_hint=CharObject)
+# another key ‘a’ of type CharObject was created
+
+value = my_cache.get('a')
+print(value)
+# 1
+
+value = my_cache.get('a', key_hint=CharObject)
+print(value)
+# 2
+
+# now let us delete both keys at once
+my_cache.remove_keys([
+    'a',                # a default type key
+    ('a', CharObject),  # a key of type CharObject
+])
+
+my_cache.destroy()
+client.close()
diff --git a/pyignite/__init__.py b/pyignite/__init__.py
new file mode 100644
index 0000000..0ac346f
--- /dev/null
+++ b/pyignite/__init__.py
@@ -0,0 +1,17 @@
+# 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 pyignite.client import Client
+from pyignite.binary import GenericObjectMeta
diff --git a/pyignite/api/__init__.py b/pyignite/api/__init__.py
new file mode 100644
index 0000000..01437f0
--- /dev/null
+++ b/pyignite/api/__init__.py
@@ -0,0 +1,71 @@
+# 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.
+
+"""
+This module contains functions, that are (more or less) directly mapped to
+Apache Ignite binary protocol operations. Read more:
+
+https://apacheignite.readme.io/docs/binary-client-protocol#section-client-operations
+
+When the binary client protocol changes, these functions also change. For
+stable end user API see :mod:`pyignite.client` module.
+"""
+
+from .cache_config import (
+    cache_create,
+    cache_get_names,
+    cache_get_or_create,
+    cache_destroy,
+    cache_get_configuration,
+    cache_create_with_config,
+    cache_get_or_create_with_config,
+)
+from .key_value import (
+    cache_get,
+    cache_put,
+    cache_get_all,
+    cache_put_all,
+    cache_contains_key,
+    cache_contains_keys,
+    cache_get_and_put,
+    cache_get_and_replace,
+    cache_get_and_remove,
+    cache_put_if_absent,
+    cache_get_and_put_if_absent,
+    cache_replace,
+    cache_replace_if_equals,
+    cache_clear,
+    cache_clear_key,
+    cache_clear_keys,
+    cache_remove_key,
+    cache_remove_if_equals,
+    cache_remove_keys,
+    cache_remove_all,
+    cache_get_size,
+)
+from .sql import (
+    scan,
+    scan_cursor_get_page,
+    sql,
+    sql_cursor_get_page,
+    sql_fields,
+    sql_fields_cursor_get_page,
+    resource_close,
+)
+from .binary import (
+    get_binary_type,
+    put_binary_type,
+)
+from .result import APIResult
diff --git a/pyignite/api/binary.py b/pyignite/api/binary.py
new file mode 100644
index 0000000..f0a5831
--- /dev/null
+++ b/pyignite/api/binary.py
@@ -0,0 +1,209 @@
+# 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 Union
+
+from pyignite.constants import *
+from pyignite.datatypes.binary import (
+    body_struct, enum_struct, schema_struct, binary_fields_struct,
+)
+from pyignite.datatypes import String, Int, Bool
+from pyignite.queries import Query, Response
+from pyignite.queries.op_codes import *
+from pyignite.utils import int_overflow, entity_id
+from .result import APIResult
+
+
+def get_binary_type(
+    connection: 'Connection', binary_type: Union[str, int], query_id=None,
+) -> APIResult:
+    """
+    Gets the binary type information by type ID.
+
+    :param connection: connection to Ignite server,
+    :param binary_type: binary type name or ID,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object.
+    """
+
+    query_struct = Query(
+        OP_GET_BINARY_TYPE,
+        [
+            ('type_id', Int),
+        ],
+        query_id=query_id,
+    )
+
+    _, send_buffer = query_struct.from_python({
+        'type_id': entity_id(binary_type),
+    })
+    connection.send(send_buffer)
+
+    response_head_struct = Response([
+        ('type_exists', Bool),
+    ])
+    response_head_type, recv_buffer = response_head_struct.parse(connection)
+    response_head = response_head_type.from_buffer_copy(recv_buffer)
+    response_parts = []
+    if response_head.type_exists:
+        resp_body_type, resp_body_buffer = body_struct.parse(connection)
+        response_parts.append(('body', resp_body_type))
+        resp_body = resp_body_type.from_buffer_copy(resp_body_buffer)
+        recv_buffer += resp_body_buffer
+        if resp_body.is_enum:
+            resp_enum, resp_enum_buffer = enum_struct.parse(connection)
+            response_parts.append(('enums', resp_enum))
+            recv_buffer += resp_enum_buffer
+        resp_schema_type, resp_schema_buffer = schema_struct.parse(connection)
+        response_parts.append(('schema', resp_schema_type))
+        recv_buffer += resp_schema_buffer
+
+    response_class = type(
+        'GetBinaryTypeResponse',
+        (response_head_type,),
+        {
+            '_pack_': 1,
+            '_fields_': response_parts,
+        }
+    )
+    response = response_class.from_buffer_copy(recv_buffer)
+    result = APIResult(response)
+    if result.status != 0:
+        return result
+    result.value = {
+        'type_exists': response.type_exists
+    }
+    if hasattr(response, 'body'):
+        result.value.update(body_struct.to_python(response.body))
+    if hasattr(response, 'enums'):
+        result.value['enums'] = enum_struct.to_python(response.enums)
+    if hasattr(response, 'schema'):
+        result.value['schema'] = {
+            x['schema_id']: [
+                z['schema_field_id'] for z in x['schema_fields']
+            ]
+            for x in schema_struct.to_python(response.schema)
+        }
+    return result
+
+
+def put_binary_type(
+    connection: 'Connection', type_name: str, affinity_key_field: str=None,
+    is_enum=False, schema: dict=None, query_id=None,
+) -> APIResult:
+    """
+    Registers binary type information in cluster.
+
+    :param connection: connection to Ignite server,
+    :param type_name: name of the data type being registered,
+    :param affinity_key_field: (optional) name of the affinity key field,
+    :param is_enum: (optional) register enum if True, binary object otherwise.
+     Defaults to False,
+    :param schema: (optional) when register enum, pass a dict of enumerated
+     parameter names as keys and an integers as values. When register binary
+     type, pass a dict of field names: field types. Binary type with no fields
+     is OK,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object.
+    """
+    # 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': [],
+    }
+    schema_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
+        schema_id = FNV1_OFFSET_BASIS if schema else 0
+        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,
+            })
+            schema_id ^= (field_id & 0xff)
+            schema_id = int_overflow(schema_id * FNV1_PRIME)
+            schema_id ^= ((field_id >> 8) & 0xff)
+            schema_id = int_overflow(schema_id * FNV1_PRIME)
+            schema_id ^= ((field_id >> 16) & 0xff)
+            schema_id = int_overflow(schema_id * FNV1_PRIME)
+            schema_id ^= ((field_id >> 24) & 0xff)
+            schema_id = int_overflow(schema_id * FNV1_PRIME)
+
+    data['schema'].append({
+        'schema_id': schema_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,
+        )
+    result = query_struct.perform(connection, query_params=data)
+    if result.status == 0:
+        result.value = {
+            'type_id': type_id,
+            'schema_id': schema_id,
+        }
+    return result
diff --git a/pyignite/api/cache_config.py b/pyignite/api/cache_config.py
new file mode 100644
index 0000000..cfea416
--- /dev/null
+++ b/pyignite/api/cache_config.py
@@ -0,0 +1,279 @@
+# 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.
+
+"""
+Set of functions to manipulate caches.
+
+Ignite `cache` can be viewed as a named entity designed to store key-value
+pairs. Each cache is split transparently between different Ignite partitions.
+
+The choice of `cache` term is due to historical reasons. (Ignite initially had
+only non-persistent storage tier.)
+"""
+
+from typing import Union
+
+from pyignite.datatypes.cache_config import cache_config_struct
+from pyignite.datatypes.cache_properties import prop_map
+from pyignite.datatypes import (
+    Int, Byte, prop_codes, Short, String, StringArray,
+)
+from pyignite.queries import Query, ConfigQuery
+from pyignite.queries.op_codes import *
+from pyignite.utils import cache_id
+
+
+def compact_cache_config(cache_config: dict) -> dict:
+    """
+    This is to make cache config read/write-symmetrical.
+
+    :param cache_config: dict of cache config properties,
+     like {'is_onheapcache_enabled': 1},
+    :return: the same dict, but with property codes as keys,
+     like {PROP_IS_ONHEAPCACHE_ENABLED: 1}.
+    """
+    result = {}
+    for k, v in cache_config.items():
+        if k == 'length':
+            continue
+        prop_code = getattr(prop_codes, 'PROP_{}'.format(k.upper()))
+        result[prop_code] = v
+    return result
+
+
+def cache_get_configuration(
+    connection: 'Connection', cache: Union[str, int], flags: int=0, query_id=None,
+) -> 'APIResult':
+    """
+    Gets configuration for the given cache.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :param flags: Ignite documentation is unclear on this subject,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Result value is OrderedDict with
+     the cache configuration parameters.
+    """
+
+    query_struct = Query(
+        OP_CACHE_GET_CONFIGURATION,
+        [
+            ('hash_code', Int),
+            ('flags', Byte),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flags': flags,
+        },
+        response_config=[
+            ('cache_config', cache_config_struct),
+        ],
+    )
+    if result.status == 0:
+        result.value = compact_cache_config(result.value['cache_config'])
+    return result
+
+
+def cache_create(
+    connection: 'Connection', name: str, query_id=None,
+) -> 'APIResult':
+    """
+    Creates a cache with a given name. Returns error if a cache with specified
+    name already exists.
+
+    :param connection: connection to Ignite server,
+    :param name: cache name,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status if a cache is
+     created successfully, non-zero status and an error description otherwise.
+    """
+
+    query_struct = Query(
+        OP_CACHE_CREATE_WITH_NAME,
+        [
+            ('cache_name', String),
+        ],
+        query_id=query_id,
+    )
+    return query_struct.perform(
+        connection,
+        query_params={
+            'cache_name': name,
+        },
+    )
+
+
+def cache_get_or_create(
+    connection: 'Connection', name: str, query_id=None,
+) -> 'APIResult':
+    """
+    Creates a cache with a given name. Does nothing if the cache exists.
+
+    :param connection: connection to Ignite server,
+    :param name: cache name,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status if a cache is
+     created successfully, non-zero status and an error description otherwise.
+    """
+
+    query_struct = Query(
+        OP_CACHE_GET_OR_CREATE_WITH_NAME,
+        [
+            ('cache_name', String),
+        ],
+        query_id=query_id,
+    )
+    return query_struct.perform(
+        connection,
+        query_params={
+            'cache_name': name,
+        },
+    )
+
+
+def cache_destroy(
+    connection: 'Connection', cache: Union[str, int], query_id=None,
+) -> 'APIResult':
+    """
+    Destroys cache with a given name.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object.
+    """
+
+    query_struct = Query(
+        OP_CACHE_DESTROY,[
+            ('hash_code', Int),
+        ],
+        query_id=query_id,
+    )
+    return query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+        },
+    )
+
+
+def cache_get_names(connection: 'Connection', query_id=None) -> 'APIResult':
+    """
+    Gets existing cache names.
+
+    :param connection: connection to Ignite server,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status and a list of cache
+     names, non-zero status and an error description otherwise.
+    """
+
+    query_struct = Query(OP_CACHE_GET_NAMES, query_id=query_id)
+    result = query_struct.perform(
+        connection,
+        response_config=[
+            ('cache_names', StringArray),
+        ],
+    )
+    if result.status == 0:
+        result.value = result.value['cache_names']
+    return result
+
+
+def cache_create_with_config(
+    connection: 'Connection', cache_props: dict, query_id=None,
+) -> 'APIResult':
+    """
+    Creates cache with provided configuration. An error is returned
+    if the name is already in use.
+
+    :param connection: connection to Ignite server,
+    :param cache_props: cache configuration properties to create cache with
+     in form of dictionary {property code: python value}.
+     You must supply at least name (PROP_NAME),
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status if cache was created,
+     non-zero status and an error description otherwise.
+    """
+
+    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)
+
+    query_struct = ConfigQuery(
+        OP_CACHE_CREATE_WITH_CONFIGURATION,
+        [
+            ('param_count', Short),
+        ] + list(prop_types.items()),
+        query_id=query_id,
+    )
+    return query_struct.perform(connection, query_params=prop_values)
+
+
+def cache_get_or_create_with_config(
+    connection: 'Connection', cache_props: dict, query_id=None,
+) -> 'APIResult':
+    """
+    Creates cache with provided configuration. Does nothing if the name
+    is already in use.
+
+    :param connection: connection to Ignite server,
+    :param cache_props: cache configuration properties to create cache with
+     in form of dictionary {property code: python value}.
+     You must supply at least name (PROP_NAME),
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status if cache was created,
+     non-zero status and an error description otherwise.
+    """
+
+    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)
+
+    query_struct = ConfigQuery(
+        OP_CACHE_GET_OR_CREATE_WITH_CONFIGURATION,
+        [
+            ('param_count', Short),
+        ] + list(prop_types.items()),
+        query_id=query_id,
+    )
+    return query_struct.perform(connection, query_params=prop_values)
diff --git a/pyignite/api/key_value.py b/pyignite/api/key_value.py
new file mode 100644
index 0000000..56f5378
--- /dev/null
+++ b/pyignite/api/key_value.py
@@ -0,0 +1,995 @@
+# 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 Iterable, Union
+
+from pyignite.queries.op_codes import *
+from pyignite.datatypes import (
+    Map, Bool, Byte, Int, Long, AnyDataArray, AnyDataObject,
+)
+from pyignite.datatypes.key_value import PeekModes
+from pyignite.queries import Query, Response
+from pyignite.utils import cache_id
+
+
+def cache_put(
+    connection: 'Connection', cache: Union[str, int], key, value,
+    key_hint=None, value_hint=None, binary=False, query_id=None,
+) -> 'APIResult':
+    """
+    Puts a value with a given key to cache (overwriting existing value if any).
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :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.
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status if a value
+     is written, non-zero status and an error description otherwise.
+    """
+
+    query_struct = Query(
+        OP_CACHE_PUT,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('key', key_hint or AnyDataObject),
+            ('value', value_hint or AnyDataObject),
+        ],
+        query_id=query_id,
+    )
+    return query_struct.perform(connection, {
+        'hash_code': cache_id(cache),
+        'flag': 1 if binary else 0,
+        'key': key,
+        'value': value,
+    })
+
+
+def cache_get(
+    connection: 'Connection', cache: Union[str, int], key,
+    key_hint=None, binary=False, query_id=None,
+) -> 'APIResult':
+    """
+    Retrieves a value from cache by key.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :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,
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status and a value
+     retrieved on success, non-zero status and an error description on failure.
+    """
+
+    query_struct = Query(
+        OP_CACHE_GET,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('key', key_hint or AnyDataObject),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'key': key,
+        },
+        response_config=[
+           ('value', AnyDataObject),
+        ],
+    )
+    if result.status != 0:
+        return result
+    result.value = result.value['value']
+    return result
+
+
+def cache_get_all(
+    connection: 'Connection', cache: Union[str, int], keys: Iterable,
+    binary=False, query_id=None,
+) -> 'APIResult':
+    """
+    Retrieves multiple key-value pairs from cache.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :param keys: list of keys or tuples of (key, key_hint),
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :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.
+    """
+
+    query_struct = Query(
+        OP_CACHE_GET_ALL,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('keys', AnyDataArray()),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'keys': keys,
+        },
+        response_config=[
+            ('data', Map),
+        ],
+    )
+    if result.status == 0:
+        result.value = dict(result.value)['data']
+    return result
+
+
+def cache_put_all(
+    connection: 'Connection', cache: Union[str, int], pairs: dict,
+    binary=False, query_id=None,
+) -> 'APIResult':
+    """
+    Puts multiple key-value pairs to cache (overwriting existing associations
+    if any).
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :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),
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status if key-value pairs
+     are written, non-zero status and an error description otherwise.
+    """
+
+    query_struct = Query(
+        OP_CACHE_PUT_ALL,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('data', Map),
+        ],
+        query_id=query_id,
+    )
+    return query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'data': pairs,
+        },
+    )
+
+
+def cache_contains_key(
+    connection: 'Connection', cache: Union[str, int], key,
+    key_hint=None, binary=False, query_id=None,
+) -> 'APIResult':
+    """
+    Returns a value indicating whether given key is present in cache.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :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,
+    :param binary: pass True to keep the value in binary form. False
+     by default,
+    :param query_id: a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :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.
+    """
+
+    query_struct = Query(
+        OP_CACHE_CONTAINS_KEY,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('key', key_hint or AnyDataObject),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+            query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'key': key,
+        },
+        response_config=[
+            ('value', Bool),
+        ],
+    )
+    if result.status == 0:
+        result.value = result.value['value']
+    return result
+
+
+def cache_contains_keys(
+    connection: 'Connection', cache: Union[str, int], keys: Iterable,
+    binary=False, query_id=None,
+) -> 'APIResult':
+    """
+    Returns a value indicating whether all given keys are present in cache.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :param keys: a list of keys or (key, type hint) tuples,
+    :param binary: pass True to keep the value in binary form. False
+     by default,
+    :param query_id: a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :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.
+    """
+
+    query_struct = Query(
+        OP_CACHE_CONTAINS_KEYS,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('keys', AnyDataArray()),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'keys': keys,
+        },
+        response_config=[
+            ('value', Bool),
+        ],
+    )
+    if result.status == 0:
+        result.value = result.value['value']
+    return result
+
+
+def cache_get_and_put(
+    connection: 'Connection', cache: Union[str, int], key, value,
+    key_hint=None, value_hint=None, binary=False, query_id=None,
+) -> 'APIResult':
+    """
+    Puts a value with a given key to cache, 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: name or ID of the cache,
+    :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.
+    :param binary: pass True to keep the value in binary form. False
+     by default,
+    :param query_id: a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :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.
+    """
+
+    query_struct = Query(
+        OP_CACHE_GET_AND_PUT,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('key', key_hint or AnyDataObject),
+            ('value', value_hint or AnyDataObject),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'key': key,
+            'value': value,
+        },
+        response_config=[
+            ('value', AnyDataObject),
+        ],
+    )
+    if result.status == 0:
+        result.value = result.value['value']
+    return result
+
+
+def cache_get_and_replace(
+    connection: 'Connection', cache: Union[str, int], key, value,
+    key_hint=None, value_hint=None, binary=False, query_id=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: name or ID of the cache,
+    :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.
+    :param binary: pass True to keep the value in binary form. False
+     by default,
+    :param query_id: a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status and an old value
+     or None on success, non-zero status and an error description otherwise.
+    """
+
+    query_struct = Query(
+        OP_CACHE_GET_AND_REPLACE, [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('key', key_hint or AnyDataObject),
+            ('value', value_hint or AnyDataObject),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'key': key,
+            'value': value,
+        },
+        response_config=[
+            ('value', AnyDataObject),
+        ],
+    )
+    if result.status == 0:
+        result.value = result.value['value']
+    return result
+
+
+def cache_get_and_remove(
+    connection: 'Connection', cache: Union[str, int], key,
+    key_hint=None, binary=False, query_id=None,
+) -> 'APIResult':
+    """
+    Removes the cache entry with specified key, returning the value.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :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,
+    :param binary: pass True to keep the value in binary form. False
+     by default,
+    :param query_id: a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status and an old value
+     or None, non-zero status and an error description otherwise.
+    """
+
+    query_struct = Query(
+        OP_CACHE_GET_AND_REMOVE, [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('key', key_hint or AnyDataObject),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'key': key,
+        },
+        response_config=[
+            ('value', AnyDataObject),
+        ],
+    )
+    if result.status == 0:
+        result.value = result.value['value']
+    return result
+
+
+def cache_put_if_absent(
+    connection: 'Connection', cache: Union[str, int], key, value,
+    key_hint=None, value_hint=None, binary=False, query_id=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: name or ID of the cache,
+    :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.
+    :param binary: (optional) pass True to keep the value in binary form. False
+     by default,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status on success,
+     non-zero status and an error description otherwise.
+    """
+
+    query_struct = Query(
+        OP_CACHE_PUT_IF_ABSENT,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('key', key_hint or AnyDataObject),
+            ('value', value_hint or AnyDataObject),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'key': key,
+            'value': value,
+        },
+        response_config=[
+            ('success', Bool),
+        ],
+    )
+    if result.status == 0:
+        result.value = result.value['success']
+    return result
+
+
+def cache_get_and_put_if_absent(
+    connection: 'Connection', cache: Union[str, int], key, value,
+    key_hint=None, value_hint=None, binary=False, query_id=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: name or ID of the cache,
+    :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.
+    :param binary: (optional) pass True to keep the value in binary form. False
+     by default,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status and an old value
+     or None on success, non-zero status and an error description otherwise.
+    """
+
+    query_struct = Query(
+        OP_CACHE_GET_AND_PUT_IF_ABSENT,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('key', key_hint or AnyDataObject),
+            ('value', value_hint or AnyDataObject),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'key': key,
+            'value': value,
+        },
+        response_config=[
+            ('value', AnyDataObject),
+        ],
+    )
+    if result.status == 0:
+        result.value = result.value['value']
+    return result
+
+
+def cache_replace(
+    connection: 'Connection', cache: Union[str, int], key, value,
+    key_hint=None, value_hint=None, binary=False, query_id=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: name or ID of the cache,
+    :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.
+    :param binary: pass True to keep the value in binary form. False
+     by default,
+    :param query_id: a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :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.
+    """
+
+    query_struct = Query(
+        OP_CACHE_REPLACE,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('key', key_hint or AnyDataObject),
+            ('value', value_hint or AnyDataObject),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'key': key,
+            'value': value,
+        },
+        response_config=[
+            ('success', Bool),
+        ],
+    )
+    if result.status == 0:
+        result.value = result.value['success']
+    return result
+
+
+def cache_replace_if_equals(
+    connection: 'Connection', cache: Union[str, int], key, sample, value,
+    key_hint=None, sample_hint=None, value_hint=None,
+    binary=False, query_id=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: name or ID of the cache,
+    :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,
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned
+     as-is in response.query_id. When the parameter is omitted, a random
+     value is generated,
+    :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.
+    """
+
+    query_struct = Query(
+        OP_CACHE_REPLACE_IF_EQUALS,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('key', key_hint or AnyDataObject),
+            ('sample', sample_hint or AnyDataObject),
+            ('value', value_hint or AnyDataObject),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'key': key,
+            'sample': sample,
+            'value': value,
+        },
+        response_config=[
+            ('success', Bool),
+        ],
+    )
+    if result.status == 0:
+        result.value = result.value['success']
+    return result
+
+
+def cache_clear(
+    connection: 'Connection', cache: Union[str, int], binary=False,
+    query_id=None,
+) -> 'APIResult':
+    """
+    Clears the cache without notifying listeners or cache writers.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned
+     as-is in response.query_id. When the parameter is omitted, a random
+     value is generated,
+    :return: API result data object. Contains zero status on success,
+     non-zero status and an error description otherwise.
+    """
+
+    query_struct = Query(
+        OP_CACHE_CLEAR,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+        ],
+        query_id=query_id,
+    )
+    return query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+        },
+    )
+
+
+def cache_clear_key(
+    connection: 'Connection', cache: Union[str, int], key,
+    key_hint: object=None, binary=False, query_id=None,
+) -> 'APIResult':
+    """
+    Clears the cache key without notifying listeners or cache writers.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :param key:  key for the cache entry,
+    :param key_hint: (optional) Ignite data type, for which the given key
+     should be converted,
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned
+     as-is in response.query_id. When the parameter is omitted, a random
+     value is generated,
+    :return: API result data object. Contains zero status on success,
+     non-zero status and an error description otherwise.
+    """
+
+    query_struct = Query(
+        OP_CACHE_CLEAR_KEY,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('key', key_hint or AnyDataObject),
+        ],
+        query_id=query_id,
+    )
+    return query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'key': key,
+        },
+    )
+
+
+def cache_clear_keys(
+    connection: 'Connection', cache: Union[str, int], keys: list,
+    binary=False, query_id=None,
+) -> 'APIResult':
+    """
+    Clears the cache keys without notifying listeners or cache writers.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :param keys: list of keys or tuples of (key, key_hint),
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status on success,
+     non-zero status and an error description otherwise.
+    """
+
+    query_struct = Query(
+        OP_CACHE_CLEAR_KEYS,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('keys', AnyDataArray()),
+        ],
+        query_id=query_id,
+    )
+    return query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'keys': keys,
+        },
+    )
+
+
+def cache_remove_key(
+    connection: 'Connection', cache: Union[str, int], key,
+    key_hint: object=None, binary=False, query_id=None,
+) -> 'APIResult':
+    """
+    Clears the cache key without notifying listeners or cache writers.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :param key:  key for the cache entry,
+    :param key_hint: (optional) Ignite data type, for which the given key
+     should be converted,
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned
+     as-is in response.query_id. When the parameter is omitted, a random
+     value is generated,
+    :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.
+    """
+
+    query_struct = Query(
+        OP_CACHE_REMOVE_KEY,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('key', key_hint or AnyDataObject),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'key': key,
+        },
+        response_config=[
+            ('success', Bool),
+        ],
+    )
+    if result.status == 0:
+        result.value = result.value['success']
+    return result
+
+
+def cache_remove_if_equals(
+    connection: 'Connection', cache: Union[str, int], key, sample,
+    key_hint=None, sample_hint=None,
+    binary=False, query_id=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: name or ID of the cache,
+    :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
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned
+     as-is in response.query_id. When the parameter is omitted, a random
+     value is generated,
+    :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.
+    """
+
+    query_struct = Query(
+        OP_CACHE_REMOVE_IF_EQUALS,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('key', key_hint or AnyDataObject),
+            ('sample', sample_hint or AnyDataObject),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'key': key,
+            'sample': sample,
+        },
+        response_config=[
+            ('success', Bool),
+        ],
+    )
+    if result.status == 0:
+        result.value = result.value['success']
+    return result
+
+
+def cache_remove_keys(
+    connection: 'Connection', cache: Union[str, int], keys: Iterable,
+    binary=False, query_id=None,
+) -> 'APIResult':
+    """
+    Removes entries with given keys, notifying listeners and cache writers.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :param keys: list of keys or tuples of (key, key_hint),
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status on success,
+     non-zero status and an error description otherwise.
+    """
+
+    query_struct = Query(
+        OP_CACHE_REMOVE_KEYS,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('keys', AnyDataArray()),
+        ],
+        query_id=query_id,
+    )
+    return query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'keys': keys,
+        },
+    )
+
+
+def cache_remove_all(
+    connection: 'Connection', cache: Union[str, int], binary=False,
+    query_id=None,
+) -> 'APIResult':
+    """
+    Removes all entries from cache, notifying listeners and cache writers.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status on success,
+     non-zero status and an error description otherwise.
+    """
+
+    query_struct = Query(
+        OP_CACHE_REMOVE_ALL,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+        ],
+        query_id=query_id,
+    )
+    return query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+        },
+    )
+
+
+def cache_get_size(
+    connection: 'Connection', cache: Union[str, int], peek_modes=0,
+    binary=False, query_id=None,
+) -> 'APIResult':
+    """
+    Gets the number of entries in cache.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :param peek_modes: (optional) limit count to near cache partition
+     (PeekModes.NEAR), primary cache (PeekModes.PRIMARY), or backup cache
+     (PeekModes.BACKUP). Defaults to all cache partitions (PeekModes.ALL),
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status and a number of
+     cache entries on success, non-zero status and an error description
+     otherwise.
+    """
+    if not isinstance(peek_modes, (list, tuple)):
+        if peek_modes == 0:
+            peek_modes = []
+        else:
+            peek_modes = [peek_modes]
+
+    query_struct = Query(
+        OP_CACHE_GET_SIZE,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('peek_modes', PeekModes),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'peek_modes': peek_modes,
+        },
+        response_config=[
+            ('count', Long),
+        ],
+    )
+    if result.status == 0:
+        result.value = result.value['count']
+    return result
diff --git a/pyignite/api/result.py b/pyignite/api/result.py
new file mode 100644
index 0000000..864ef61
--- /dev/null
+++ b/pyignite/api/result.py
@@ -0,0 +1,38 @@
+# 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 pyignite.datatypes import String
+
+
+class APIResult:
+    """
+    Dataclass which represents the result of API request.
+
+    Fields are:
+
+    * status: request status code. 0 if successful,
+    * message: 'Success' if status == 0, verbatim error description
+      otherwise,
+    * value: return value or None.
+    """
+
+    message = 'Success'
+    value = None
+
+    def __init__(self, response: 'Response'):
+        self.status = response.status_code
+        self.query_id = response.query_id
+        if hasattr(response, 'error_message'):
+            self.message = String.to_python(response.error_message)
diff --git a/pyignite/api/sql.py b/pyignite/api/sql.py
new file mode 100644
index 0000000..f2f96fc
--- /dev/null
+++ b/pyignite/api/sql.py
@@ -0,0 +1,478 @@
+# 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.
+
+"""
+Only key-value queries (scan queries) are implemented. SQL part is still
+in progress.
+"""
+
+from typing import Union
+
+from pyignite.datatypes import (
+    AnyDataArray, AnyDataObject, Bool, Byte, Int, Long, Map, Null, String,
+    StructArray,
+)
+from pyignite.datatypes.sql import StatementType
+from pyignite.queries import Query, Response, SQLResponse
+from pyignite.queries.op_codes import *
+from pyignite.utils import cache_id
+from .result import APIResult
+
+
+def scan(
+    connection: 'Connection', cache: Union[str, int], page_size: int,
+    partitions: int=-1, local: bool=False, binary: bool=False, query_id=None,
+) -> APIResult:
+    """
+    Performs scan query.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :param page_size: cursor page size,
+    :param partitions: (optional) number of partitions to query
+     (negative to query entire cache),
+    :param local: (optional) pass True if this query should be executed
+     on local node only. Defaults to False,
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status and a value
+     of type dict with results on success, non-zero status and an error
+     description otherwise.
+
+     Value dict is of following format:
+
+     * `cursor`: int, cursor ID,
+     * `data`: dict, result rows as key-value pairs,
+     * `more`: bool, True if more data is available for subsequent
+       ‘scan_cursor_get_page’ calls.
+    """
+
+    query_struct = Query(
+        OP_QUERY_SCAN,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('filter', Null),
+            ('page_size', Int),
+            ('partitions', Int),
+            ('local', Bool),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'filter': None,
+            'page_size': page_size,
+            'partitions': partitions,
+            'local': 1 if local else 0,
+        },
+        response_config=[
+            ('cursor', Long),
+            ('data', Map),
+            ('more', Bool),
+        ],
+    )
+    if result.status == 0:
+        result.value = dict(result.value)
+    return result
+
+
+def scan_cursor_get_page(
+    connection: 'Connection', cursor: int, query_id=None,
+) -> APIResult:
+    """
+    Fetches the next scan query cursor page by cursor ID that is obtained
+    from `scan` function.
+
+    :param connection: connection to Ignite server,
+    :param cursor: cursor ID,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status and a value
+     of type dict with results on success, non-zero status and an error
+     description otherwise.
+
+     Value dict is of following format:
+
+     * `data`: dict, result rows as key-value pairs,
+     * `more`: bool, True if more data is available for subsequent
+       ‘scan_cursor_get_page’ calls.
+    """
+
+    query_struct = Query(
+        OP_QUERY_SCAN_CURSOR_GET_PAGE,
+        [
+            ('cursor', Long),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'cursor': cursor,
+        },
+        response_config=[
+            ('data', Map),
+            ('more', Bool),
+        ],
+    )
+    if result.status == 0:
+        result.value = dict(result.value)
+    return result
+
+
+def sql(
+    connection: 'Connection', cache: Union[str, int],
+    table_name: str, query_str: str, page_size: int, query_args=None,
+    distributed_joins: bool=False, replicated_only: bool=False,
+    local: bool=False, timeout: int=0, binary: bool=False, query_id=None
+) -> APIResult:
+    """
+    Executes an SQL query over data stored in the cluster. The query returns
+    the whole record (key and value).
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :param table_name: name of a type or SQL table,
+    :param query_str: SQL query string,
+    :param page_size: cursor page size,
+    :param query_args: (optional) query arguments,
+    :param distributed_joins: (optional) distributed joins. Defaults to False,
+    :param replicated_only: (optional) whether query contains only replicated
+     tables or not. Defaults to False,
+    :param local: (optional) pass True if this query should be executed
+     on local node only. Defaults to False,
+    :param timeout: (optional) non-negative timeout value in ms. Zero disables
+     timeout (default),
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status and a value
+     of type dict with results on success, non-zero status and an error
+     description otherwise.
+
+     Value dict is of following format:
+
+     * `cursor`: int, cursor ID,
+     * `data`: dict, result rows as key-value pairs,
+     * `more`: bool, True if more data is available for subsequent
+       ‘sql_get_page’ calls.
+    """
+
+    if query_args is None:
+        query_args = []
+
+    query_struct = Query(
+        OP_QUERY_SQL,
+        [
+            ('hash_code', Int),
+            ('flag', Byte),
+            ('table_name', String),
+            ('query_str', String),
+            ('query_args', AnyDataArray()),
+            ('distributed_joins', Bool),
+            ('local', Bool),
+            ('replicated_only', Bool),
+            ('page_size', Int),
+            ('timeout', Long),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'hash_code': cache_id(cache),
+            'flag': 1 if binary else 0,
+            'table_name': table_name,
+            'query_str': query_str,
+            'query_args': query_args,
+            'distributed_joins': 1 if distributed_joins else 0,
+            'local': 1 if local else 0,
+            'replicated_only': 1 if replicated_only else 0,
+            'page_size': page_size,
+            'timeout': timeout,
+        },
+        response_config=[
+            ('cursor', Long),
+            ('data', Map),
+            ('more', Bool),
+        ],
+    )
+    if result.status == 0:
+        result.value = dict(result.value)
+    return result
+
+
+def sql_cursor_get_page(
+    connection: 'Connection', cursor: int, query_id=None,
+) -> APIResult:
+    """
+    Retrieves the next SQL query cursor page by cursor ID from `sql`.
+
+    :param connection: connection to Ignite server,
+    :param cursor: cursor ID,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status and a value
+     of type dict with results on success, non-zero status and an error
+     description otherwise.
+
+     Value dict is of following format:
+
+     * `data`: dict, result rows as key-value pairs,
+     * `more`: bool, True if more data is available for subsequent
+       ‘sql_cursor_get_page’ calls.
+    """
+
+    query_struct = Query(
+        OP_QUERY_SQL_CURSOR_GET_PAGE,
+        [
+            ('cursor', Long),
+        ],
+        query_id=query_id,
+    )
+    result = query_struct.perform(
+        connection,
+        query_params={
+            'cursor': cursor,
+        },
+        response_config=[
+            ('data', Map),
+            ('more', Bool),
+        ],
+    )
+    if result.status == 0:
+        result.value = dict(result.value)
+    return result
+
+
+def sql_fields(
+    connection: 'Connection', cache: Union[str, int],
+    query_str: str, page_size: int, query_args=None, schema: str=None,
+    statement_type: int=StatementType.ANY, distributed_joins: bool=False,
+    local: bool=False, replicated_only: bool=False,
+    enforce_join_order: bool=False, collocated: bool=False, lazy: bool=False,
+    include_field_names: bool=False, max_rows: int=-1, timeout: int=0,
+    binary: bool=False, query_id=None
+) -> APIResult:
+    """
+    Performs SQL fields query.
+
+    :param connection: connection to Ignite server,
+    :param cache: name or ID of the cache,
+    :param query_str: SQL query string,
+    :param page_size: cursor page size,
+    :param query_args: (optional) query arguments. List of values or
+     (value, type hint) tuples,
+    :param schema: (optional) schema for the query. Defaults to `PUBLIC`,
+    :param statement_type: (optional) statement type. Can be:
+
+     * StatementType.ALL − any type (default),
+     * StatementType.SELECT − select,
+     * StatementType.UPDATE − update.
+
+    :param distributed_joins: (optional) distributed joins. Defaults to False,
+    :param local: (optional) pass True if this query should be executed
+     on local node only. Defaults to False,
+    :param replicated_only: (optional) whether query contains only
+     replicated tables or not. Defaults to False,
+    :param enforce_join_order: (optional) enforce join order. Defaults
+     to False,
+    :param collocated: (optional) whether your data is co-located or not.
+     Defaults to False,
+    :param lazy: (optional) lazy query execution. Defaults to False,
+    :param include_field_names: (optional) include field names in result.
+     Defaults to False,
+    :param max_rows: (optional) query-wide maximum of rows. Defaults to -1
+     (all rows),
+    :param timeout: (optional) non-negative timeout value in ms. Zero disables
+     timeout (default),
+    :param binary: (optional) pass True to keep the value in binary form.
+     False by default,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status and a value
+     of type dict with results on success, non-zero status and an error
+     description otherwise.
+
+     Value dict is of following format:
+
+     * `cursor`: int, cursor ID,
+     * `data`: list, result values,
+     * `more`: bool, True if more data is available for subsequent
+       ‘sql_fields_cursor_get_page’ calls.
+    """
+    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,
+    )
+
+    _, send_buffer = query_struct.from_python({
+        '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,
+    })
+
+    connection.send(send_buffer)
+
+    response_struct = SQLResponse(
+        include_field_names=include_field_names,
+        has_cursor=True,
+    )
+    response_class, recv_buffer = response_struct.parse(connection)
+    response = response_class.from_buffer_copy(recv_buffer)
+
+    result = APIResult(response)
+    if result.status != 0:
+        return result
+    result.value = response_struct.to_python(response)
+    return result
+
+
+def sql_fields_cursor_get_page(
+    connection: 'Connection', cursor: int, field_count: int, query_id=None,
+) -> APIResult:
+    """
+    Retrieves the next query result page by cursor ID from `sql_fields`.
+
+    :param connection: connection to Ignite server,
+    :param cursor: cursor ID,
+    :param field_count: a number of fields in a row,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status and a value
+     of type dict with results on success, non-zero status and an error
+     description otherwise.
+
+     Value dict is of following format:
+
+     * `data`: list, result values,
+     * `more`: bool, True if more data is available for subsequent
+       ‘sql_fields_cursor_get_page’ calls.
+    """
+
+    query_struct = Query(
+        OP_QUERY_SQL_FIELDS_CURSOR_GET_PAGE,
+        [
+            ('cursor', Long),
+        ],
+        query_id=query_id,
+    )
+
+    _, send_buffer = query_struct.from_python({
+        'cursor': cursor,
+    })
+
+    connection.send(send_buffer)
+
+    response_struct = Response([
+        ('data', StructArray([
+            ('field_{}'.format(i), AnyDataObject) for i in range(field_count)
+        ])),
+        ('more', Bool),
+    ])
+    response_class, recv_buffer = response_struct.parse(connection)
+    response = response_class.from_buffer_copy(recv_buffer)
+
+    result = APIResult(response)
+    if result.status != 0:
+        return result
+    value = response_struct.to_python(response)
+    result.value = {
+        'data': [],
+        'more': value['more']
+    }
+    for row_dict in value['data']:
+        row = []
+        for field_key in sorted(row_dict.keys()):
+            row.append(row_dict[field_key])
+        result.value['data'].append(row)
+    return result
+
+
+def resource_close(
+    connection: 'Connection', cursor: int, query_id=None
+) -> APIResult:
+    """
+    Closes a resource, such as query cursor.
+
+    :param connection: connection to Ignite server,
+    :param cursor: cursor ID,
+    :param query_id: (optional) a value generated by client and returned as-is
+     in response.query_id. When the parameter is omitted, a random value
+     is generated,
+    :return: API result data object. Contains zero status on success,
+     non-zero status and an error description otherwise.
+    """
+
+    query_struct = Query(
+        OP_RESOURCE_CLOSE,
+        [
+            ('cursor', Long),
+        ],
+        query_id=query_id,
+    )
+    return query_struct.perform(
+        connection,
+        query_params={
+            'cursor': cursor,
+        },
+    )
diff --git a/pyignite/binary.py b/pyignite/binary.py
new file mode 100644
index 0000000..e726730
--- /dev/null
+++ b/pyignite/binary.py
@@ -0,0 +1,136 @@
+# 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.
+
+"""
+:class:`~pyignite.binary.GenericObjectMeta` is a metaclass used to create
+classes, which objects serve as a native Python values for Ignite Complex
+object data type. You can use this metaclass with your existing classes
+to save and restore their selected attributes and properties to/from
+Ignite caches. It is also used internally by `pyignite` to create simple
+data classes “on the fly” when retrieving arbitrary Complex objects.
+
+You can get the examples of using Complex objects in the
+:ref:`complex_object_usage` section of `pyignite` documentation.
+"""
+
+from collections import OrderedDict
+from typing import Any
+
+import attr
+
+from .datatypes import *
+from .exceptions import ParseError
+from .utils import entity_id, schema_id
+
+
+ALLOWED_FIELD_TYPES = [
+    Null, ByteObject, ShortObject, IntObject, LongObject, FloatObject,
+    DoubleObject, CharObject, BoolObject, UUIDObject, DateObject,
+    TimestampObject, TimeObject, EnumObject, BinaryEnumObject,
+    ByteArrayObject, ShortArrayObject, IntArrayObject, LongArrayObject,
+    FloatArrayObject, DoubleArrayObject, CharArrayObject, BoolArrayObject,
+    UUIDArrayObject, DateArrayObject, TimestampArrayObject,
+    TimeArrayObject, EnumArrayObject, String, StringArrayObject,
+    DecimalObject, DecimalArrayObject, ObjectArrayObject, CollectionObject,
+    MapObject, BinaryObject, WrappedDataObject,
+]
+
+
+class GenericObjectPropsMixin:
+    """
+    This class is mixed both to metaclass and to resulting class to make class
+    properties universally available. You should not subclass it directly.
+    """
+    @property
+    def type_name(self) -> str:
+        """ Binary object type name. """
+        return self._type_name
+
+    @property
+    def type_id(self) -> int:
+        """ Binary object type ID. """
+        return entity_id(self._type_name)
+
+    @property
+    def schema(self) -> OrderedDict:
+        """ Binary object schema. """
+        return self._schema.copy()
+
+    @property
+    def schema_id(self) -> int:
+        """ Binary object schema ID. """
+        return schema_id(self._schema)
+
+    def __new__(cls, *args, **kwargs) -> Any:
+        # allow all items in Binary Object schema to be populated as optional
+        # arguments to `__init__()` with sensible defaults.
+        if cls is not GenericObjectMeta:
+            attributes = {
+                k: attr.ib(
+                    type=getattr(v, 'pythonic', type(None)),
+                    default=getattr(v, 'default', None),
+                ) for k, v in cls.schema.items()
+            }
+            attributes.update({'version': attr.ib(type=int, default=1)})
+            cls = attr.s(cls, these=attributes)
+        # skip parameters
+        return super().__new__(cls)
+
+
+class GenericObjectMeta(type, GenericObjectPropsMixin):
+    """
+    Complex (or Binary) Object metaclass. It is aimed to help user create
+    classes, which objects could serve as a pythonic representation of the
+    :class:`~pyignite.datatypes.complex.BinaryObject` Ignite data type.
+    """
+    _schema = None
+    _type_name = None
+    version = None
+
+    def __new__(
+        mcs: Any, name: str, base_classes: tuple, namespace: dict, **kwargs
+    ) -> Any:
+        """ Sort out class creation arguments. """
+        return super().__new__(
+            mcs, name, (GenericObjectPropsMixin, )+base_classes, namespace
+        )
+
+    @staticmethod
+    def _validate_schema(schema: dict):
+        for field_type in schema.values():
+            if field_type not in ALLOWED_FIELD_TYPES:
+                raise ParseError(
+                    'Wrong binary field type: {}'.format(field_type)
+                )
+
+    def __init__(
+        cls, name: str, base_classes: tuple, namespace: dict,
+        type_name: str=None, schema: OrderedDict=None, **kwargs
+    ):
+        """
+        Initializes binary object class.
+
+        :param type_name: (optional) binary object name. Defaults to class
+         name,
+        :param schema: (optional) a dict of field names: field types,
+        :raise: ParseError if one or more binary field types
+         did not recognized.
+        """
+        cls._type_name = type_name or cls.__name__
+        cls._type_id = entity_id(cls._type_name)
+        schema = schema or OrderedDict()
+        cls._validate_schema(schema)
+        cls._schema = schema
+        super().__init__(name, base_classes, namespace)
diff --git a/pyignite/cache.py b/pyignite/cache.py
new file mode 100644
index 0000000..6cd7377
--- /dev/null
+++ b/pyignite/cache.py
@@ -0,0 +1,595 @@
+# 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, Optional, Union
+
+from .datatypes import prop_codes
+from .exceptions import (
+    CacheCreationError, CacheError, ParameterError, SQLError,
+)
+from .utils import cache_id, is_wrapped, status_to_exception, unwrap_binary
+from .api.cache_config import (
+    cache_create, cache_create_with_config,
+    cache_get_or_create, cache_get_or_create_with_config,
+    cache_destroy, cache_get_configuration,
+)
+from .api.key_value import (
+    cache_get, cache_put, cache_get_all, cache_put_all, cache_replace,
+    cache_clear, cache_clear_key, cache_clear_keys,
+    cache_contains_key, cache_contains_keys,
+    cache_get_and_put, cache_get_and_put_if_absent, cache_put_if_absent,
+    cache_get_and_remove, cache_get_and_replace,
+    cache_remove_key, cache_remove_keys, cache_remove_all,
+    cache_remove_if_equals, cache_replace_if_equals, cache_get_size,
+)
+from .api.sql import scan, scan_cursor_get_page, sql, sql_cursor_get_page
+
+
+PROP_CODES = set([
+    getattr(prop_codes, x)
+    for x in dir(prop_codes)
+    if x.startswith('PROP_')
+])
+CACHE_CREATE_FUNCS = {
+    True: {
+        True: cache_get_or_create_with_config,
+        False: cache_create_with_config,
+    },
+    False: {
+        True: cache_get_or_create,
+        False: cache_create,
+    },
+}
+
+
+class Cache:
+    """
+    Ignite cache abstraction. Users should never use this class directly,
+    but construct its instances with
+    :py:meth:`~pyignite.client.Client.create_cache`,
+    :py:meth:`~pyignite.client.Client.get_or_create_cache` or
+    :py:meth:`~pyignite.client.Client.get_cache` methods instead. See
+    :ref:`this example <create_cache>` on how to do it.
+    """
+    _cache_id = None
+    _name = None
+    _client = None
+    _settings = None
+
+    @staticmethod
+    def _validate_settings(
+        settings: Union[str, dict]=None, get_only: bool=False,
+    ):
+        if any([
+            not settings,
+            type(settings) not in (str, dict),
+            type(settings) is dict and prop_codes.PROP_NAME not in settings,
+        ]):
+            raise ParameterError('You should supply at least cache name')
+
+        if all([
+            type(settings) is dict,
+            not set(settings).issubset(PROP_CODES),
+        ]):
+            raise ParameterError('One or more settings was not recognized')
+
+        if get_only and type(settings) is dict and len(settings) != 1:
+            raise ParameterError('Only cache name allowed as a parameter')
+
+    def __init__(
+        self, client: 'Client', settings: Union[str, dict]=None,
+        with_get: bool=False, get_only: bool=False,
+    ):
+        """
+        Initialize cache object.
+
+        :param client: Ignite client,
+        :param settings: cache settings. Can be a string (cache name) or a dict
+         of cache properties and their values. In this case PROP_NAME is
+         mandatory,
+        :param with_get: (optional) do not raise exception, if the cache
+         is already exists. Defaults to False,
+        :param get_only: (optional) do not communicate with Ignite server
+         at all, only create Cache instance. Defaults to False.
+        """
+        self._client = client
+        self._validate_settings(settings)
+        if type(settings) == str:
+            self._name = settings
+        else:
+            self._name = settings[prop_codes.PROP_NAME]
+
+        if not get_only:
+            func = CACHE_CREATE_FUNCS[type(settings) is dict][with_get]
+            result = func(client, settings)
+            if result.status != 0:
+                raise CacheCreationError(result.message)
+
+        self._cache_id = cache_id(self._name)
+
+    @property
+    def settings(self) -> Optional[dict]:
+        """
+        Lazy Cache settings. See the :ref:`example <sql_cache_read>`
+        of reading this property.
+
+        All cache properties are documented here: :ref:`cache_props`.
+
+        :return: dict of cache properties and their values.
+        """
+        if self._settings is None:
+            config_result = cache_get_configuration(self._client, self._cache_id)
+            if config_result.status == 0:
+                self._settings = config_result.value
+            else:
+                raise CacheError(config_result.message)
+
+        return self._settings
+
+    @property
+    def name(self) -> str:
+        """
+        Lazy cache name.
+
+        :return: cache name string.
+        """
+        if self._name is None:
+            self._name = self.settings[prop_codes.PROP_NAME]
+
+        return self._name
+
+    @property
+    def client(self) -> 'Client':
+        """
+        Ignite :class:`~pyignite.client.Client` object.
+
+        :return: Client object, through which the cache is accessed.
+        """
+        return self._client
+
+    @property
+    def cache_id(self) -> int:
+        """
+        Cache ID.
+
+        :return: integer value of the cache ID.
+        """
+        return self._cache_id
+
+    def _process_binary(self, value: Any) -> Any:
+        """
+        Detects and recursively unwraps Binary Object.
+
+        :param value: anything that could be a Binary Object,
+        :return: the result of the Binary Object unwrapping with all other data
+         left intact.
+        """
+        if is_wrapped(value):
+            return unwrap_binary(self._client, value)
+        return value
+
+    @status_to_exception(CacheError)
+    def destroy(self):
+        """
+        Destroys cache with a given name.
+        """
+        return cache_destroy(self._client, self._cache_id)
+
+    @status_to_exception(CacheError)
+    def get(self, key, key_hint: object=None) -> Any:
+        """
+        Retrieves a value from cache by key.
+
+        :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: value retrieved.
+        """
+        result = cache_get(self._client, self._cache_id, key, key_hint=key_hint)
+        result.value = self._process_binary(result.value)
+        return result
+
+    @status_to_exception(CacheError)
+    def put(self, key, value, key_hint: object=None, value_hint: object=None):
+        """
+        Puts a value with a given key to cache (overwriting existing value
+        if any).
+
+        :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 cache_put(
+            self._client, self._cache_id, key, value,
+            key_hint=key_hint, value_hint=value_hint
+        )
+
+    @status_to_exception(CacheError)
+    def get_all(self, keys: list) -> list:
+        """
+        Retrieves multiple key-value pairs from cache.
+
+        :param keys: list of keys or tuples of (key, key_hint),
+        :return: a dict of key-value pairs.
+        """
+        result = cache_get_all(self._client, self._cache_id, keys)
+        if result.value:
+            for key, value in result.value.items():
+                result.value[key] = self._process_binary(value)
+        return result
+
+    @status_to_exception(CacheError)
+    def put_all(self, pairs: dict):
+        """
+        Puts multiple key-value pairs to cache (overwriting existing
+        associations if any).
+
+        :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 cache_put_all(self._client, self._cache_id, pairs)
+
+    @status_to_exception(CacheError)
+    def replace(
+        self, key, value, key_hint: object=None, value_hint: object=None
+    ):
+        """
+        Puts a value with a given key to cache only if the key already exist.
+
+        :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.
+        """
+        result = cache_replace(
+            self._client, self._cache_id, key, value,
+            key_hint=key_hint, value_hint=value_hint
+        )
+        result.value = self._process_binary(result.value)
+        return result
+
+    @status_to_exception(CacheError)
+    def clear(self, keys: Optional[list]=None):
+        """
+        Clears the cache without notifying listeners or cache writers.
+
+        :param keys: (optional) list of cache keys or (key, key type
+         hint) tuples to clear (default: clear all).
+        """
+        if keys:
+            return cache_clear_keys(self._client, self._cache_id, keys)
+        else:
+            return cache_clear(self._client, self._cache_id)
+
+    @status_to_exception(CacheError)
+    def clear_key(self, key, key_hint: object=None):
+        """
+        Clears the cache key without notifying listeners or cache writers.
+
+        :param key: key for the cache entry,
+        :param key_hint: (optional) Ignite data type, for which the given key
+         should be converted,
+        """
+        return cache_clear_key(
+            self._client, self._cache_id, key, key_hint=key_hint
+        )
+
+    @status_to_exception(CacheError)
+    def contains_key(self, key, key_hint=None) -> bool:
+        """
+        Returns a value indicating whether given key is present in cache.
+
+        :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: boolean `True` when key is present, `False` otherwise.
+        """
+        return cache_contains_key(
+            self._client, self._cache_id, key, key_hint=key_hint
+        )
+
+    @status_to_exception(CacheError)
+    def contains_keys(self, keys: Iterable) -> bool:
+        """
+        Returns a value indicating whether all given keys are present in cache.
+
+        :param keys: a list of keys or (key, type hint) tuples,
+        :return: boolean `True` when all keys are present, `False` otherwise.
+        """
+        return cache_contains_keys(self._client, self._cache_id, keys)
+
+    @status_to_exception(CacheError)
+    def get_and_put(self, key, value, key_hint=None, value_hint=None) -> Any:
+        """
+        Puts a value with a given key to cache, and returns the previous value
+        for that key, or null value if there was not such key.
+
+        :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: old value or None.
+        """
+        result = cache_get_and_put(
+            self._client, self._cache_id, key, value, key_hint, value_hint
+        )
+        result.value = self._process_binary(result.value)
+        return result
+
+    @status_to_exception(CacheError)
+    def get_and_put_if_absent(
+        self, key, value, key_hint=None, value_hint=None
+    ):
+        """
+        Puts a value with a given key to cache only if the key does not
+        already exist.
+
+        :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: old value or None.
+        """
+        result = cache_get_and_put_if_absent(
+            self._client, self._cache_id, key, value, key_hint, value_hint
+        )
+        result.value = self._process_binary(result.value)
+        return result
+
+    @status_to_exception(CacheError)
+    def put_if_absent(self, key, value, key_hint=None, value_hint=None):
+        """
+        Puts a value with a given key to cache only if the key does not
+        already exist.
+
+        :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 cache_put_if_absent(
+            self._client, self._cache_id, key, value, key_hint, value_hint
+        )
+
+    @status_to_exception(CacheError)
+    def get_and_remove(self, key, key_hint=None) -> Any:
+        """
+        Removes the cache entry with specified key, returning the value.
+
+        :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: old value or None.
+        """
+        result = cache_get_and_remove(
+            self._client, self._cache_id, key, key_hint
+        )
+        result.value = self._process_binary(result.value)
+        return result
+
+    @status_to_exception(CacheError)
+    def get_and_replace(
+        self, key, value, key_hint=None, value_hint=None
+    ) -> Any:
+        """
+        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 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: old value or None.
+        """
+        result = cache_get_and_replace(
+            self._client, self._cache_id, key, value, key_hint, value_hint
+        )
+        result.value = self._process_binary(result.value)
+        return result
+
+    @status_to_exception(CacheError)
+    def remove_key(self, key, key_hint=None):
+        """
+        Clears the cache key without notifying listeners or cache writers.
+
+        :param key: key for the cache entry,
+        :param key_hint: (optional) Ignite data type, for which the given key
+         should be converted,
+        """
+        return cache_remove_key(self._client, self._cache_id, key, key_hint)
+
+    @status_to_exception(CacheError)
+    def remove_keys(self, keys: list):
+        """
+        Removes cache entries by given list of keys, notifying listeners
+        and cache writers.
+
+        :param keys: list of keys or tuples of (key, key_hint) to remove.
+        """
+        return cache_remove_keys(self._client, self._cache_id, keys)
+
+    @status_to_exception(CacheError)
+    def remove_all(self):
+        """
+        Removes all cache entries, notifying listeners and cache writers.
+        """
+        return cache_remove_all(self._client, self._cache_id)
+
+    @status_to_exception(CacheError)
+    def remove_if_equals(self, key, sample, key_hint=None, sample_hint=None):
+        """
+        Removes an entry with a given key if provided value is equal to
+        actual value, notifying listeners and cache writers.
+
+        :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 cache_remove_if_equals(
+            self._client, self._cache_id, key, sample, key_hint, sample_hint
+        )
+
+    @status_to_exception(CacheError)
+    def replace_if_equals(
+        self, key, sample, value,
+        key_hint=None, sample_hint=None, value_hint=None
+    ) -> Any:
+        """
+        Puts a value with a given key to cache only if the key already exists
+        and value equals provided sample.
+
+        :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: boolean `True` when key is present, `False` otherwise.
+        """
+        result = cache_replace_if_equals(
+            self._client, self._cache_id, key, sample, value,
+            key_hint, sample_hint, value_hint
+        )
+        result.value = self._process_binary(result.value)
+        return result
+
+    @status_to_exception(CacheError)
+    def get_size(self, peek_modes=0):
+        """
+        Gets the number of entries in cache.
+
+        :param peek_modes: (optional) limit count to near cache partition
+         (PeekModes.NEAR), primary cache (PeekModes.PRIMARY), or backup cache
+         (PeekModes.BACKUP). Defaults to all cache partitions (PeekModes.ALL),
+        :return: integer number of cache entries.
+        """
+        return cache_get_size(self._client, self._cache_id, peek_modes)
+
+    def scan(self, page_size: int=1, partitions: int=-1, local: bool=False):
+        """
+        Returns all key-value pairs from the cache, similar to `get_all`, but
+        with internal pagination, which is slower, but safer.
+
+        :param page_size: (optional) page size. Default size is 1 (slowest
+         and safest),
+        :param partitions: (optional) number of partitions to query
+         (negative to query entire cache),
+        :param local: (optional) pass True if this query should be executed
+         on local node only. Defaults to False,
+        :return: generator with key-value pairs.
+        """
+        result = scan(self._client, self._cache_id, page_size, partitions, local)
+        if result.status != 0:
+            raise CacheError(result.message)
+
+        cursor = result.value['cursor']
+        for k, v in result.value['data'].items():
+            k = self._process_binary(k)
+            v = self._process_binary(v)
+            yield k, v
+
+        while result.value['more']:
+            result = scan_cursor_get_page(self._client, cursor)
+            if result.status != 0:
+                raise CacheError(result.message)
+
+            for k, v in result.value['data'].items():
+                k = self._process_binary(k)
+                v = self._process_binary(v)
+                yield k, v
+
+    def select_row(
+        self, query_str: str, page_size: int=1,
+        query_args: Optional[list]=None, distributed_joins: bool=False,
+        replicated_only: bool=False, local: bool=False, timeout: int=0
+    ):
+        """
+        Executes a simplified SQL SELECT query over data stored in the cache.
+        The query returns the whole record (key and value).
+
+        :param query_str: SQL query string,
+        :param page_size: (optional) cursor page size. Default is 1, which
+         means that client makes one server call per row,
+        :param query_args: (optional) query arguments,
+        :param distributed_joins: (optional) distributed joins. Defaults
+         to False,
+        :param replicated_only: (optional) whether query contains only
+         replicated tables or not. Defaults to False,
+        :param local: (optional) pass True if this query should be executed
+         on local node only. Defaults to False,
+        :param timeout: (optional) non-negative timeout value in ms. Zero
+         disables timeout (default),
+        :return: generator with key-value pairs.
+        """
+        def generate_result(value):
+            cursor = value['cursor']
+            more = value['more']
+            for k, v in value['data'].items():
+                k = self._process_binary(k)
+                v = self._process_binary(v)
+                yield k, v
+
+            while more:
+                inner_result = sql_cursor_get_page(self._client, cursor)
+                if result.status != 0:
+                    raise SQLError(result.message)
+                more = inner_result.value['more']
+                for k, v in inner_result.value['data'].items():
+                    k = self._process_binary(k)
+                    v = self._process_binary(v)
+                    yield k, v
+
+        type_name = self.settings[
+            prop_codes.PROP_QUERY_ENTITIES
+        ][0]['value_type_name']
+        if not type_name:
+            raise SQLError('Value type is unknown')
+        result = sql(
+            self._client,
+            self._cache_id,
+            type_name,
+            query_str,
+            page_size,
+            query_args,
+            distributed_joins,
+            replicated_only,
+            local,
+            timeout
+        )
+        if result.status != 0:
+            raise SQLError(result.message)
+
+        return generate_result(result.value)
diff --git a/pyignite/client.py b/pyignite/client.py
new file mode 100644
index 0000000..d5a9464
--- /dev/null
+++ b/pyignite/client.py
@@ -0,0 +1,406 @@
+# 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.
+
+"""
+This module contains `Client` class, that lets you communicate with Apache
+Ignite cluster node by the means of Ignite binary client protocol.
+
+To start the communication, you may connect to the node of their choice
+by instantiating the `Client` object and calling
+:py:meth:`~pyignite.connection.Connection.connect` method with proper
+parameters.
+
+The whole storage room of Ignite cluster is split up into named structures,
+called caches. For accessing the particular cache in key-value style
+(a-la Redis or memcached) you should first create
+the :class:`~pyignite.cache.Cache` object by calling
+:py:meth:`~pyignite.client.Client.create_cache` or
+:py:meth:`~pyignite.client.Client.get_or_create_cache()` methods, than call
+:class:`~pyignite.cache.Cache` methods. If you wish to create a cache object
+without communicating with server, there is also a
+:py:meth:`~pyignite.client.Client.get_cache()` method that does just that.
+
+For using Ignite SQL, call :py:meth:`~pyignite.client.Client.sql` method.
+It returns a generator with result rows.
+
+:py:meth:`~pyignite.client.Client.register_binary_type` and
+:py:meth:`~pyignite.client.Client.query_binary_type` methods operates
+the local (class-wise) registry for Ignite Complex objects.
+"""
+
+from collections import defaultdict, OrderedDict
+from typing import Iterable, Type, Union
+
+from .api.binary import get_binary_type, put_binary_type
+from .api.cache_config import cache_get_names
+from .api.sql import sql_fields, sql_fields_cursor_get_page
+from .cache import Cache
+from .connection import Connection
+from .constants import *
+from .datatypes import BinaryObject
+from .datatypes.internal import tc_map
+from .exceptions import BinaryTypeError, CacheError, SQLError
+from .utils import entity_id, schema_id, status_to_exception
+from .binary import GenericObjectMeta
+
+
+__all__ = ['Client']
+
+
+class Client(Connection):
+    """
+    This is a main `pyignite` class, that is build upon the
+    :class:`~pyignite.connection.Connection`. In addition to the attributes,
+    properties and methods of its parent class, `Client` implements
+    the following features:
+
+     * cache factory. Cache objects are used for key-value operations,
+     * Ignite SQL endpoint,
+     * binary types registration endpoint.
+    """
+
+    _registry = defaultdict(dict)
+    _compact_footer = None
+
+    def _transfer_params(self, to: 'Client'):
+        super()._transfer_params(to)
+        to._registry = self._registry
+        to._compact_footer = self._compact_footer
+
+    def __init__(self, compact_footer: bool=None, *args, **kwargs):
+        """
+        Initialize client.
+
+        :param compact_footer: (optional) use compact (True, recommended) or
+         full (False) schema approach when serializing Complex objects.
+         Default is to use the same approach the server is using (None).
+         Apache Ignite binary protocol documentation on this topic:
+         https://apacheignite.readme.io/docs/binary-client-protocol-data-format#section-schema
+        """
+        self._compact_footer = compact_footer
+        super().__init__(*args, **kwargs)
+
+    @status_to_exception(BinaryTypeError)
+    def get_binary_type(self, binary_type: Union[str, int]) -> dict:
+        """
+        Gets the binary type information from the Ignite server. This is quite
+        a low-level implementation of Ignite thin client protocol's
+        `OP_GET_BINARY_TYPE` operation. You would probably want to use
+        :py:meth:`~pyignite.client.Client.query_binary_type` instead.
+
+        :param binary_type: binary type name or ID,
+        :return: binary type description − a dict with the following fields:
+
+         - `type_exists`: True if the type is registered, False otherwise. In
+           the latter case all the following fields are omitted,
+         - `type_id`: Complex object type ID,
+         - `type_name`: Complex object type name,
+         - `affinity_key_field`: string value or None,
+         - `is_enum`: False in case of Complex object registration,
+         - `schemas`: a list, containing the Complex object schemas in format:
+           OrderedDict[field name: field type hint]. A schema can be empty.
+        """
+        def convert_type(tc_type: int):
+            try:
+                return tc_map(tc_type.to_bytes(1, PROTOCOL_BYTE_ORDER))
+            except (KeyError, OverflowError):
+                # if conversion to char or type lookup failed,
+                # we probably have a binary object type ID
+                return BinaryObject
+
+        def convert_schema(
+            field_ids: list, binary_fields: list
+        ) -> OrderedDict:
+            converted_schema = OrderedDict()
+            for field_id in field_ids:
+                binary_field = [
+                    x
+                    for x in binary_fields
+                    if x['field_id'] == field_id
+                ][0]
+                converted_schema[binary_field['field_name']] = convert_type(
+                    binary_field['type_id']
+                )
+            return converted_schema
+
+        result = get_binary_type(self, binary_type)
+        if result.status != 0 or not result.value['type_exists']:
+            return result
+
+        binary_fields = result.value.pop('binary_fields')
+        old_format_schemas = result.value.pop('schema')
+        result.value['schemas'] = []
+        for s_id, field_ids in old_format_schemas.items():
+            result.value['schemas'].append(
+                convert_schema(field_ids, binary_fields)
+            )
+        return result
+
+    @property
+    def compact_footer(self) -> bool:
+        """
+        This property remembers Complex object schema encoding approach when
+        decoding any Complex object, to use the same approach on Complex
+        object encoding.
+
+        :return: True if compact schema was used by server or no Complex
+         object decoding has yet taken place, False if full schema was used.
+        """
+        # this is an ordinary object property, but its backing storage
+        # is a class attribute
+
+        # use compact schema by default, but leave initial (falsy) backing
+        # value unchanged
+        return (
+            self.__class__._compact_footer
+            or self.__class__._compact_footer is None
+        )
+
+    @compact_footer.setter
+    def compact_footer(self, value: bool):
+        # normally schema approach should not change
+        if self.__class__._compact_footer not in (value, None):
+            raise Warning('Can not change client schema approach.')
+        else:
+            self.__class__._compact_footer = value
+
+    @status_to_exception(BinaryTypeError)
+    def put_binary_type(
+        self, type_name: str, affinity_key_field: str=None,
+        is_enum=False, schema: dict=None
+    ):
+        """
+        Registers binary type information in cluster. Do not update binary
+        registry. This is a literal implementation of Ignite thin client
+        protocol's `OP_PUT_BINARY_TYPE` operation. You would probably want
+        to use :py:meth:`~pyignite.client.Client.register_binary_type` instead.
+
+        :param type_name: name of the data type being registered,
+        :param affinity_key_field: (optional) name of the affinity key field,
+        :param is_enum: (optional) register enum if True, binary object
+         otherwise. Defaults to False,
+        :param schema: (optional) when register enum, pass a dict
+         of enumerated parameter names as keys and an integers as values.
+         When register binary type, pass a dict of field names: field types.
+         Binary type with no fields is OK.
+        """
+        return put_binary_type(
+            self, type_name, affinity_key_field, is_enum, schema
+        )
+
+    @staticmethod
+    def _create_dataclass(type_name: str, schema: OrderedDict=None) -> Type:
+        """
+        Creates default (generic) class for Ignite Complex object.
+
+        :param type_name: Complex object type name,
+        :param schema: Complex object schema,
+        :return: the resulting class.
+        """
+        schema = schema or {}
+        return GenericObjectMeta(type_name, (), {}, schema=schema)
+
+    def _sync_binary_registry(self, type_id: int):
+        """
+        Reads Complex object description from Ignite server. Creates default
+        Complex object classes and puts in registry, if not already there.
+
+        :param type_id: Complex object type ID.
+        """
+        type_info = self.get_binary_type(type_id)
+        if type_info['type_exists']:
+            for schema in type_info['schemas']:
+                if not self._registry[type_id].get(schema_id(schema), None):
+                    data_class = self._create_dataclass(
+                        type_info['type_name'],
+                        schema,
+                    )
+                    self._registry[type_id][schema_id(schema)] = data_class
+
+    def register_binary_type(
+        self, data_class: Type, affinity_key_field: str=None,
+    ):
+        """
+        Register the given class as a representation of a certain Complex
+        object type. Discards autogenerated or previously registered class.
+
+        :param data_class: Complex object class,
+        :param affinity_key_field: (optional) affinity parameter.
+        """
+        if not self.query_binary_type(
+            data_class.type_id, data_class.schema_id
+        ):
+            self.put_binary_type(
+                data_class.type_name,
+                affinity_key_field,
+                schema=data_class.schema,
+            )
+        self._registry[data_class.type_id][data_class.schema_id] = data_class
+
+    def query_binary_type(
+        self, binary_type: Union[int, str], schema: Union[int, dict]=None,
+        sync: bool=True
+    ):
+        """
+        Queries the registry of Complex object classes.
+
+        :param binary_type: Complex object type name or ID,
+        :param schema: (optional) Complex object schema or schema ID,
+        :param sync: (optional) look up the Ignite server for registered
+         Complex objects and create data classes for them if needed,
+        :return: found dataclass or None, if `schema` parameter is provided,
+         a dict of {schema ID: dataclass} format otherwise.
+        """
+        type_id = entity_id(binary_type)
+        s_id = schema_id(schema)
+
+        if schema:
+            try:
+                result = self._registry[type_id][s_id]
+            except KeyError:
+                result = None
+        else:
+            result = self._registry[type_id]
+
+        if sync and not result:
+            self._sync_binary_registry(type_id)
+            return self.query_binary_type(type_id, s_id, sync=False)
+
+        return result
+
+    def create_cache(self, settings: Union[str, dict]) -> 'Cache':
+        """
+        Creates Ignite cache by name. Raises `CacheError` if such a cache is
+        already exists.
+
+        :param settings: cache name or dict of cache properties' codes
+         and values. All cache properties are documented here:
+         :ref:`cache_props`. See also the
+         :ref:`cache creation example <sql_cache_create>`,
+        :return: :class:`~pyignite.cache.Cache` object.
+        """
+        return Cache(self, settings)
+
+    def get_or_create_cache(self, settings: Union[str, dict]) -> 'Cache':
+        """
+        Creates Ignite cache, if not exist.
+
+        :param settings: cache name or dict of cache properties' codes
+         and values. All cache properties are documented here:
+         :ref:`cache_props`. See also the
+         :ref:`cache creation example <sql_cache_create>`,
+        :return: :class:`~pyignite.cache.Cache` object.
+        """
+        return Cache(self, settings, with_get=True)
+
+    def get_cache(self, settings: Union[str, dict]) -> 'Cache':
+        """
+        Creates Cache object with a given cache name without checking it up
+        on server. If such a cache does not exist, some kind of exception
+        (most probably `CacheError`) may be raised later.
+
+        :param settings: cache name or cache properties (but only `PROP_NAME`
+         property is allowed),
+        :return: :class:`~pyignite.cache.Cache` object.
+        """
+        return Cache(self, settings, get_only=True)
+
+    @status_to_exception(CacheError)
+    def get_cache_names(self) -> list:
+        """
+        Gets existing cache names.
+
+        :return: list of cache names.
+        """
+        return cache_get_names(self)
+
+    def sql(
+        self, query_str: str, page_size: int=1, query_args: Iterable=None,
+        schema: Union[int, str]='PUBLIC',
+        statement_type: int=0, distributed_joins: bool=False,
+        local: bool=False, replicated_only: bool=False,
+        enforce_join_order: bool=False, collocated: bool=False,
+        lazy: bool=False, include_field_names: bool=False,
+        max_rows: int=-1, timeout: int=0,
+    ):
+        """
+        Runs an SQL query and returns its result.
+
+        :param query_str: SQL query string,
+        :param page_size: (optional) cursor page size. Default is 1, which
+         means that client makes one server call per row,
+        :param query_args: (optional) query arguments. List of values or
+         (value, type hint) tuples,
+        :param schema: (optional) schema for the query. Defaults to `PUBLIC`,
+        :param statement_type: (optional) statement type. Can be:
+
+         * StatementType.ALL − any type (default),
+         * StatementType.SELECT − select,
+         * StatementType.UPDATE − update.
+
+        :param distributed_joins: (optional) distributed joins. Defaults
+         to False,
+        :param local: (optional) pass True if this query should be executed
+         on local node only. Defaults to False,
+        :param replicated_only: (optional) whether query contains only
+         replicated tables or not. Defaults to False,
+        :param enforce_join_order: (optional) enforce join order. Defaults
+         to False,
+        :param collocated: (optional) whether your data is co-located or not.
+         Defaults to False,
+        :param lazy: (optional) lazy query execution. Defaults to False,
+        :param include_field_names: (optional) include field names in result.
+         Defaults to False,
+        :param max_rows: (optional) query-wide maximum of rows. Defaults to -1
+         (all rows),
+        :param timeout: (optional) non-negative timeout value in ms.
+         Zero disables timeout (default),
+        :return: generator with result rows as a lists. If
+         `include_field_names` was set, the first row will hold field names.
+        """
+        def generate_result(value):
+            cursor = value['cursor']
+            more = value['more']
+
+            if include_field_names:
+                yield value['fields']
+                field_count = len(value['fields'])
+            else:
+                field_count = value['field_count']
+            for line in value['data']:
+                yield line
+
+            while more:
+                inner_result = sql_fields_cursor_get_page(
+                    self, cursor, field_count
+                )
+                if inner_result.status != 0:
+                    raise SQLError(result.message)
+                more = inner_result.value['more']
+                for line in inner_result.value['data']:
+                    yield line
+
+        schema = self.get_or_create_cache(schema)
+        result = sql_fields(
+            self, schema.cache_id, query_str,
+            page_size, query_args, schema.name,
+            statement_type, distributed_joins, local, replicated_only,
+            enforce_join_order, collocated, lazy, include_field_names,
+            max_rows, timeout,
+        )
+        if result.status != 0:
+            raise SQLError(result.message)
+
+        return generate_result(result.value)
diff --git a/pyignite/connection/__init__.py b/pyignite/connection/__init__.py
new file mode 100644
index 0000000..32decdf
--- /dev/null
+++ b/pyignite/connection/__init__.py
@@ -0,0 +1,329 @@
+# 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.
+
+# 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.
+
+"""
+This module contains `Connection` class, that wraps TCP socket handling,
+as well as Ignite protocol handshaking.
+"""
+
+import socket
+
+from pyignite.constants import *
+from pyignite.exceptions import (
+    HandshakeError, ParameterError, ReconnectError, SocketError,
+)
+
+from pyignite.utils import is_iterable
+from .handshake import HandshakeRequest, read_response
+from .ssl import wrap
+
+
+__all__ = ['Connection']
+
+
+class Connection:
+    """
+    This is a `pyignite` class, that represents a connection to Ignite
+    node. It serves multiple purposes:
+
+     * socket wrapper. Detects fragmentation and network errors. See also
+       https://docs.python.org/3/howto/sockets.html,
+     * binary protocol connector. Incapsulates handshake, data read-ahead and
+       failover reconnection.
+    """
+
+    _socket = None
+    nodes = None
+    host = None
+    port = None
+    timeout = None
+    prefetch = None
+    username = None
+    password = None
+
+    @staticmethod
+    def _check_kwargs(kwargs):
+        expected_args = [
+            'timeout',
+            'use_ssl',
+            'ssl_version',
+            'ssl_ciphers',
+            'ssl_cert_reqs',
+            'ssl_keyfile',
+            'ssl_certfile',
+            'ssl_ca_certfile',
+            'username',
+            'password',
+        ]
+        for kw in kwargs:
+            if kw not in expected_args:
+                raise ParameterError((
+                    'Unexpected parameter for connection initialization: `{}`'
+                ).format(kw))
+
+    def __init__(self, prefetch: bytes=b'', **kwargs):
+        """
+        Initialize connection.
+
+        For the use of the SSL-related parameters see
+        https://docs.python.org/3/library/ssl.html#ssl-certificates.
+
+        :param prefetch: (optional) initialize the read-ahead data buffer.
+         Empty by default,
+        :param timeout: (optional) sets timeout (in seconds) for each socket
+         operation including `connect`. 0 means non-blocking mode, which is
+         virtually guaranteed to fail. Can accept integer or float value.
+         Default is None (blocking mode),
+        :param use_ssl: (optional) set to True if Ignite server uses SSL
+         on its binary connector. Defaults to use SSL when username
+         and password has been supplied, not to use SSL otherwise,
+        :param ssl_version: (optional) SSL version constant from standard
+         `ssl` module. Defaults to TLS v1.1, as in Ignite 2.5,
+        :param ssl_ciphers: (optional) ciphers to use. If not provided,
+         `ssl` default ciphers are used,
+        :param ssl_cert_reqs: (optional) determines how the remote side
+         certificate is treated:
+
+         * `ssl.CERT_NONE` − remote certificate is ignored (default),
+         * `ssl.CERT_OPTIONAL` − remote certificate will be validated,
+           if provided,
+         * `ssl.CERT_REQUIRED` − valid remote certificate is required,
+
+        :param ssl_keyfile: (optional) a path to SSL key file to identify
+         local (client) party,
+        :param ssl_certfile: (optional) a path to ssl certificate file
+         to identify local (client) party,
+        :param ssl_ca_certfile: (optional) a path to a trusted certificate
+         or a certificate chain. Required to check the validity of the remote
+         (server-side) certificate,
+        :param username: (optional) user name to authenticate to Ignite
+         cluster,
+        :param password: (optional) password to authenticate to Ignite cluster.
+        """
+        self.prefetch = prefetch
+        self._check_kwargs(kwargs)
+        self.timeout = kwargs.pop('timeout', None)
+        self.username = kwargs.pop('username', None)
+        self.password = kwargs.pop('password', None)
+        if all([self.username, self.password, 'use_ssl' not in kwargs]):
+            kwargs['use_ssl'] = True
+        self.init_kwargs = kwargs
+
+    read_response = read_response
+    _wrap = wrap
+
+    @property
+    def socket(self) -> socket.socket:
+        """
+        Network socket.
+        """
+        if self._socket is None:
+            self._reconnect()
+        return self._socket
+
+    def __repr__(self) -> str:
+        if self.host and self.port:
+            return '{}:{}'.format(self.host, self.port)
+        else:
+            return '<not connected>'
+
+    def _connect(self, host: str, port: int):
+        """
+        Actually connect socket.
+        """
+        self._socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        self._socket.settimeout(self.timeout)
+        self._socket = self._wrap(self.socket)
+        self._socket.connect((host, port))
+
+        hs_request = HandshakeRequest(self.username, self.password)
+        self.send(hs_request)
+        hs_response = self.read_response()
+        if hs_response['op_code'] == 0:
+            self.close()
+            error_text = 'Handshake error: {}'.format(hs_response['message'])
+            # if handshake fails for any reason other than protocol mismatch
+            # (i.e. authentication error), server version is 0.0.0
+            if any([
+                hs_response['version_major'],
+                hs_response['version_minor'],
+                hs_response['version_patch'],
+            ]):
+                error_text += (
+                    ' Server expects binary protocol version '
+                    '{version_major}.{version_minor}.{version_patch}. Client '
+                    'provides {client_major}.{client_minor}.{client_patch}.'
+                ).format(
+                    client_major=PROTOCOL_VERSION_MAJOR,
+                    client_minor=PROTOCOL_VERSION_MINOR,
+                    client_patch=PROTOCOL_VERSION_PATCH,
+                    **hs_response
+                )
+            raise HandshakeError(error_text)
+        self.host, self.port = host, port
+
+    def connect(self, *args):
+        """
+        Connect to the server. Connection parameters may be either one node
+        (host and port), or list (or other iterable) of nodes.
+
+        :param host: Ignite server host,
+        :param port: Ignite server port,
+        :param nodes: iterable of (host, port) tuples.
+        """
+        self.nodes = iter([])
+        if len(args) == 0:
+            host, port = IGNITE_DEFAULT_HOST, IGNITE_DEFAULT_PORT
+        elif len(args) == 1 and is_iterable(args[0]):
+            self.nodes = iter(args[0])
+            host, port = next(self.nodes)
+        elif (
+            len(args) == 2
+            and isinstance(args[0], str)
+            and isinstance(args[1], int)
+        ):
+            host, port = args
+        else:
+            raise ConnectionError('Connection parameters are not valid.')
+
+        self._connect(host, port)
+
+    def _reconnect(self):
+        """
+        Restore the connection using the next node in `nodes` iterable.
+        """
+        for host, port in self.nodes:
+            try:
+                self._connect(host, port)
+                return
+            except OSError:
+                pass
+        self.host = self.port = self.nodes = None
+        # exception chaining gives a misleading traceback here
+        raise ReconnectError('Can not reconnect: out of nodes') from None
+
+    def _transfer_params(self, to: 'Connection'):
+        """
+        Transfer non-SSL parameters to target connection object.
+
+        :param target: connection object to transfer parameters to.
+        """
+        to.username = self.username
+        to.password = self.password
+        to.nodes = self.nodes
+
+    def clone(self, prefetch: bytes=b'') -> 'Connection':
+        """
+        Clones this connection in its current state.
+
+        :return: `Connection` object.
+        """
+        clone = self.__class__(**self.init_kwargs)
+        self._transfer_params(to=clone)
+        if self.port and self.host:
+            clone._connect(self.host, self.port)
+        clone.prefetch = prefetch
+        return clone
+
+    def send(self, data: bytes, flags=None):
+        """
+        Send data down the socket.
+
+        :param data: bytes to send,
+        :param flags: (optional) OS-specific flags.
+        """
+        kwargs = {}
+        if flags is not None:
+            kwargs['flags'] = flags
+        data = bytes(data)
+        total_bytes_sent = 0
+
+        while total_bytes_sent < len(data):
+            try:
+                bytes_sent = self.socket.send(data[total_bytes_sent:], **kwargs)
+            except OSError:
+                self._socket = self.host = self.port = None
+                raise
+            if bytes_sent == 0:
+                self.socket.close()
+                raise SocketError('Socket connection broken.')
+            total_bytes_sent += bytes_sent
+
+    def recv(self, buffersize, flags=None) -> bytes:
+        """
+        Receive data from socket or read-ahead buffer.
+
+        :param buffersize: bytes to receive,
+        :param flags: (optional) OS-specific flags,
+        :return: data received.
+        """
+        pref_size = len(self.prefetch)
+        if buffersize > pref_size:
+            result = self.prefetch
+            self.prefetch = b''
+            try:
+                result += self._recv(buffersize-pref_size, flags)
+            except (SocketError, OSError):
+                self._socket = self.host = self.port = None
+                raise
+            return result
+        else:
+            result = self.prefetch[:buffersize]
+            self.prefetch = self.prefetch[buffersize:]
+            return result
+
+    def _recv(self, buffersize, flags=None) -> bytes:
+        """
+        Handle socket data reading.
+        """
+        kwargs = {}
+        if flags is not None:
+            kwargs['flags'] = flags
+        chunks = []
+        bytes_rcvd = 0
+
+        while bytes_rcvd < buffersize:
+            chunk = self.socket.recv(buffersize-bytes_rcvd, **kwargs)
+            if chunk == b'':
+                self.socket.close()
+                raise SocketError('Socket connection broken.')
+            chunks.append(chunk)
+            bytes_rcvd += len(chunk)
+
+        return b''.join(chunks)
+
+    def close(self):
+        """
+        Mark socket closed. This is recommended but not required, since
+        sockets are automatically closed when they are garbage-collected.
+        """
+        self._socket.shutdown(socket.SHUT_RDWR)
+        self._socket.close()
+        self._socket = self.host = self.port = None
diff --git a/pyignite/connection/generators.py b/pyignite/connection/generators.py
new file mode 100644
index 0000000..d76db0e
--- /dev/null
+++ b/pyignite/connection/generators.py
@@ -0,0 +1,48 @@
+# 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.
+
+
+class RoundRobin:
+    """
+    Round-robin generator for use with `Client.connect()`. Cycles a node
+    list until a maximum number of reconnects is reached (if set).
+    """
+
+    def __init__(self, nodes: list, max_reconnects: int=None):
+        """
+        :param nodes: list of two-tuples of (host, port) format,
+        :param max_reconnects: (optional) maximum number of reconnect attempts.
+         defaults to None (cycle nodes infinitely).
+        """
+        self.nodes = nodes
+        self.max_reconnects = max_reconnects
+        self.node_index = 0
+        self.reconnects = 0
+
+    def __iter__(self) -> 'RoundRobin':
+        return self
+
+    def __next__(self) -> tuple:
+        if self.max_reconnects is not None:
+            if self.reconnects >= self.max_reconnects:
+                raise StopIteration
+            else:
+                self.reconnects += 1
+
+        if self.node_index >= len(self.nodes):
+            self.node_index = 0
+        node = self.nodes[self.node_index]
+        self.node_index += 1
+        return node
diff --git a/pyignite/connection/handshake.py b/pyignite/connection/handshake.py
new file mode 100644
index 0000000..13d57fe
--- /dev/null
+++ b/pyignite/connection/handshake.py
@@ -0,0 +1,91 @@
+# 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 Optional
+
+from pyignite.constants import *
+from pyignite.datatypes import Byte, Int, Short, String
+from pyignite.datatypes.internal import Struct
+
+OP_HANDSHAKE = 1
+
+
+class HandshakeRequest:
+    """ Handshake request. """
+    handshake_struct = None
+    username = None
+    password = None
+
+    def __init__(
+        self, username: Optional[str]=None, password: Optional[str]=None
+    ):
+        fields = [
+            ('length', Int),
+            ('op_code', Byte),
+            ('version_major', Short),
+            ('version_minor', Short),
+            ('version_patch', Short),
+            ('client_code', Byte),
+        ]
+        if username and password:
+            self.username = username
+            self.password = password
+            fields.extend([
+                ('username', String),
+                ('password', String),
+            ])
+        self.handshake_struct = Struct(fields)
+
+    def __bytes__(self) -> bytes:
+        handshake_data = {
+            'length': 8,
+            'op_code': OP_HANDSHAKE,
+            'version_major': PROTOCOL_VERSION_MAJOR,
+            'version_minor': PROTOCOL_VERSION_MINOR,
+            'version_patch': PROTOCOL_VERSION_PATCH,
+            'client_code': 2,  # fixed value defined by protocol
+        }
+        if self.username and self.password:
+            handshake_data.update({
+                'username': self.username,
+                'password': self.password,
+            })
+            handshake_data['length'] += sum([
+                10,  # each `String` header takes 5 bytes
+                len(self.username),
+                len(self.password),
+            ])
+        return self.handshake_struct.from_python(handshake_data)
+
+
+def read_response(client):
+    response_start = Struct([
+        ('length', Int),
+        ('op_code', Byte),
+    ])
+    start_class, start_buffer = response_start.parse(client)
+    start = start_class.from_buffer_copy(start_buffer)
+    data = response_start.to_python(start)
+    if data['op_code'] == 0:
+        response_end = Struct([
+            ('version_major', Short),
+            ('version_minor', Short),
+            ('version_patch', Short),
+            ('message', String),
+        ])
+        end_class, end_buffer = response_end.parse(client)
+        end = end_class.from_buffer_copy(end_buffer)
+        data.update(response_end.to_python(end))
+    return data
diff --git a/pyignite/connection/ssl.py b/pyignite/connection/ssl.py
new file mode 100644
index 0000000..548ca7f
--- /dev/null
+++ b/pyignite/connection/ssl.py
@@ -0,0 +1,39 @@
+# 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.
+
+import ssl
+
+from pyignite.constants import *
+
+
+def wrap(client, _socket):
+    """ Wrap socket in SSL wrapper. """
+    if client.init_kwargs.get('use_ssl', None):
+        _socket = ssl.wrap_socket(
+            _socket,
+            ssl_version=client.init_kwargs.get(
+                'ssl_version', SSL_DEFAULT_VERSION
+            ),
+            ciphers=client.init_kwargs.get(
+                'ssl_ciphers', SSL_DEFAULT_CIPHERS
+            ),
+            cert_reqs=client.init_kwargs.get(
+                'ssl_cert_reqs', ssl.CERT_NONE
+            ),
+            keyfile=client.init_kwargs.get('ssl_keyfile', None),
+            certfile=client.init_kwargs.get('ssl_certfile', None),
+            ca_certs=client.init_kwargs.get('ssl_ca_certfile', None),
+        )
+    return _socket
diff --git a/pyignite/constants.py b/pyignite/constants.py
new file mode 100644
index 0000000..78c9379
--- /dev/null
+++ b/pyignite/constants.py
@@ -0,0 +1,52 @@
+# 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.
+
+"""
+This module contains some constants, used internally throughout the API.
+"""
+
+import ssl
+
+
+__all__ = [
+    'PROTOCOL_VERSION_MAJOR', 'PROTOCOL_VERSION_MINOR',
+    'PROTOCOL_VERSION_PATCH', 'MAX_LONG', 'MIN_LONG', 'MAX_INT', 'MIN_INT',
+    'PROTOCOL_BYTE_ORDER', 'PROTOCOL_STRING_ENCODING',
+    'PROTOCOL_CHAR_ENCODING', 'SSL_DEFAULT_VERSION', 'SSL_DEFAULT_CIPHERS',
+    'FNV1_OFFSET_BASIS', 'FNV1_PRIME',
+    'IGNITE_DEFAULT_HOST', 'IGNITE_DEFAULT_PORT',
+]
+
+PROTOCOL_VERSION_MAJOR = 1
+PROTOCOL_VERSION_MINOR = 2
+PROTOCOL_VERSION_PATCH = 0
+
+MAX_LONG = 9223372036854775807
+MIN_LONG = -9223372036854775808
+MAX_INT = 2147483647
+MIN_INT = -2147483648
+
+PROTOCOL_BYTE_ORDER = 'little'
+PROTOCOL_STRING_ENCODING = 'utf-8'
+PROTOCOL_CHAR_ENCODING = 'utf-16le'
+
+SSL_DEFAULT_VERSION = ssl.PROTOCOL_TLSv1_1
+SSL_DEFAULT_CIPHERS = ssl._DEFAULT_CIPHERS
+
+FNV1_OFFSET_BASIS = 0x811c9dc5
+FNV1_PRIME = 0x01000193
+
+IGNITE_DEFAULT_HOST = 'localhost'
+IGNITE_DEFAULT_PORT = 10800
diff --git a/pyignite/datatypes/__init__.py b/pyignite/datatypes/__init__.py
new file mode 100644
index 0000000..5024f79
--- /dev/null
+++ b/pyignite/datatypes/__init__.py
@@ -0,0 +1,27 @@
+# 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.
+
+"""
+This module contains classes, used internally by `pyignite` for parsing and
+creating binary data.
+"""
+
+from .complex import *
+from .internal import *
+from .null_object import *
+from .primitive import *
+from .primitive_arrays import *
+from .primitive_objects import *
+from .standard import *
diff --git a/pyignite/datatypes/binary.py b/pyignite/datatypes/binary.py
new file mode 100644
index 0000000..c2344da
--- /dev/null
+++ b/pyignite/datatypes/binary.py
@@ -0,0 +1,45 @@
+# 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 pyignite.datatypes import Int, Bool, String, Struct, StructArray
+
+
+binary_fields_struct = StructArray([
+    ('field_name', String),
+    ('type_id', Int),
+    ('field_id', Int),
+])
+
+body_struct = Struct([
+    ('type_id', Int),
+    ('type_name', String),
+    ('affinity_key_field', String),
+    ('binary_fields', binary_fields_struct),
+    ('is_enum', Bool),
+])
+
+enum_struct = StructArray([
+    ('literal', String),
+    ('type_id', Int),
+])
+
+schema_fields_struct = StructArray([
+    ('schema_field_id', Int),
+])
+
+schema_struct = StructArray([
+    ('schema_id', Int),
+    ('schema_fields', schema_fields_struct),
+])
diff --git a/pyignite/datatypes/cache_config.py b/pyignite/datatypes/cache_config.py
new file mode 100644
index 0000000..67b353d
--- /dev/null
+++ b/pyignite/datatypes/cache_config.py
@@ -0,0 +1,153 @@
+# 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 .standard import String
+from .internal import AnyDataObject, Struct, StructArray
+from .primitive import *
+
+
+__all__ = [
+    'cache_config_struct', 'CacheMode', 'PartitionLossPolicy',
+    'RebalanceMode', 'WriteSynchronizationMode', 'IndexType',
+]
+
+
+class CacheMode(Int):
+    LOCAL = 0
+    REPLICATED = 1
+    PARTITIONED = 2
+
+
+class PartitionLossPolicy(Int):
+    READ_ONLY_SAFE = 0
+    READ_ONLY_ALL = 1
+    READ_WRITE_SAFE = 2
+    READ_WRITE_ALL = 3
+    IGNORE = 4
+
+
+class RebalanceMode(Int):
+    SYNC = 0
+    ASYNC = 1
+    NONE = 2
+
+
+class WriteSynchronizationMode(Int):
+    FULL_SYNC = 0
+    FULL_ASYNC = 1
+    PRIMARY_SYNC = 2
+
+
+class IndexType(Byte):
+    SORTED = 0
+    FULLTEXT = 1
+    GEOSPATIAL = 2
+
+
+class CacheAtomicityMode(Int):
+    TRANSACTIONAL = 0
+    ATOMIC = 1
+
+
+QueryFields = StructArray([
+    ('name', String),
+    ('type_name', String),
+    ('is_key_field', Bool),
+    ('is_notnull_constraint_field', Bool),
+    ('default_value', AnyDataObject),
+    ('precision', Int),
+    ('scale', Int),
+], defaults={
+    'is_key_field': False,
+    'is_notnull_constraint_field': False,
+    'default_value': None,
+    'precision': -1,
+    'scale': -1,
+})
+
+
+FieldNameAliases = StructArray([
+    ('field_name', String),
+    ('alias', String),
+])
+
+
+Fields = StructArray([
+    ('name', String),
+    ('is_descending', Bool),
+], defaults={
+    'is_descending': False,
+})
+
+
+QueryIndexes = StructArray([
+    ('index_name', String),
+    ('index_type', IndexType),
+    ('inline_size', Int),
+    ('fields', Fields),
+])
+
+
+QueryEntities = StructArray([
+    ('key_type_name', String),
+    ('value_type_name', String),
+    ('table_name', String),
+    ('key_field_name', String),
+    ('value_field_name', String),
+    ('query_fields', QueryFields),
+    ('field_name_aliases', FieldNameAliases),
+    ('query_indexes', QueryIndexes),
+])
+
+
+CacheKeyConfiguration = StructArray([
+    ('type_name', String),
+    ('affinity_key_field_name', String),
+])
+
+
+cache_config_struct = Struct([
+    ('length', Int),
+    ('backups_number', Int),
+    ('cache_mode', CacheMode),
+    ('cache_atomicity_mode', CacheAtomicityMode),
+    ('copy_on_read', Bool),
+    ('data_region_name', String),
+    ('eager_ttl', Bool),
+    ('statistics_enabled', Bool),
+    ('group_name', String),
+    ('invalidate', Int),
+    ('default_lock_timeout', Long),
+    ('max_query_iterators', Int),
+    ('name', String),
+    ('is_onheap_cache_enabled', Bool),
+    ('partition_loss_policy', PartitionLossPolicy),
+    ('query_detail_metric_size', Int),
+    ('query_parallelism', Int),
+    ('read_from_backup', Bool),
+    ('rebalance_batch_size', Int),
+    ('rebalance_batches_prefetch_count', Long),
+    ('rebalance_delay', Long),
+    ('rebalance_mode', RebalanceMode),
+    ('rebalance_order', Int),
+    ('rebalance_throttle', Long),
+    ('rebalance_timeout', Long),
+    ('sql_escape_all', Bool),
+    ('sql_index_inline_max_size', Int),
+    ('sql_schema', String),
+    ('write_synchronization_mode', WriteSynchronizationMode),
+    ('cache_key_configuration', CacheKeyConfiguration),
+    ('query_entities', QueryEntities),
+])
diff --git a/pyignite/datatypes/cache_properties.py b/pyignite/datatypes/cache_properties.py
new file mode 100644
index 0000000..e94db5f
--- /dev/null
+++ b/pyignite/datatypes/cache_properties.py
@@ -0,0 +1,287 @@
+# 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.
+
+import ctypes
+
+from .prop_codes import *
+from .cache_config import (
+    CacheMode, CacheAtomicityMode, PartitionLossPolicy, RebalanceMode,
+    WriteSynchronizationMode, QueryEntities, CacheKeyConfiguration,
+)
+from .primitive import *
+from .standard import *
+
+
+__all__ = [
+    'PropName', 'PropCacheMode', 'PropCacheAtomicityMode', 'PropBackupsNumber',
+    'PropWriteSynchronizationMode', 'PropCopyOnRead', 'PropReadFromBackup',
+    'PropDataRegionName', 'PropIsOnheapCacheEnabled', 'PropQueryEntities',
+    'PropQueryParallelism', 'PropQueryDetailMetricSize', 'PropSQLSchema',
+    'PropSQLIndexInlineMaxSize', 'PropSqlEscapeAll', 'PropMaxQueryIterators',
+    'PropRebalanceMode', 'PropRebalanceDelay', 'PropRebalanceTimeout',
+    'PropRebalanceBatchSize', 'PropRebalanceBatchesPrefetchCount',
+    'PropRebalanceOrder', 'PropRebalanceThrottle', 'PropGroupName',
+    'PropCacheKeyConfiguration', 'PropDefaultLockTimeout',
+    'PropMaxConcurrentAsyncOperation', 'PropPartitionLossPolicy',
+    'PropEagerTTL', 'PropStatisticsEnabled', 'prop_map', 'AnyProperty',
+]
+
+
+def prop_map(code: int):
+    return {
+        PROP_NAME: PropName,
+        PROP_CACHE_MODE: PropCacheMode,
+        PROP_CACHE_ATOMICITY_MODE: PropCacheAtomicityMode,
+        PROP_BACKUPS_NUMBER: PropBackupsNumber,
+        PROP_WRITE_SYNCHRONIZATION_MODE: PropWriteSynchronizationMode,
+        PROP_COPY_ON_READ: PropCopyOnRead,
+        PROP_READ_FROM_BACKUP: PropReadFromBackup,
+        PROP_DATA_REGION_NAME: PropDataRegionName,
+        PROP_IS_ONHEAP_CACHE_ENABLED: PropIsOnheapCacheEnabled,
+        PROP_QUERY_ENTITIES: PropQueryEntities,
+        PROP_QUERY_PARALLELISM: PropQueryParallelism,
+        PROP_QUERY_DETAIL_METRIC_SIZE: PropQueryDetailMetricSize,
+        PROP_SQL_SCHEMA: PropSQLSchema,
+        PROP_SQL_INDEX_INLINE_MAX_SIZE: PropSQLIndexInlineMaxSize,
+        PROP_SQL_ESCAPE_ALL: PropSqlEscapeAll,
+        PROP_MAX_QUERY_ITERATORS: PropMaxQueryIterators,
+        PROP_REBALANCE_MODE: PropRebalanceMode,
+        PROP_REBALANCE_DELAY: PropRebalanceDelay,
+        PROP_REBALANCE_TIMEOUT: PropRebalanceTimeout,
+        PROP_REBALANCE_BATCH_SIZE: PropRebalanceBatchSize,
+        PROP_REBALANCE_BATCHES_PREFETCH_COUNT: PropRebalanceBatchesPrefetchCount,
+        PROP_REBALANCE_ORDER: PropRebalanceOrder,
+        PROP_REBALANCE_THROTTLE: PropRebalanceThrottle,
+        PROP_GROUP_NAME: PropGroupName,
+        PROP_CACHE_KEY_CONFIGURATION: PropCacheKeyConfiguration,
+        PROP_DEFAULT_LOCK_TIMEOUT: PropDefaultLockTimeout,
+        PROP_MAX_CONCURRENT_ASYNC_OPERATIONS: PropMaxConcurrentAsyncOperation,
+        PROP_PARTITION_LOSS_POLICY: PartitionLossPolicy,
+        PROP_EAGER_TTL: PropEagerTTL,
+        PROP_STATISTICS_ENABLED: PropStatisticsEnabled,
+    }[code]
+
+
+class PropBase:
+    prop_code = None
+    prop_data_class = None
+
+    @classmethod
+    def build_header(cls):
+        return type(
+            cls.__name__+'Header',
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('prop_code', ctypes.c_short),
+                ],
+            }
+        )
+
+    @classmethod
+    def parse(cls, connection: 'Connection'):
+        header_class = cls.build_header()
+        header_buffer = connection.recv(ctypes.sizeof(header_class))
+        data_class, data_buffer = cls.prop_data_class.parse(connection)
+        prop_class = type(
+            cls.__name__,
+            (header_class,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('data', data_class),
+                ],
+            }
+        )
+        return prop_class, header_buffer + data_buffer
+
+    @classmethod
+    def to_python(cls, ctype_object, *args, **kwargs):
+        return cls.prop_data_class.to_python(
+            ctype_object.data, *args, **kwargs
+        )
+
+    @classmethod
+    def from_python(cls, value):
+        header_class = cls.build_header()
+        header = header_class()
+        header.prop_code = cls.prop_code
+        return bytes(header) + cls.prop_data_class.from_python(value)
+
+
+class PropName(PropBase):
+    prop_code = PROP_NAME
+    prop_data_class = String
+
+
+class PropCacheMode(PropBase):
+    prop_code = PROP_CACHE_MODE
+    prop_data_class = CacheMode
+
+
+class PropCacheAtomicityMode(PropBase):
+    prop_code = PROP_CACHE_ATOMICITY_MODE
+    prop_data_class = CacheAtomicityMode
+
+
+class PropBackupsNumber(PropBase):
+    prop_code = PROP_BACKUPS_NUMBER
+    prop_data_class = Int
+
+
+class PropWriteSynchronizationMode(PropBase):
+    prop_code = PROP_WRITE_SYNCHRONIZATION_MODE
+    prop_data_class = WriteSynchronizationMode
+
+
+class PropCopyOnRead(PropBase):
+    prop_code = PROP_COPY_ON_READ
+    prop_data_class = Bool
+
+
+class PropReadFromBackup(PropBase):
+    prop_code = PROP_READ_FROM_BACKUP
+    prop_data_class = Bool
+
+
+class PropDataRegionName(PropBase):
+    prop_code = PROP_DATA_REGION_NAME
+    prop_data_class = String
+
+
+class PropIsOnheapCacheEnabled(PropBase):
+    prop_code = PROP_IS_ONHEAP_CACHE_ENABLED
+    prop_data_class = Bool
+
+
+class PropQueryEntities(PropBase):
+    prop_code = PROP_QUERY_ENTITIES
+    prop_data_class = QueryEntities
+
+
+class PropQueryParallelism(PropBase):
+    prop_code = PROP_QUERY_PARALLELISM
+    prop_data_class = Int
+
+
+class PropQueryDetailMetricSize(PropBase):
+    prop_code = PROP_QUERY_DETAIL_METRIC_SIZE
+    prop_data_class = Int
+
+
+class PropSQLSchema(PropBase):
+    prop_code = PROP_SQL_SCHEMA
+    prop_data_class = String
+
+
+class PropSQLIndexInlineMaxSize(PropBase):
+    prop_code = PROP_SQL_INDEX_INLINE_MAX_SIZE
+    prop_data_class = Int
+
+
+class PropSqlEscapeAll(PropBase):
+    prop_code = PROP_SQL_ESCAPE_ALL
+    prop_data_class = Bool
+
+
+class PropMaxQueryIterators(PropBase):
+    prop_code = PROP_MAX_QUERY_ITERATORS
+    prop_data_class = Int
+
+
+class PropRebalanceMode(PropBase):
+    prop_code = PROP_REBALANCE_MODE
+    prop_data_class = RebalanceMode
+
+
+class PropRebalanceDelay(PropBase):
+    prop_code = PROP_REBALANCE_DELAY
+    prop_data_class = Long
+
+
+class PropRebalanceTimeout(PropBase):
+    prop_code = PROP_REBALANCE_TIMEOUT
+    prop_data_class = Long
+
+
+class PropRebalanceBatchSize(PropBase):
+    prop_code = PROP_REBALANCE_BATCH_SIZE
+    prop_data_class = Int
+
+
+class PropRebalanceBatchesPrefetchCount(PropBase):
+    prop_code = PROP_REBALANCE_BATCHES_PREFETCH_COUNT
+    prop_data_class = Long
+
+
+class PropRebalanceOrder(PropBase):
+    prop_code = PROP_REBALANCE_ORDER
+    prop_data_class = Int
+
+
+class PropRebalanceThrottle(PropBase):
+    prop_code = PROP_REBALANCE_THROTTLE
+    prop_data_class = Long
+
+
+class PropGroupName(PropBase):
+    prop_code = PROP_GROUP_NAME
+    prop_data_class = String
+
+
+class PropCacheKeyConfiguration(PropBase):
+    prop_code = PROP_CACHE_KEY_CONFIGURATION
+    prop_data_class = CacheKeyConfiguration
+
+
+class PropDefaultLockTimeout(PropBase):
+    prop_code = PROP_DEFAULT_LOCK_TIMEOUT
+    prop_data_class = Long
+
+
+class PropMaxConcurrentAsyncOperation(PropBase):
+    prop_code = PROP_MAX_CONCURRENT_ASYNC_OPERATIONS
+    prop_data_class = Int
+
+
+class PropPartitionLossPolicy(PropBase):
+    prop_code = PROP_PARTITION_LOSS_POLICY
+    prop_data_class = PartitionLossPolicy
+
+
+class PropEagerTTL(PropBase):
+    prop_code = PROP_EAGER_TTL
+    prop_data_class = Bool
+
+
+class PropStatisticsEnabled(PropBase):
+    prop_code = PROP_STATISTICS_ENABLED
+    prop_data_class = Bool
+
+
+class AnyProperty(PropBase):
+
+    @classmethod
+    def from_python(cls, value):
+        raise Exception(
+            'You must choose a certain type '
+            'for your cache configuration property'
+        )
+
+    @classmethod
+    def to_python(cls, ctype_object, *args, **kwargs):
+        prop_data_class = prop_map(ctype_object.prop_code)
+        return prop_data_class.to_python(ctype_object.data, *args, **kwargs)
diff --git a/pyignite/datatypes/complex.py b/pyignite/datatypes/complex.py
new file mode 100644
index 0000000..9a5664c
--- /dev/null
+++ b/pyignite/datatypes/complex.py
@@ -0,0 +1,531 @@
+# 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 collections import OrderedDict
+import ctypes
+import inspect
+
+from pyignite.constants import *
+from pyignite.exceptions import ParseError
+from pyignite.utils import entity_id, hashcode, is_hinted
+from .internal import AnyDataObject
+from .type_codes import *
+
+
+__all__ = [
+    'Map', 'ObjectArrayObject', 'CollectionObject', 'MapObject',
+    'WrappedDataObject', 'BinaryObject',
+]
+
+
+class ObjectArrayObject:
+    """
+    Array of objects of any type. Its Python representation is
+    tuple(type_id, iterable of any type).
+    """
+    type_code = TC_OBJECT_ARRAY
+    type_or_id_name = 'type_id'
+
+    @classmethod
+    def build_header(cls):
+        return type(
+            cls.__name__+'Header',
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('type_code', ctypes.c_byte),
+                    ('type_id', ctypes.c_int),
+                    ('length', ctypes.c_int),
+                ],
+            }
+        )
+
+    @classmethod
+    def parse(cls, client: 'Client'):
+        header_class = cls.build_header()
+        buffer = client.recv(ctypes.sizeof(header_class))
+        header = header_class.from_buffer_copy(buffer)
+        fields = []
+
+        for i in range(header.length):
+            c_type, buffer_fragment = AnyDataObject.parse(client)
+            buffer += buffer_fragment
+            fields.append(('element_{}'.format(i), c_type))
+
+        final_class = type(
+            cls.__name__,
+            (header_class,),
+            {
+                '_pack_': 1,
+                '_fields_': fields,
+            }
+        )
+        return final_class, buffer
+
+    @classmethod
+    def to_python(cls, ctype_object, *args, **kwargs):
+        result = []
+        for i in range(ctype_object.length):
+            result.append(
+                AnyDataObject.to_python(
+                    getattr(ctype_object, 'element_{}'.format(i)),
+                    *args, **kwargs
+                )
+            )
+        return getattr(ctype_object, cls.type_or_id_name), result
+
+    @classmethod
+    def from_python(cls, value):
+        type_or_id, value = value
+        header_class = cls.build_header()
+        header = header_class()
+        header.type_code = int.from_bytes(
+            cls.type_code,
+            byteorder=PROTOCOL_BYTE_ORDER
+        )
+        try:
+            length = len(value)
+        except TypeError:
+            value = [value]
+            length = 1
+        header.length = length
+        setattr(header, cls.type_or_id_name, type_or_id)
+        buffer = bytes(header)
+
+        for x in value:
+            buffer += AnyDataObject.from_python(x)
+        return buffer
+
+
+class WrappedDataObject:
+    """
+    One or more binary objects can be wrapped in an array. This allows reading,
+    storing, passing and writing objects efficiently without understanding
+    their contents, performing simple byte copy.
+
+    Python representation: tuple(payload: bytes, offset: integer). Offset
+    points to the root object of the array.
+    """
+    type_code = TC_ARRAY_WRAPPED_OBJECTS
+
+    @classmethod
+    def build_header(cls):
+        return type(
+            cls.__name__+'Header',
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('type_code', ctypes.c_byte),
+                    ('length', ctypes.c_int),
+                ],
+            }
+        )
+
+    @classmethod
+    def parse(cls, client: 'Client'):
+        header_class = cls.build_header()
+        buffer = client.recv(ctypes.sizeof(header_class))
+        header = header_class.from_buffer_copy(buffer)
+
+        final_class = type(
+            cls.__name__,
+            (header_class,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('payload', ctypes.c_byte*header.length),
+                    ('offset', ctypes.c_int),
+                ],
+            }
+        )
+        buffer += client.recv(
+            ctypes.sizeof(final_class) - ctypes.sizeof(header_class)
+        )
+        return final_class, buffer
+
+    @classmethod
+    def to_python(cls, ctype_object, *args, **kwargs):
+        return bytes(ctype_object.payload), ctype_object.offset
+
+    @classmethod
+    def from_python(cls, value):
+        raise ParseError('Send unwrapped data.')
+
+
+class CollectionObject(ObjectArrayObject):
+    """
+    Just like object array, but contains deserialization type hint instead of
+    type id. This hint is also useless in Python, because the list type along
+    covers all the use cases.
+
+    Also represented as tuple(type_id, iterable of any type) in Python.
+    """
+    type_code = TC_COLLECTION
+    type_or_id_name = 'type'
+    pythonic = list
+    default = []
+
+    @classmethod
+    def build_header(cls):
+        return type(
+            cls.__name__+'Header',
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('type_code', ctypes.c_byte),
+                    ('length', ctypes.c_int),
+                    ('type', ctypes.c_byte),
+                ],
+            }
+        )
+
+
+class Map:
+    """
+    Dictionary type, payload-only.
+
+    Ignite does not track the order of key-value pairs in its caches, hence
+    the ordinary Python dict type, not the collections.OrderedDict.
+    """
+    HASH_MAP = 1
+    LINKED_HASH_MAP = 2
+
+    @classmethod
+    def build_header(cls):
+        return type(
+            cls.__name__+'Header',
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('length', ctypes.c_int),
+                ],
+            }
+        )
+
+    @classmethod
+    def parse(cls, client: 'Client'):
+        header_class = cls.build_header()
+        buffer = client.recv(ctypes.sizeof(header_class))
+        header = header_class.from_buffer_copy(buffer)
+        fields = []
+
+        for i in range(header.length << 1):
+            c_type, buffer_fragment = AnyDataObject.parse(client)
+            buffer += buffer_fragment
+            fields.append(('element_{}'.format(i), c_type))
+
+        final_class = type(
+            cls.__name__,
+            (header_class,),
+            {
+                '_pack_': 1,
+                '_fields_': fields,
+            }
+        )
+        return final_class, buffer
+
+    @classmethod
+    def to_python(cls, ctype_object, *args, **kwargs):
+        map_type = getattr(ctype_object, 'type', cls.HASH_MAP)
+        result = OrderedDict() if map_type == cls.LINKED_HASH_MAP else {}
+
+        for i in range(0, ctype_object.length << 1, 2):
+            k = AnyDataObject.to_python(
+                    getattr(ctype_object, 'element_{}'.format(i)),
+                    *args, **kwargs
+                )
+            v = AnyDataObject.to_python(
+                    getattr(ctype_object, 'element_{}'.format(i + 1)),
+                    *args, **kwargs
+                )
+            result[k] = v
+        return result
+
+    @classmethod
+    def from_python(cls, value, type_id=None):
+        header_class = cls.build_header()
+        header = header_class()
+        length = len(value)
+        header.length = length
+        if hasattr(header, 'type_code'):
+            header.type_code = int.from_bytes(
+                cls.type_code,
+                byteorder=PROTOCOL_BYTE_ORDER
+            )
+        if hasattr(header, 'type'):
+            header.type = type_id
+        buffer = bytes(header)
+
+        for k, v in value.items():
+            if is_hinted(k):
+                buffer += k[1].from_python(k[0])
+            else:
+                buffer += AnyDataObject.from_python(k)
+            if is_hinted(v):
+                buffer += v[1].from_python(v[0])
+            else:
+                buffer += AnyDataObject.from_python(v)
+        return buffer
+
+
+class MapObject(Map):
+    """
+    This is a dictionary type. Type conversion hint can be a `HASH_MAP`
+    (ordinary dict) or `LINKED_HASH_MAP` (collections.OrderedDict).
+
+    Keys and values in map are independent data objects, but `count`
+    counts pairs. Very annoying.
+    """
+    type_code = TC_MAP
+    pythonic = dict
+    default = {}
+
+    @classmethod
+    def build_header(cls):
+        return type(
+            cls.__name__+'Header',
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('type_code', ctypes.c_byte),
+                    ('length', ctypes.c_int),
+                    ('type', ctypes.c_byte),
+                ],
+            }
+        )
+
+    @classmethod
+    def to_python(cls, ctype_object, *args, **kwargs):
+        return ctype_object.type, super().to_python(
+            ctype_object, *args, **kwargs
+        )
+
+    @classmethod
+    def from_python(cls, value):
+        type_id, value = value
+        return super().from_python(value, type_id)
+
+
+class BinaryObject:
+    type_code = TC_COMPLEX_OBJECT
+
+    USER_TYPE = 0x0001
+    HAS_SCHEMA = 0x0002
+    HAS_RAW_DATA = 0x0004
+    OFFSET_ONE_BYTE = 0x0008
+    OFFSET_TWO_BYTES = 0x0010
+    COMPACT_FOOTER = 0x0020
+
+    @classmethod
+    def build_header(cls):
+        return type(
+            cls.__name__,
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('type_code', ctypes.c_byte),
+                    ('version', ctypes.c_byte),
+                    ('flags', ctypes.c_short),
+                    ('type_id', ctypes.c_int),
+                    ('hash_code', ctypes.c_int),
+                    ('length', ctypes.c_int),
+                    ('schema_id', ctypes.c_int),
+                    ('schema_offset', ctypes.c_int),
+                ],
+            }
+        )
+
+    @classmethod
+    def offset_c_type(cls, flags: int):
+        if flags & cls.OFFSET_ONE_BYTE:
+            return ctypes.c_ubyte
+        if flags & cls.OFFSET_TWO_BYTES:
+            return ctypes.c_uint16
+        return ctypes.c_uint
+
+    @classmethod
+    def schema_type(cls, flags: int):
+        if flags & cls.COMPACT_FOOTER:
+            return cls.offset_c_type(flags)
+        return type(
+            'SchemaElement',
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('field_id', ctypes.c_int),
+                    ('offset', cls.offset_c_type(flags)),
+                ],
+            },
+        )
+
+    @staticmethod
+    def get_dataclass(client: 'Client', header) -> OrderedDict:
+        # get field names from outer space
+        temp_conn = client.clone()
+        result = temp_conn.query_binary_type(header.type_id, header.schema_id)
+        temp_conn.close()
+        if not result:
+            raise ParseError('Binary type is not registered')
+        return result
+
+    @classmethod
+    def parse(cls, client: 'Client'):
+        from pyignite.datatypes import Struct
+
+        header_class = cls.build_header()
+        buffer = client.recv(ctypes.sizeof(header_class))
+        header = header_class.from_buffer_copy(buffer)
+
+        # ignore full schema, always retrieve fields' types and order
+        # from complex types registry
+        data_class = cls.get_dataclass(client, header)
+        fields = data_class.schema.items()
+        object_fields_struct = Struct(fields)
+        object_fields, object_fields_buffer = object_fields_struct.parse(client)
+        buffer += object_fields_buffer
+        final_class_fields = [('object_fields', object_fields)]
+
+        if header.flags & cls.HAS_SCHEMA:
+            schema = cls.schema_type(header.flags) * len(fields)
+            buffer += client.recv(ctypes.sizeof(schema))
+            final_class_fields.append(('schema', schema))
+
+        final_class = type(
+            cls.__name__,
+            (header_class,),
+            {
+                '_pack_': 1,
+                '_fields_': final_class_fields,
+            }
+        )
+        # register schema encoding approach
+        client.compact_footer = bool(header.flags & cls.COMPACT_FOOTER)
+        return final_class, buffer
+
+    @classmethod
+    def to_python(cls, ctype_object, client: 'Client'=None, *args, **kwargs):
+
+        if not client:
+            raise ParseError(
+                'Can not query binary type {}'.format(ctype_object.type_id)
+            )
+
+        data_class = client.query_binary_type(
+            ctype_object.type_id,
+            ctype_object.schema_id
+        )
+        result = data_class()
+
+        result.version = ctype_object.version
+        for field_name, field_type in data_class.schema.items():
+            setattr(
+                result, field_name, field_type.to_python(
+                    getattr(ctype_object.object_fields, field_name),
+                    client, *args, **kwargs
+                )
+            )
+        return result
+
+    @classmethod
+    def from_python(cls, value: object):
+
+        def find_client():
+            """
+            A nice hack. Extracts the nearest `Client` instance from the
+            call stack.
+            """
+            from pyignite import Client
+
+            frame = None
+            try:
+                for rec in inspect.stack()[2:]:
+                    frame = rec[0]
+                    code = frame.f_code
+                    for varname in code.co_varnames:
+                        suspect = frame.f_locals[varname]
+                        if isinstance(suspect, Client):
+                            return suspect
+            finally:
+                del frame
+
+        compact_footer = True  # this is actually used
+        client = find_client()
+        if client:
+            # if no client can be found, the class of the `value` is discarded
+            # and the new dataclass is automatically registered later on
+            client.register_binary_type(value.__class__)
+            compact_footer = client.compact_footer
+        else:
+            raise Warning(
+                'Can not register binary type {}'.format(value.type_name)
+            )
+
+        # prepare header
+        header_class = cls.build_header()
+        header = header_class()
+        header.type_code = int.from_bytes(
+            cls.type_code,
+            byteorder=PROTOCOL_BYTE_ORDER
+        )
+
+        header.flags = cls.USER_TYPE | cls.HAS_SCHEMA
+        if compact_footer:
+            header.flags |= cls.COMPACT_FOOTER
+        header.version = value.version
+        header.type_id = value.type_id
+        header.schema_id = value.schema_id
+
+        # create fields and calculate offsets
+        field_buffer = b''
+        offsets = [ctypes.sizeof(header_class)]
+        schema_items = list(value.schema.items())
+        for field_name, field_type in schema_items:
+            partial_buffer = field_type.from_python(
+                getattr(
+                    value, field_name, getattr(field_type, 'default', None)
+                )
+            )
+            offsets.append(max(offsets) + len(partial_buffer))
+            field_buffer += partial_buffer
+
+        offsets = offsets[:-1]
+
+        # create footer
+        if max(offsets, default=0) < 255:
+            header.flags |= cls.OFFSET_ONE_BYTE
+        elif max(offsets) < 65535:
+            header.flags |= cls.OFFSET_TWO_BYTES
+        schema_class = cls.schema_type(header.flags) * len(offsets)
+        schema = schema_class()
+        if compact_footer:
+            for i, offset in enumerate(offsets):
+                schema[i] = offset
+        else:
+            for i, offset in enumerate(offsets):
+                schema[i].field_id = entity_id(schema_items[i][0])
+                schema[i].offset = offset
+        # calculate size and hash code
+        header.schema_offset = ctypes.sizeof(header_class) + len(field_buffer)
+        header.length = header.schema_offset + ctypes.sizeof(schema_class)
+        header.hash_code = hashcode(field_buffer + bytes(schema))
+
+        return bytes(header) + field_buffer + bytes(schema)
diff --git a/pyignite/datatypes/internal.py b/pyignite/datatypes/internal.py
new file mode 100644
index 0000000..a363a5f
--- /dev/null
+++ b/pyignite/datatypes/internal.py
@@ -0,0 +1,461 @@
+# 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 collections import OrderedDict
+import ctypes
+import decimal
+from datetime import date, datetime, timedelta
+from typing import Any, Tuple
+import uuid
+
+import attr
+
+from pyignite.constants import *
+from pyignite.exceptions import ParseError
+from pyignite.utils import is_binary, is_hinted, is_iterable
+from .type_codes import *
+
+
+__all__ = ['AnyDataArray', 'AnyDataObject', 'Struct', 'StructArray', 'tc_map']
+
+
+def tc_map(key: bytes, _memo_map: dict={}):
+    """
+    Returns a default parser/generator class for the given type code.
+
+    This mapping is used internally inside listed complex parser/generator
+    classes, so it has to be a function. Local imports are used for the same
+    reason.
+
+    :param key: Ignite type code,
+    :param _memo_map: do not use this parameter, it is for memoization
+     of the “type code-type class” mapping,
+    :return: parser/generator class for the type code.
+    """
+    if not _memo_map:
+        from pyignite.datatypes import (
+            Null, ByteObject, ShortObject, IntObject, LongObject, FloatObject,
+            DoubleObject, CharObject, BoolObject, UUIDObject, DateObject,
+            TimestampObject, TimeObject, EnumObject, BinaryEnumObject,
+            ByteArrayObject, ShortArrayObject, IntArrayObject, LongArrayObject,
+            FloatArrayObject, DoubleArrayObject, CharArrayObject,
+            BoolArrayObject,
+            UUIDArrayObject, DateArrayObject, TimestampArrayObject,
+            TimeArrayObject, EnumArrayObject, String, StringArrayObject,
+            DecimalObject, DecimalArrayObject, ObjectArrayObject,
+            CollectionObject,
+            MapObject, BinaryObject, WrappedDataObject,
+        )
+
+        _memo_map = {
+            TC_NULL: Null,
+
+            TC_BYTE: ByteObject,
+            TC_SHORT: ShortObject,
+            TC_INT: IntObject,
+            TC_LONG: LongObject,
+            TC_FLOAT: FloatObject,
+            TC_DOUBLE: DoubleObject,
+            TC_CHAR: CharObject,
+            TC_BOOL: BoolObject,
+
+            TC_UUID: UUIDObject,
+            TC_DATE: DateObject,
+            TC_TIMESTAMP: TimestampObject,
+            TC_TIME: TimeObject,
+            TC_ENUM: EnumObject,
+            TC_BINARY_ENUM: BinaryEnumObject,
+
+            TC_BYTE_ARRAY: ByteArrayObject,
+            TC_SHORT_ARRAY: ShortArrayObject,
+            TC_INT_ARRAY: IntArrayObject,
+            TC_LONG_ARRAY: LongArrayObject,
+            TC_FLOAT_ARRAY: FloatArrayObject,
+            TC_DOUBLE_ARRAY: DoubleArrayObject,
+            TC_CHAR_ARRAY: CharArrayObject,
+            TC_BOOL_ARRAY: BoolArrayObject,
+
+            TC_UUID_ARRAY: UUIDArrayObject,
+            TC_DATE_ARRAY: DateArrayObject,
+            TC_TIMESTAMP_ARRAY: TimestampArrayObject,
+            TC_TIME_ARRAY: TimeArrayObject,
+            TC_ENUM_ARRAY: EnumArrayObject,
+
+            TC_STRING: String,
+            TC_STRING_ARRAY: StringArrayObject,
+            TC_DECIMAL: DecimalObject,
+            TC_DECIMAL_ARRAY: DecimalArrayObject,
+
+            TC_OBJECT_ARRAY: ObjectArrayObject,
+            TC_COLLECTION: CollectionObject,
+            TC_MAP: MapObject,
+
+            TC_COMPLEX_OBJECT: BinaryObject,
+            TC_ARRAY_WRAPPED_OBJECTS: WrappedDataObject,
+        }
+    return _memo_map[key]
+
+
+@attr.s
+class StructArray:
+    """ `counter_type` counter, followed by count*following structure. """
+    following = attr.ib(type=list, factory=list)
+    counter_type = attr.ib(default=ctypes.c_int)
+    defaults = attr.ib(type=dict, default={})
+
+    def build_header_class(self):
+        return type(
+            self.__class__.__name__+'Header',
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('length', self.counter_type),
+                ],
+            },
+        )
+
+    def parse(self, client: 'Client'):
+        buffer = client.recv(ctypes.sizeof(self.counter_type))
+        length = int.from_bytes(buffer, byteorder=PROTOCOL_BYTE_ORDER)
+        fields = []
+
+        for i in range(length):
+            c_type, buffer_fragment = Struct(self.following).parse(client)
+            buffer += buffer_fragment
+            fields.append(('element_{}'.format(i), c_type))
+
+        data_class = type(
+            'StructArray',
+            (self.build_header_class(),),
+            {
+                '_pack_': 1,
+                '_fields_': fields,
+            },
+        )
+
+        return data_class, buffer
+
+    def to_python(self, ctype_object, *args, **kwargs):
+        result = []
+        length = getattr(ctype_object, 'length', 0)
+        for i in range(length):
+            result.append(
+                Struct(
+                    self.following, dict_type=dict
+                ).to_python(
+                    getattr(ctype_object, 'element_{}'.format(i)),
+                    *args, **kwargs
+                )
+            )
+        return result
+
+    def from_python(self, value):
+        length = len(value)
+        header_class = self.build_header_class()
+        header = header_class()
+        header.length = length
+        buffer = bytes(header)
+
+        for i, v in enumerate(value):
+            for default_key, default_value in self.defaults.items():
+                v.setdefault(default_key, default_value)
+            for name, el_class in self.following:
+                buffer += el_class.from_python(v[name])
+
+        return buffer
+
+
+@attr.s
+class Struct:
+    """ Sequence of fields, including variable-sized and nested. """
+    fields = attr.ib(type=list)
+    dict_type = attr.ib(default=OrderedDict)
+    defaults = attr.ib(type=dict, default={})
+
+    def parse(self, client: 'Client') -> Tuple[type, bytes]:
+        buffer = b''
+        fields = []
+
+        for name, c_type in self.fields:
+            c_type, buffer_fragment = c_type.parse(client)
+            buffer += buffer_fragment
+
+            fields.append((name, c_type))
+
+        data_class = type(
+            'Struct',
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': fields,
+            },
+        )
+
+        return data_class, buffer
+
+    def to_python(self, ctype_object, *args, **kwargs) -> Any:
+        result = self.dict_type()
+        for name, c_type in self.fields:
+            result[name] = c_type.to_python(
+                getattr(ctype_object, name),
+                *args, **kwargs
+            )
+        return result
+
+    def from_python(self, value) -> bytes:
+        buffer = b''
+
+        for default_key, default_value in self.defaults.items():
+            value.setdefault(default_key, default_value)
+
+        for name, el_class in self.fields:
+            buffer += el_class.from_python(value[name])
+
+        return buffer
+
+
+class AnyDataObject:
+    """
+    Not an actual Ignite type, but contains a guesswork
+    on serializing Python data or parsing an unknown Ignite data object.
+    """
+    _python_map = None
+    _python_array_map = None
+
+    @staticmethod
+    def get_subtype(iterable, allow_none=False):
+        # arrays of these types can contain Null objects
+        object_array_python_types = [
+            str,
+            datetime,
+            timedelta,
+            decimal.Decimal,
+            uuid.UUID,
+        ]
+
+        iterator = iter(iterable)
+        type_first = type(None)
+        try:
+            while isinstance(None, type_first):
+                type_first = type(next(iterator))
+        except StopIteration:
+            raise TypeError(
+                'Can not represent an empty iterable '
+                'or an iterable of `NoneType` in Ignite type.'
+            )
+
+        if type_first in object_array_python_types:
+            allow_none = True
+
+        # if an iterable contains items of more than one non-nullable type,
+        # return None
+        if all([
+            isinstance(x, type_first)
+            or ((x is None) and allow_none) for x in iterator
+        ]):
+            return type_first
+
+    @classmethod
+    def parse(cls, client: 'Client'):
+        type_code = client.recv(ctypes.sizeof(ctypes.c_byte))
+        try:
+            data_class = tc_map(type_code)
+        except KeyError:
+            raise ParseError('Unknown type code: `{}`'.format(type_code))
+        client.prefetch += type_code
+        return data_class.parse(client)
+
+    @classmethod
+    def to_python(cls, ctype_object, *args, **kwargs):
+        type_code = ctype_object.type_code.to_bytes(
+            ctypes.sizeof(ctypes.c_byte),
+            byteorder=PROTOCOL_BYTE_ORDER
+        )
+        data_class = tc_map(type_code)
+        return data_class.to_python(ctype_object)
+
+    @classmethod
+    def _init_python_map(cls):
+        """
+        Optimizes Python types→Ignite types map creation for speed.
+
+        Local imports seem inevitable here.
+        """
+        from pyignite.datatypes import (
+            LongObject, DoubleObject, String, BoolObject, Null, UUIDObject,
+            DateObject, TimeObject, DecimalObject,
+        )
+
+        cls._python_map = {
+            int: LongObject,
+            float: DoubleObject,
+            str: String,
+            bytes: String,
+            bool: BoolObject,
+            type(None): Null,
+            uuid.UUID: UUIDObject,
+            datetime: DateObject,
+            date: DateObject,
+            timedelta: TimeObject,
+            decimal.Decimal: DecimalObject,
+        }
+
+    @classmethod
+    def _init_python_array_map(cls):
+        """
+        Optimizes  Python types→Ignite array types map creation for speed.
+        """
+        from pyignite.datatypes import (
+            LongArrayObject, DoubleArrayObject, StringArrayObject,
+            BoolArrayObject, UUIDArrayObject, DateArrayObject, TimeArrayObject,
+            DecimalArrayObject,
+        )
+
+        cls._python_array_map = {
+            int: LongArrayObject,
+            float: DoubleArrayObject,
+            str: StringArrayObject,
+            bytes: StringArrayObject,
+            bool: BoolArrayObject,
+            uuid.UUID: UUIDArrayObject,
+            datetime: DateArrayObject,
+            date: DateArrayObject,
+            timedelta: TimeArrayObject,
+            decimal.Decimal: DecimalArrayObject,
+        }
+
+    @classmethod
+    def map_python_type(cls, value):
+        from pyignite.datatypes import (
+            MapObject, ObjectArrayObject, BinaryObject,
+        )
+
+        if cls._python_map is None:
+            cls._init_python_map()
+        if cls._python_array_map is None:
+            cls._init_python_array_map()
+
+        value_type = type(value)
+        if is_iterable(value) and value_type is not str:
+            value_subtype = cls.get_subtype(value)
+            if value_subtype in cls._python_array_map:
+                return cls._python_array_map[value_subtype]
+
+            # a little heuristics (order may be important)
+            if all([
+                value_subtype is None,
+                len(value) == 2,
+                isinstance(value[0], int),
+                isinstance(value[1], dict),
+            ]):
+                return MapObject
+
+            if all([
+                value_subtype is None,
+                len(value) == 2,
+                isinstance(value[0], int),
+                is_iterable(value[1]),
+            ]):
+                return ObjectArrayObject
+
+            raise TypeError(
+                'Type `array of {}` is invalid'.format(value_subtype)
+            )
+
+        if is_binary(value):
+            return BinaryObject
+
+        if value_type in cls._python_map:
+            return cls._python_map[value_type]
+        raise TypeError(
+            'Type `{}` is invalid.'.format(value_type)
+        )
+
+    @classmethod
+    def from_python(cls, value):
+        return cls.map_python_type(value).from_python(value)
+
+
+@attr.s
+class AnyDataArray(AnyDataObject):
+    """
+    Sequence of AnyDataObjects, payload-only.
+    """
+    counter_type = attr.ib(default=ctypes.c_int)
+
+    def build_header(self):
+        return type(
+            self.__class__.__name__+'Header',
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('length', self.counter_type),
+                ],
+            }
+        )
+
+    def parse(self, client: 'Client'):
+        header_class = self.build_header()
+        buffer = client.recv(ctypes.sizeof(header_class))
+        header = header_class.from_buffer_copy(buffer)
+        fields = []
+
+        for i in range(header.length):
+            c_type, buffer_fragment = super().parse(client)
+            buffer += buffer_fragment
+            fields.append(('element_{}'.format(i), c_type))
+
+        final_class = type(
+            self.__class__.__name__,
+            (header_class,),
+            {
+                '_pack_': 1,
+                '_fields_': fields,
+            }
+        )
+        return final_class, buffer
+
+    @classmethod
+    def to_python(cls, ctype_object, *args, **kwargs):
+        result = []
+        for i in range(ctype_object.length):
+            result.append(
+                super().to_python(
+                    getattr(ctype_object, 'element_{}'.format(i)),
+                    *args, **kwargs
+                )
+            )
+        return result
+
+    def from_python(self, value):
+        header_class = self.build_header()
+        header = header_class()
+
+        try:
+            length = len(value)
+        except TypeError:
+            value = [value]
+            length = 1
+        header.length = length
+        buffer = bytes(header)
+
+        for x in value:
+            if is_hinted(x):
+                buffer += x[1].from_python(x[0])
+            else:
+                buffer += super().from_python(x)
+        return buffer
diff --git a/pyignite/datatypes/key_value.py b/pyignite/datatypes/key_value.py
new file mode 100644
index 0000000..0f21ac6
--- /dev/null
+++ b/pyignite/datatypes/key_value.py
@@ -0,0 +1,24 @@
+# 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 .primitive_arrays import ByteArray
+
+
+class PeekModes(ByteArray):
+
+    ALL = 0
+    NEAR = 1
+    PRIMARY = 2
+    BACKUP = 3
diff --git a/pyignite/datatypes/null_object.py b/pyignite/datatypes/null_object.py
new file mode 100644
index 0000000..9fa1e8f
--- /dev/null
+++ b/pyignite/datatypes/null_object.py
@@ -0,0 +1,63 @@
+# 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.
+
+"""
+Null object.
+
+There can't be null type, because null payload takes exactly 0 bytes.
+"""
+
+import ctypes
+
+from .type_codes import TC_NULL
+
+
+__all__ = ['Null']
+
+
+class Null:
+    default = None
+    pythonic = type(None)
+    _object_c_type = None
+
+    @classmethod
+    def build_c_type(cls):
+        if cls._object_c_type is None:
+            cls._object_c_type = type(
+                cls.__name__,
+                (ctypes.LittleEndianStructure,),
+                {
+                    '_pack_': 1,
+                    '_fields_': [
+                        ('type_code', ctypes.c_byte),
+                    ],
+                },
+            )
+        return cls._object_c_type
+
+    @classmethod
+    def parse(cls, client: 'Client'):
+        buffer = client.recv(ctypes.sizeof(ctypes.c_byte))
+        data_type = cls.build_c_type()
+        return data_type, buffer
+
+    @staticmethod
+    def to_python(*args, **kwargs):
+        return None
+
+    @staticmethod
+    def from_python(*args):
+        return TC_NULL
+
diff --git a/pyignite/datatypes/primitive.py b/pyignite/datatypes/primitive.py
new file mode 100644
index 0000000..73f096d
--- /dev/null
+++ b/pyignite/datatypes/primitive.py
@@ -0,0 +1,105 @@
+# 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.
+
+import ctypes
+
+from pyignite.constants import *
+
+
+__all__ = [
+    'Primitive',
+    'Byte', 'Short', 'Int', 'Long', 'Float', 'Double', 'Char', 'Bool',
+]
+
+
+class Primitive:
+    """
+    Ignite primitive type. Base type for the following types:
+
+    - Byte,
+    - Short,
+    - Int,
+    - Long,
+    - Float,
+    - Double,
+    - Char,
+    - Bool.
+    """
+
+    c_type = None
+
+    @classmethod
+    def parse(cls, client: 'Client'):
+        return cls.c_type, client.recv(ctypes.sizeof(cls.c_type))
+
+    @staticmethod
+    def to_python(ctype_object, *args, **kwargs):
+        return ctype_object
+
+    @classmethod
+    def from_python(cls, value):
+        return bytes(cls.c_type(value))
+
+
+class Byte(Primitive):
+    c_type = ctypes.c_byte
+
+
+class Short(Primitive):
+    c_type = ctypes.c_short
+
+
+class Int(Primitive):
+    c_type = ctypes.c_int
+
+
+class Long(Primitive):
+    c_type = ctypes.c_long
+
+
+class Float(Primitive):
+    c_type = ctypes.c_float
+
+
+class Double(Primitive):
+    c_type = ctypes.c_double
+
+
+class Char(Primitive):
+    c_type = ctypes.c_short
+
+    @classmethod
+    def to_python(cls, ctype_object, *args, **kwargs):
+        return ctype_object.value.to_bytes(
+            ctypes.sizeof(cls.c_type),
+            byteorder=PROTOCOL_BYTE_ORDER
+        ).decode(PROTOCOL_CHAR_ENCODING)
+
+    @classmethod
+    def from_python(cls, value):
+        if type(value) is str:
+            value = value.encode(PROTOCOL_CHAR_ENCODING)
+        # assuming either a bytes or an integer
+        if type(value) is bytes:
+            value = int.from_bytes(value, byteorder=PROTOCOL_BYTE_ORDER)
+        # assuming a valid integer
+        return value.to_bytes(
+            ctypes.sizeof(cls.c_type),
+            byteorder=PROTOCOL_BYTE_ORDER
+        )
+
+
+class Bool(Primitive):
+    c_type = ctypes.c_bool
diff --git a/pyignite/datatypes/primitive_arrays.py b/pyignite/datatypes/primitive_arrays.py
new file mode 100644
index 0000000..83a2b4c
--- /dev/null
+++ b/pyignite/datatypes/primitive_arrays.py
@@ -0,0 +1,207 @@
+# 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.
+
+import ctypes
+
+from pyignite.constants import *
+from .primitive import *
+from .type_codes import *
+
+
+__all__ = [
+    'ByteArray', 'ByteArrayObject', 'ShortArray', 'ShortArrayObject',
+    'IntArray', 'IntArrayObject', 'LongArray', 'LongArrayObject',
+    'FloatArray', 'FloatArrayObject', 'DoubleArray', 'DoubleArrayObject',
+    'CharArray', 'CharArrayObject', 'BoolArray', 'BoolArrayObject',
+]
+
+
+class PrimitiveArray:
+    """
+    Base class for array of primitives. Payload-only.
+    """
+    primitive_type = None
+    type_code = None
+
+    @classmethod
+    def build_header_class(cls):
+        return type(
+            cls.__name__+'Header',
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('length', ctypes.c_int),
+                ],
+            }
+        )
+
+    @classmethod
+    def parse(cls, client: 'Client'):
+        header_class = cls.build_header_class()
+        buffer = client.recv(ctypes.sizeof(header_class))
+        header = header_class.from_buffer_copy(buffer)
+        final_class = type(
+            cls.__name__,
+            (header_class,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('data', cls.primitive_type.c_type * header.length),
+                ],
+            }
+        )
+        buffer += client.recv(
+            ctypes.sizeof(final_class) - ctypes.sizeof(header_class)
+        )
+        return final_class, buffer
+
+    @classmethod
+    def to_python(cls, ctype_object, *args, **kwargs):
+        result = []
+        for i in range(ctype_object.length):
+            result.append(ctype_object.data[i])
+        return result
+
+    @classmethod
+    def from_python(cls, value):
+        header_class = cls.build_header_class()
+        header = header_class()
+        if hasattr(header, 'type_code'):
+            header.type_code = int.from_bytes(
+                cls.type_code,
+                byteorder=PROTOCOL_BYTE_ORDER
+            )
+        length = len(value)
+        header.length = length
+        buffer = bytes(header)
+
+        for x in value:
+            buffer += cls.primitive_type.from_python(x)
+        return buffer
+
+
+class ByteArray(PrimitiveArray):
+    primitive_type = Byte
+    type_code = TC_BYTE_ARRAY
+
+
+class ShortArray(PrimitiveArray):
+    primitive_type = Short
+    type_code = TC_SHORT_ARRAY
+
+
+class IntArray(PrimitiveArray):
+    primitive_type = Int
+    type_code = TC_INT_ARRAY
+
+
+class LongArray(PrimitiveArray):
+    primitive_type = Long
+    type_code = TC_LONG_ARRAY
+
+
+class FloatArray(PrimitiveArray):
+    primitive_type = Float
+    type_code = TC_FLOAT_ARRAY
+
+
+class DoubleArray(PrimitiveArray):
+    primitive_type = Double
+    type_code = TC_DOUBLE_ARRAY
+
+
+class CharArray(PrimitiveArray):
+    primitive_type = Char
+    type_code = TC_CHAR_ARRAY
+
+
+class BoolArray(PrimitiveArray):
+    primitive_type = Bool
+    type_code = TC_BOOL_ARRAY
+
+
+class PrimitiveArrayObject(PrimitiveArray):
+    """
+    Base class for primitive array object. Type code plus payload.
+    """
+    pythonic = list
+    default = []
+
+    @classmethod
+    def build_header_class(cls):
+        return type(
+            cls.__name__+'Header',
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('type_code', ctypes.c_byte),
+                    ('length', ctypes.c_int),
+                ],
+            }
+        )
+
+
+class ByteArrayObject(PrimitiveArrayObject):
+    primitive_type = Byte
+    type_code = TC_BYTE_ARRAY
+
+
+class ShortArrayObject(PrimitiveArrayObject):
+    primitive_type = Short
+    type_code = TC_SHORT_ARRAY
+
+
+class IntArrayObject(PrimitiveArrayObject):
+    primitive_type = Int
+    type_code = TC_INT_ARRAY
+
+
+class LongArrayObject(PrimitiveArrayObject):
+    primitive_type = Long
+    type_code = TC_LONG_ARRAY
+
+
+class FloatArrayObject(PrimitiveArrayObject):
+    primitive_type = Float
+    type_code = TC_FLOAT_ARRAY
+
+
+class DoubleArrayObject(PrimitiveArrayObject):
+    primitive_type = Double
+    type_code = TC_DOUBLE_ARRAY
+
+
+class CharArrayObject(PrimitiveArrayObject):
+    primitive_type = Char
+    type_code = TC_CHAR_ARRAY
+
+    @classmethod
+    def to_python(cls, ctype_object, *args, **kwargs):
+        values = super().to_python(ctype_object, *args, **kwargs)
+        return [
+            v.to_bytes(
+                ctypes.sizeof(cls.primitive_type.c_type),
+                byteorder=PROTOCOL_BYTE_ORDER
+            ).decode(
+                PROTOCOL_CHAR_ENCODING
+            ) for v in values
+        ]
+
+
+class BoolArrayObject(PrimitiveArrayObject):
+    primitive_type = Bool
+    type_code = TC_BOOL_ARRAY
diff --git a/pyignite/datatypes/primitive_objects.py b/pyignite/datatypes/primitive_objects.py
new file mode 100644
index 0000000..53b54b3
--- /dev/null
+++ b/pyignite/datatypes/primitive_objects.py
@@ -0,0 +1,157 @@
+# 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.
+
+import ctypes
+
+from pyignite.constants import *
+from .type_codes import *
+
+
+__all__ = [
+    'DataObject', 'ByteObject', 'ShortObject', 'IntObject', 'LongObject',
+    'FloatObject', 'DoubleObject', 'CharObject', 'BoolObject',
+]
+
+
+class DataObject:
+    """
+    Base class for primitive data objects.
+
+    Primitive data objects are built of primitive data prepended by
+    the corresponding type code.
+    """
+
+    c_type = None
+    type_code = None
+    _object_c_type = None
+
+    @classmethod
+    def build_c_type(cls):
+        if cls._object_c_type is None:
+            cls._object_c_type = type(
+                cls.__name__,
+                (ctypes.LittleEndianStructure,),
+                {
+                    '_pack_': 1,
+                    '_fields_': [
+                        ('type_code', ctypes.c_byte),
+                        ('value', cls.c_type),
+                    ],
+                },
+            )
+        return cls._object_c_type
+
+    @classmethod
+    def parse(cls, client: 'Client'):
+        data_type = cls.build_c_type()
+        buffer = client.recv(ctypes.sizeof(data_type))
+        return data_type, buffer
+
+    @staticmethod
+    def to_python(ctype_object, *args, **kwargs):
+        return ctype_object.value
+
+    @classmethod
+    def from_python(cls, value):
+        data_type = cls.build_c_type()
+        data_object = data_type()
+        data_object.type_code = int.from_bytes(
+            cls.type_code,
+            byteorder=PROTOCOL_BYTE_ORDER
+        )
+        data_object.value = value
+        return bytes(data_object)
+
+
+class ByteObject(DataObject):
+    c_type = ctypes.c_byte
+    type_code = TC_BYTE
+    pythonic = int
+    default = 0
+
+
+class ShortObject(DataObject):
+    c_type = ctypes.c_short
+    type_code = TC_SHORT
+    pythonic = int
+    default = 0
+
+
+class IntObject(DataObject):
+    c_type = ctypes.c_int
+    type_code = TC_INT
+    pythonic = int
+    default = 0
+
+
+class LongObject(DataObject):
+    c_type = ctypes.c_long
+    type_code = TC_LONG
+    pythonic = int
+    default = 0
+
+
+class FloatObject(DataObject):
+    c_type = ctypes.c_float
+    type_code = TC_FLOAT
+    pythonic = float
+    default = 0.0
+
+
+class DoubleObject(DataObject):
+    c_type = ctypes.c_double
+    type_code = TC_DOUBLE
+    pythonic = float
+    default = 0.0
+
+
+class CharObject(DataObject):
+    """
+    This type is a little tricky. It stores character values in
+    UTF-16 Little-endian encoding. We have to encode/decode it
+    to/from UTF-8 to keep the coding hassle to minimum. Bear in mind
+    though: decoded character may take 1..4 bytes in UTF-8.
+    """
+    c_type = ctypes.c_short
+    type_code = TC_CHAR
+    pythonic = str
+    default = ' '
+
+    @classmethod
+    def to_python(cls, ctype_object, *args, **kwargs):
+        return ctype_object.value.to_bytes(
+            ctypes.sizeof(cls.c_type),
+            byteorder=PROTOCOL_BYTE_ORDER
+        ).decode(PROTOCOL_CHAR_ENCODING)
+
+    @classmethod
+    def from_python(cls, value):
+        if type(value) is str:
+            value = value.encode(PROTOCOL_CHAR_ENCODING)
+        # assuming either a bytes or an integer
+        if type(value) is bytes:
+            value = int.from_bytes(value, byteorder=PROTOCOL_BYTE_ORDER)
+        # assuming a valid integer
+        return cls.type_code + value.to_bytes(
+            ctypes.sizeof(cls.c_type),
+            byteorder=PROTOCOL_BYTE_ORDER
+        )
+
+
+class BoolObject(DataObject):
+    c_type = ctypes.c_bool
+    type_code = TC_BOOL
+    pythonic = bool
+    default = False
diff --git a/pyignite/datatypes/prop_codes.py b/pyignite/datatypes/prop_codes.py
new file mode 100644
index 0000000..adea281
--- /dev/null
+++ b/pyignite/datatypes/prop_codes.py
@@ -0,0 +1,51 @@
+# 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.
+
+PROP_NAME = 0
+PROP_CACHE_MODE = 1
+PROP_CACHE_ATOMICITY_MODE = 2
+PROP_BACKUPS_NUMBER = 3
+PROP_WRITE_SYNCHRONIZATION_MODE = 4
+PROP_COPY_ON_READ = 5
+PROP_READ_FROM_BACKUP = 6
+
+PROP_DATA_REGION_NAME = 100
+PROP_IS_ONHEAP_CACHE_ENABLED = 101
+
+PROP_QUERY_ENTITIES = 200
+PROP_QUERY_PARALLELISM = 201
+PROP_QUERY_DETAIL_METRIC_SIZE = 202
+PROP_SQL_SCHEMA = 203
+PROP_SQL_INDEX_INLINE_MAX_SIZE = 204
+PROP_SQL_ESCAPE_ALL = 205
+PROP_MAX_QUERY_ITERATORS = 206
+
+PROP_REBALANCE_MODE = 300
+PROP_REBALANCE_DELAY = 301
+PROP_REBALANCE_TIMEOUT = 302
+PROP_REBALANCE_BATCH_SIZE = 303
+PROP_REBALANCE_BATCHES_PREFETCH_COUNT = 304
+PROP_REBALANCE_ORDER = 305
+PROP_REBALANCE_THROTTLE = 306
+
+PROP_GROUP_NAME = 400
+PROP_CACHE_KEY_CONFIGURATION = 401
+PROP_DEFAULT_LOCK_TIMEOUT = 402
+PROP_MAX_CONCURRENT_ASYNC_OPERATIONS = 403
+PROP_PARTITION_LOSS_POLICY = 404
+PROP_EAGER_TTL = 405
+PROP_STATISTICS_ENABLED = 406
+
+PROP_INVALIDATE = -1
diff --git a/pyignite/datatypes/sql.py b/pyignite/datatypes/sql.py
new file mode 100644
index 0000000..533349e
--- /dev/null
+++ b/pyignite/datatypes/sql.py
@@ -0,0 +1,23 @@
+# 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 .primitive import Byte
+
+
+class StatementType(Byte):
+
+    ANY = 0
+    SELECT = 1
+    UPDATE = 2
diff --git a/pyignite/datatypes/standard.py b/pyignite/datatypes/standard.py
new file mode 100644
index 0000000..160e06e
--- /dev/null
+++ b/pyignite/datatypes/standard.py
@@ -0,0 +1,713 @@
+# 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.
+
+import ctypes
+from datetime import date, datetime, time, timedelta
+import decimal
+import uuid
+
+from pyignite.constants import *
+from .type_codes import *
+from .null_object import Null
+
+
+__all__ = [
+    'String', 'DecimalObject', 'UUIDObject', 'TimestampObject', 'DateObject',
+    'TimeObject',
+
+    'StringArray', 'DecimalArray', 'UUIDArray', 'TimestampArray', 'DateArray',
+    'TimeArray',
+
+    'StringArrayObject', 'DecimalArrayObject', 'UUIDArrayObject',
+    'TimestampArrayObject', 'TimeArrayObject', 'DateArrayObject',
+
+    'EnumObject', 'EnumArray', 'EnumArrayObject', 'BinaryEnumObject',
+    'BinaryEnumArrayObject', 'ObjectArray',
+]
+
+
+class StandardObject:
+    type_code = None
+
+    @classmethod
+    def build_c_type(cls):
+        raise NotImplementedError('This object is generic')
+
+    @classmethod
+    def parse(cls, client: 'Client'):
+        tc_type = client.recv(ctypes.sizeof(ctypes.c_byte))
+
+        if tc_type == TC_NULL:
+            return Null.build_c_type(), tc_type
+
+        c_type = cls.build_c_type()
+        buffer = tc_type + client.recv(ctypes.sizeof(c_type) - len(tc_type))
+        return c_type, buffer
+
+
+class String:
+    """
+    Pascal-style string: `c_int` counter, followed by count*bytes.
+    UTF-8-encoded, so that one character may take 1 to 4 bytes.
+    """
+    type_code = TC_STRING
+    pythonic = str
+
+    @classmethod
+    def build_c_type(cls, length: int):
+        return type(
+            cls.__name__,
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('type_code', ctypes.c_byte),
+                    ('length', ctypes.c_int),
+                    ('data', ctypes.c_char * length),
+                ],
+            },
+        )
+
+    @classmethod
+    def parse(cls, client: 'Client'):
+        tc_type = client.recv(ctypes.sizeof(ctypes.c_byte))
+        # String or Null
+        if tc_type == TC_NULL:
+            return Null.build_c_type(), tc_type
+
+        buffer = tc_type + client.recv(ctypes.sizeof(ctypes.c_int))
+        length = int.from_bytes(buffer[1:], byteorder=PROTOCOL_BYTE_ORDER)
+
+        data_type = cls.build_c_type(length)
+        buffer += client.recv(ctypes.sizeof(data_type) - len(buffer))
+
+        return data_type, buffer
+
+    @staticmethod
+    def to_python(ctype_object, *args, **kwargs):
+        length = getattr(ctype_object, 'length', None)
+        if length is None:
+            return None
+        elif length > 0:
+            return ctype_object.data.decode(PROTOCOL_STRING_ENCODING)
+        else:
+            return ''
+
+    @classmethod
+    def from_python(cls, value):
+        if value is None:
+            return Null.from_python()
+
+        if isinstance(value, str):
+            value = value.encode(PROTOCOL_STRING_ENCODING)
+        length = len(value)
+        data_type = cls.build_c_type(length)
+        data_object = data_type()
+        data_object.type_code = int.from_bytes(
+            cls.type_code,
+            byteorder=PROTOCOL_BYTE_ORDER
+        )
+        data_object.length = length
+        data_object.data = value
+        return bytes(data_object)
+
+
+class DecimalObject:
+    type_code = TC_DECIMAL
+    pythonic = decimal.Decimal
+    default = decimal.Decimal('0.00')
+
+    @classmethod
+    def build_c_header(cls):
+        return type(
+            cls.__name__,
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('type_code', ctypes.c_byte),
+                    ('scale', ctypes.c_int),
+                    ('length', ctypes.c_int),
+                ],
+            }
+        )
+
+    @classmethod
+    def parse(cls, client: 'Client'):
+        tc_type = client.recv(ctypes.sizeof(ctypes.c_byte))
+        # Decimal or Null
+        if tc_type == TC_NULL:
+            return Null.build_c_type(), tc_type
+
+        header_class = cls.build_c_header()
+        buffer = tc_type + client.recv(
+            ctypes.sizeof(header_class)
+            - len(tc_type)
+        )
+        header = header_class.from_buffer_copy(buffer)
+        data_type = type(
+            cls.__name__,
+            (header_class,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('data', ctypes.c_char * header.length),
+                ],
+            }
+        )
+        buffer += client.recv(
+            ctypes.sizeof(data_type)
+            - ctypes.sizeof(header_class)
+        )
+        return data_type, buffer
+
+    @classmethod
+    def to_python(cls, ctype_object, *args, **kwargs):
+        if getattr(ctype_object, 'length', None) is None:
+            return None
+
+        sign = 1 if ctype_object.data[0] & 0x80 else 0
+        data = bytes([ctype_object.data[0] & 0x7f]) + ctype_object.data[1:]
+        result = decimal.Decimal(data.decode(PROTOCOL_STRING_ENCODING))
+        # apply scale
+        result = (
+            result
+            * decimal.Decimal('10') ** decimal.Decimal(ctype_object.scale)
+        )
+        if sign:
+            # apply sign
+            result = -result
+        return result
+
+    @classmethod
+    def from_python(cls, value: decimal.Decimal):
+        if value is None:
+            return Null.from_python()
+
+        sign, digits, scale = value.normalize().as_tuple()
+        data = bytearray([ord('0') + digit for digit in digits])
+        if sign:
+            data[0] |= 0x80
+        else:
+            data[0] &= 0x7f
+        length = len(digits)
+        header_class = cls.build_c_header()
+        data_class = type(
+            cls.__name__,
+            (header_class,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('data', ctypes.c_char * length),
+                ],
+            }
+        )
+        data_object = data_class()
+        data_object.type_code = int.from_bytes(
+            cls.type_code,
+            byteorder=PROTOCOL_BYTE_ORDER
+        )
+        data_object.length = length
+        data_object.scale = scale
+        data_object.data = bytes(data)
+        return bytes(data_object)
+
+
+class UUIDObject(StandardObject):
+    """
+    Universally unique identifier (UUID), aka Globally unique identifier
+    (GUID). Payload takes up 16 bytes.
+    """
+    type_code = TC_UUID
+    _object_c_type = None
+
+    @classmethod
+    def build_c_type(cls):
+        if cls._object_c_type is None:
+            cls._object_c_type = type(
+                cls.__name__,
+                (ctypes.LittleEndianStructure,),
+                {
+                    '_pack_': 1,
+                    '_fields_': [
+                        ('type_code', ctypes.c_byte),
+                        ('value', ctypes.c_byte * 16),
+                    ],
+                }
+            )
+        return cls._object_c_type
+
+    @classmethod
+    def from_python(cls, value: uuid.UUID):
+        data_type = cls.build_c_type()
+        data_object = data_type()
+        data_object.type_code = int.from_bytes(
+            cls.type_code,
+            byteorder=PROTOCOL_BYTE_ORDER
+        )
+        for i, byte in enumerate(bytearray(value.bytes)):
+            data_object.value[i] = byte
+        return bytes(data_object)
+
+    @classmethod
+    def to_python(cls, ctypes_object, *args, **kwargs):
+        if ctypes_object.type_code == int.from_bytes(
+            TC_NULL,
+            byteorder=PROTOCOL_BYTE_ORDER
+        ):
+            return None
+        return uuid.UUID(bytes=bytes(ctypes_object.value))
+
+
+class TimestampObject(StandardObject):
+    """
+    A signed integer number of milliseconds past 1 Jan 1970, aka Epoch
+    (8 bytes long integer), plus the delta in nanoseconds (4 byte integer,
+    only 0..999 range used).
+
+    The accuracy is ridiculous. For instance, common HPETs have
+    less than 10ms accuracy. Therefore no ns range calculations is made;
+    `epoch` and `fraction` stored separately and represented as
+    tuple(datetime.datetime, integer).
+    """
+    type_code = TC_TIMESTAMP
+    pythonic = tuple
+    default = (datetime(1970, 1, 1), 0)
+    _object_c_type = None
+
+    @classmethod
+    def build_c_type(cls):
+        if cls._object_c_type is None:
+            cls._object_c_type = type(
+                cls.__name__,
+                (ctypes.LittleEndianStructure,),
+                {
+                    '_pack_': 1,
+                    '_fields_': [
+                        ('type_code', ctypes.c_byte),
+                        ('epoch', ctypes.c_long),
+                        ('fraction', ctypes.c_int),
+                    ],
+                }
+            )
+        return cls._object_c_type
+
+    @classmethod
+    def from_python(cls, value: tuple):
+        if value is None:
+            return Null.from_python()
+        data_type = cls.build_c_type()
+        data_object = data_type()
+        data_object.type_code = int.from_bytes(
+            cls.type_code,
+            byteorder=PROTOCOL_BYTE_ORDER
+        )
+        data_object.epoch = int(value[0].timestamp() * 1000)
+        data_object.fraction = value[1]
+        return bytes(data_object)
+
+    @classmethod
+    def to_python(cls, ctypes_object, *args, **kwargs):
+        if ctypes_object.type_code == int.from_bytes(
+            TC_NULL,
+            byteorder=PROTOCOL_BYTE_ORDER
+        ):
+            return None
+        return (
+            datetime.fromtimestamp(ctypes_object.epoch/1000),
+            ctypes_object.fraction
+        )
+
+
+class DateObject(StandardObject):
+    """
+    A signed integer number of milliseconds past 1 Jan 1970, aka Epoch
+    (8 bytes long integer).
+
+    Represented as a naive datetime.datetime in Python.
+    """
+    type_code = TC_DATE
+    pythonic = datetime
+    default = datetime(1970, 1, 1)
+    _object_c_type = None
+
+    @classmethod
+    def build_c_type(cls):
+        if cls._object_c_type is None:
+            cls._object_c_type = type(
+                cls.__name__,
+                (ctypes.LittleEndianStructure,),
+                {
+                    '_pack_': 1,
+                    '_fields_': [
+                        ('type_code', ctypes.c_byte),
+                        ('epoch', ctypes.c_long),
+                    ],
+                }
+            )
+        return cls._object_c_type
+
+    @classmethod
+    def from_python(cls, value: [date, datetime]):
+        if value is None:
+            return Null.from_python()
+        if type(value) is date:
+            value = datetime.combine(value, time())
+        data_type = cls.build_c_type()
+        data_object = data_type()
+        data_object.type_code = int.from_bytes(
+            cls.type_code,
+            byteorder=PROTOCOL_BYTE_ORDER
+        )
+        data_object.epoch = int(value.timestamp() * 1000)
+        return bytes(data_object)
+
+    @classmethod
+    def to_python(cls, ctypes_object, *args, **kwargs):
+        if ctypes_object.type_code == int.from_bytes(
+            TC_NULL,
+            byteorder=PROTOCOL_BYTE_ORDER
+        ):
+            return None
+        return datetime.fromtimestamp(ctypes_object.epoch/1000)
+
+
+class TimeObject(StandardObject):
+    """
+    Time of the day as a number of milliseconds since midnight.
+
+    Represented as a datetime.timedelta in Python.
+    """
+    type_code = TC_TIME
+    pythonic = timedelta
+    default = timedelta()
+    _object_c_type = None
+
+    @classmethod
+    def build_c_type(cls):
+        if cls._object_c_type is None:
+            cls._object_c_type = type(
+                cls.__name__,
+                (ctypes.LittleEndianStructure,),
+                {
+                    '_pack_': 1,
+                    '_fields_': [
+                        ('type_code', ctypes.c_byte),
+                        ('value', ctypes.c_long),
+                    ],
+                }
+            )
+        return cls._object_c_type
+
+    @classmethod
+    def from_python(cls, value: timedelta):
+        if value is None:
+            return Null.from_python()
+        data_type = cls.build_c_type()
+        data_object = data_type()
+        data_object.type_code = int.from_bytes(
+            cls.type_code,
+            byteorder=PROTOCOL_BYTE_ORDER
+        )
+        data_object.value = int(value.total_seconds() * 1000)
+        return bytes(data_object)
+
+    @classmethod
+    def to_python(cls, ctypes_object, *args, **kwargs):
+        if ctypes_object.type_code == int.from_bytes(
+            TC_NULL,
+            byteorder=PROTOCOL_BYTE_ORDER
+        ):
+            return None
+        return timedelta(milliseconds=ctypes_object.value)
+
+
+class EnumObject(StandardObject):
+    """
+    Two integers used as the ID of the enumeration type, and its value.
+
+    This type itself is useless in Python, but can be used for interoperability
+    (using language-specific type serialization is a good way to kill the
+    interoperability though), so it represented by tuple(int, int) in Python.
+    """
+    type_code = TC_ENUM
+    _object_c_type = None
+
+    @classmethod
+    def build_c_type(cls):
+        if cls._object_c_type is None:
+            cls._object_c_type = type(
+                cls.__name__,
+                (ctypes.LittleEndianStructure,),
+                {
+                    '_pack_': 1,
+                    '_fields_': [
+                        ('type_code', ctypes.c_byte),
+                        ('type_id', ctypes.c_int),
+                        ('ordinal', ctypes.c_int),
+                    ],
+                }
+            )
+        return cls._object_c_type
+
+    @classmethod
+    def from_python(cls, value: tuple):
+        if value is None:
+            return Null.from_python()
+
+        data_type = cls.build_c_type()
+        data_object = data_type()
+        data_object.type_code = int.from_bytes(
+            cls.type_code,
+            byteorder=PROTOCOL_BYTE_ORDER
+        )
+        if value is None:
+            return Null.from_python(value)
+        data_object.type_id, data_object.ordinal = value
+        return bytes(data_object)
+
+    @classmethod
+    def to_python(cls, ctypes_object, *args, **kwargs):
+        if ctypes_object.type_code == int.from_bytes(
+            TC_NULL,
+            byteorder=PROTOCOL_BYTE_ORDER
+        ):
+            return None
+        return ctypes_object.type_id, ctypes_object.ordinal
+
+
+class BinaryEnumObject(EnumObject):
+    """
+    Another way of representing the enum type. Same, but different.
+    """
+    type_code = TC_BINARY_ENUM
+
+
+class StandardArray:
+    """
+    Base class for array of primitives. Payload-only.
+    """
+    standard_type = None
+    type_code = None
+
+    @classmethod
+    def build_header_class(cls):
+        return type(
+            cls.__name__+'Header',
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('length', ctypes.c_int),
+                ],
+            }
+        )
+
+    @classmethod
+    def parse(cls, client: 'Client'):
+        header_class = cls.build_header_class()
+        buffer = client.recv(ctypes.sizeof(header_class))
+        header = header_class.from_buffer_copy(buffer)
+        fields = []
+        for i in range(header.length):
+            c_type, buffer_fragment = cls.standard_type.parse(client)
+            buffer += buffer_fragment
+            fields.append(('element_{}'.format(i), c_type))
+
+        final_class = type(
+            cls.__name__,
+            (header_class,),
+            {
+                '_pack_': 1,
+                '_fields_': fields,
+            }
+        )
+        return final_class, buffer
+
+    @classmethod
+    def to_python(cls, ctype_object, *args, **kwargs):
+        result = []
+        for i in range(ctype_object.length):
+            result.append(
+                cls.standard_type.to_python(
+                    getattr(ctype_object, 'element_{}'.format(i)),
+                    *args, **kwargs
+                )
+            )
+        return result
+
+    @classmethod
+    def from_python(cls, value):
+        header_class = cls.build_header_class()
+        header = header_class()
+        if hasattr(header, 'type_code'):
+            header.type_code = int.from_bytes(
+                cls.type_code,
+                byteorder=PROTOCOL_BYTE_ORDER
+            )
+        length = len(value)
+        header.length = length
+        buffer = bytes(header)
+
+        for x in value:
+            buffer += cls.standard_type.from_python(x)
+        return buffer
+
+
+class StringArray(StandardArray):
+    """
+    Array of Pascal-like strings. Payload-only, i.e. no `type_code` field
+    in binary representation.
+
+    List(str) in Python.
+    """
+    standard_type = String
+
+
+class DecimalArray(StandardArray):
+    standard_type = DecimalObject
+
+
+class UUIDArray(StandardArray):
+    standard_type = UUIDObject
+
+
+class TimestampArray(StandardArray):
+    standard_type = TimestampObject
+
+
+class DateArray(StandardArray):
+    standard_type = DateObject
+
+
+class TimeArray(StandardArray):
+    standard_type = TimeObject
+
+
+class EnumArray(StandardArray):
+    standard_type = EnumObject
+
+
+class StandardArrayObject(StandardArray):
+    pythonic = list
+    default = []
+
+    @classmethod
+    def build_header_class(cls):
+        return type(
+            cls.__name__+'Header',
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('type_code', ctypes.c_byte),
+                    ('length', ctypes.c_int),
+                ],
+            }
+        )
+
+
+class StringArrayObject(StandardArrayObject):
+    """ List of strings. """
+    standard_type = String
+    type_code = TC_STRING_ARRAY
+
+
+class DecimalArrayObject(StandardArrayObject):
+    """ List of decimal.Decimal objects. """
+    standard_type = DecimalObject
+    type_code = TC_DECIMAL_ARRAY
+
+
+class UUIDArrayObject(StandardArrayObject):
+    """ Translated into Python as a list(uuid.UUID)"""
+    standard_type = UUIDObject
+    type_code = TC_UUID_ARRAY
+
+
+class TimestampArrayObject(StandardArrayObject):
+    """
+    Translated into Python as a list of (datetime.datetime, integer) tuples.
+    """
+    standard_type = TimestampObject
+    type_code = TC_TIMESTAMP_ARRAY
+
+
+class DateArrayObject(StandardArrayObject):
+    """ List of datetime.datetime type values. """
+    standard_type = DateObject
+    type_code = TC_DATE_ARRAY
+
+
+class TimeArrayObject(StandardArrayObject):
+    """ List of datetime.timedelta type values. """
+    standard_type = TimeObject
+    type_code = TC_TIME_ARRAY
+
+
+class EnumArrayObject(StandardArrayObject):
+    """
+    Array of (int, int) tuples, plus it holds a `type_id` in its header.
+    The only `type_id` value of -1 (user type) works from Python perspective.
+    """
+    standard_type = EnumObject
+    type_code = TC_ENUM_ARRAY
+
+    @classmethod
+    def build_header_class(cls):
+        return type(
+            cls.__name__+'Header',
+            (ctypes.LittleEndianStructure,),
+            {
+                '_pack_': 1,
+                '_fields_': [
+                    ('type_code', ctypes.c_byte),
+                    ('type_id', ctypes.c_int),
+                    ('length', ctypes.c_int),
+                ],
+            }
+        )
+
+    @classmethod
+    def from_python(cls, value):
+        type_id, value = value
+        header_class = cls.build_header_class()
+        header = header_class()
+        if hasattr(header, 'type_code'):
+            header.type_code = int.from_bytes(
+                cls.type_code,
+                byteorder=PROTOCOL_BYTE_ORDER
+            )
+        length = len(value)
+        header.length = length
+        header.type_id = type_id
+        buffer = bytes(header)
+
+        for x in value:
+            buffer += cls.standard_type.from_python(x)
+        return buffer
+
+    @classmethod
+    def to_python(cls, ctype_object, *args, **kwargs):
+        type_id = ctype_object.type_id
+        return type_id, super().to_python(ctype_object, *args, **kwargs)
+
+
+class BinaryEnumArrayObject(EnumArrayObject):
+    standard_type = BinaryEnumObject
+
+
+class ObjectArray(EnumArrayObject):
+    standard_type = BinaryEnumObject
diff --git a/pyignite/datatypes/type_codes.py b/pyignite/datatypes/type_codes.py
new file mode 100644
index 0000000..d5e8dd4
--- /dev/null
+++ b/pyignite/datatypes/type_codes.py
@@ -0,0 +1,57 @@
+# 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.
+
+TC_BYTE = b'\x01'
+TC_SHORT = b'\x02'
+TC_INT = b'\x03'
+TC_LONG = b'\x04'
+TC_FLOAT = b'\x05'
+TC_DOUBLE = b'\x06'
+TC_CHAR = b'\x07'
+TC_BOOL = b'\x08'
+TC_STRING = b'\x09'
+TC_UUID = b'\x0a'
+TC_DATE = b'\x0b'
+TC_BYTE_ARRAY = b'\x0c'
+TC_SHORT_ARRAY = b'\x0d'
+TC_INT_ARRAY = b'\x0e'
+TC_LONG_ARRAY = b'\x0f'
+TC_FLOAT_ARRAY = b'\x10'
+TC_DOUBLE_ARRAY = b'\x11'
+TC_CHAR_ARRAY = b'\x12'
+TC_BOOL_ARRAY = b'\x13'
+TC_STRING_ARRAY = b'\x14'
+TC_UUID_ARRAY = b'\x15'
+TC_DATE_ARRAY = b'\x16'
+TC_OBJECT_ARRAY = b'\x17'
+TC_COLLECTION = b'\x18'
+TC_MAP = b'\x19'
+
+TC_ARRAY_WRAPPED_OBJECTS = b'\x1b'
+
+TC_ENUM = b'\x1c'
+TC_ENUM_ARRAY = b'\x1d'
+
+TC_DECIMAL = b'\x1e'
+TC_DECIMAL_ARRAY = b'\x1f'
+TC_TIMESTAMP = b'\x21'
+TC_TIMESTAMP_ARRAY = b'\x22'
+
+TC_TIME = b'\x24'
+TC_TIME_ARRAY = b'\x25'
+TC_BINARY_ENUM = b'\x26'
+
+TC_NULL = b'\x65'
+TC_COMPLEX_OBJECT = b'\x67'
diff --git a/pyignite/exceptions.py b/pyignite/exceptions.py
new file mode 100644
index 0000000..2bc5996
--- /dev/null
+++ b/pyignite/exceptions.py
@@ -0,0 +1,80 @@
+# 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 socket import error as SocketError
+
+
+class ParseError(Exception):
+    """
+    This exception is raised, when `pyignite` is unable to build a query to,
+    or parse a response from, Ignite node.
+    """
+    pass
+
+
+class HandshakeError(SocketError):
+    """
+    This exception is raised on Ignite binary protocol handshake failure,
+    as defined in
+    https://apacheignite.readme.io/docs/binary-client-protocol#section-handshake
+    """
+    pass
+
+
+class ReconnectError(Exception):
+    """
+    This exception is raised by `Client.reconnect` method, when no more
+    nodes are left to connect to. It is not meant to be an error, but rather
+    a flow control tool, similar to `StopIteration`.
+    """
+    pass
+
+
+class ParameterError(Exception):
+    """
+    This exception represents the parameter validation error in any `pyignite`
+    method.
+    """
+    pass
+
+
+class CacheError(Exception):
+    """
+    This exception is raised, whenever any remote Thin client operation
+    returns an error.
+    """
+    pass
+
+
+class BinaryTypeError(CacheError):
+    """
+    A remote error in operation with Complex Object registry.
+    """
+    pass
+
+
+class CacheCreationError(CacheError):
+    """
+    This exception is raised, when any complex operation failed
+    on cache creation phase.
+    """
+    pass
+
+
+class SQLError(CacheError):
+    """
+    An error in SQL query.
+    """
+    pass
diff --git a/pyignite/queries/__init__.py b/pyignite/queries/__init__.py
new file mode 100644
index 0000000..f43d60e
--- /dev/null
+++ b/pyignite/queries/__init__.py
@@ -0,0 +1,339 @@
+# 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.
+
+"""
+This module is a source of some basic information about the binary protocol.
+
+Most importantly, it contains `Query` and `Response` base classes. They are
+used internally by :mod:`pyignite.api` module. They, in turn, based on
+:mod:`pyignite.datatypes` binary parser/generator classes.
+"""
+
+from collections import OrderedDict
+import ctypes
+from random import randint
+
+import attr
+
+from pyignite.api.result import APIResult
+from pyignite.constants import *
+from pyignite.datatypes import (
+    AnyDataObject, Bool, Int, Long, String, StringArray, Struct,
+)
+from .op_codes import *
+
+
+@attr.s
+class Response:
+    following = attr.ib(type=list, factory=list)
+    _response_header = None
+
+    def __attrs_post_init__(self):
+        # replace None with empty list
+        self.following = self.following or []
+
+    @classmethod
+    def build_header(cls):
+        if cls._response_header is None:
+            cls._response_header = type(
+                'ResponseHeader',
+                (ctypes.LittleEndianStructure,),
+                {
+                    '_pack_': 1,
+                    '_fields_': [
+                        ('length', ctypes.c_int),
+                        ('query_id', ctypes.c_long),
+                        ('status_code', ctypes.c_int),
+                    ],
+                },
+            )
+        return cls._response_header
+
+    def parse(self, client: 'Client'):
+        header_class = self.build_header()
+        buffer = client.recv(ctypes.sizeof(header_class))
+        header = header_class.from_buffer_copy(buffer)
+        fields = []
+
+        if header.status_code == OP_SUCCESS:
+            for name, ignite_type in self.following:
+                c_type, buffer_fragment = ignite_type.parse(client)
+                buffer += buffer_fragment
+                fields.append((name, c_type))
+        else:
+            c_type, buffer_fragment = String.parse(client)
+            buffer += buffer_fragment
+            fields.append(('error_message', c_type))
+
+        response_class = type(
+            'Response',
+            (header_class,),
+            {
+                '_pack_': 1,
+                '_fields_': fields,
+            }
+        )
+        return response_class, buffer
+
+    def to_python(self, ctype_object, *args, **kwargs):
+        result = OrderedDict()
+
+        for name, c_type in self.following:
+            result[name] = c_type.to_python(
+                getattr(ctype_object, name),
+                *args, **kwargs
+            )
+
+        return result if result else None
+
+
+@attr.s
+class SQLResponse(Response):
+    """
+    The response class of SQL functions is special in the way the row-column
+    data is counted in it. Basically, Ignite thin client API is following a
+    “counter right before the counted objects” rule in most of its parts.
+    SQL ops are breaking this rule.
+    """
+    include_field_names = attr.ib(type=bool, default=False)
+    has_cursor = attr.ib(type=bool, default=False)
+
+    def fields_or_field_count(self):
+        if self.include_field_names:
+            return 'fields', StringArray
+        return 'field_count', Int
+
+    def parse(self, client: 'Client'):
+        header_class = self.build_header()
+        buffer = client.recv(ctypes.sizeof(header_class))
+        header = header_class.from_buffer_copy(buffer)
+        fields = []
+
+        if header.status_code == OP_SUCCESS:
+            following = [
+                self.fields_or_field_count(),
+                ('row_count', Int),
+            ]
+            if self.has_cursor:
+                following.insert(0, ('cursor', Long))
+            body_struct = Struct(following)
+            body_class, body_buffer = body_struct.parse(client)
+            body = body_class.from_buffer_copy(body_buffer)
+
+            if self.include_field_names:
+                field_count = body.fields.length
+            else:
+                field_count = body.field_count
+
+            data_fields = []
+            data_buffer = b''
+            for i in range(body.row_count):
+                row_fields = []
+                row_buffer = b''
+                for j in range(field_count):
+                    field_class, field_buffer = AnyDataObject.parse(client)
+                    row_fields.append(('column_{}'.format(j), field_class))
+                    row_buffer += field_buffer
+
+                row_class = type(
+                    'SQLResponseRow',
+                    (ctypes.LittleEndianStructure,),
+                    {
+                        '_pack_': 1,
+                        '_fields_': row_fields,
+                    }
+                )
+                data_fields.append(('row_{}'.format(i), row_class))
+                data_buffer += row_buffer
+
+            data_class = type(
+                'SQLResponseData',
+                (ctypes.LittleEndianStructure,),
+                {
+                    '_pack_': 1,
+                    '_fields_': data_fields,
+                }
+            )
+            fields += body_class._fields_ + [
+                ('data', data_class),
+                ('more', ctypes.c_bool),
+            ]
+            buffer += body_buffer + data_buffer
+        else:
+            c_type, buffer_fragment = String.parse(client)
+            buffer += buffer_fragment
+            fields.append(('error_message', c_type))
+
+        final_class = type(
+            'SQLResponse',
+            (header_class,),
+            {
+                '_pack_': 1,
+                '_fields_': fields,
+            }
+        )
+        buffer += client.recv(ctypes.sizeof(final_class) - len(buffer))
+        return final_class, buffer
+
+    def to_python(self, ctype_object, *args, **kwargs):
+        if ctype_object.status_code == 0:
+            result = {
+                'more': Bool.to_python(
+                    ctype_object.more, *args, **kwargs
+                ),
+                'data': [],
+            }
+            if hasattr(ctype_object, 'fields'):
+                result['fields'] = StringArray.to_python(
+                    ctype_object.fields, *args, **kwargs
+                )
+            else:
+                result['field_count'] = Int.to_python(
+                    ctype_object.field_count, *args, **kwargs
+                )
+            if hasattr(ctype_object, 'cursor'):
+                result['cursor'] = Long.to_python(
+                    ctype_object.cursor, *args, **kwargs
+                )
+            for row_item in ctype_object.data._fields_:
+                row_name = row_item[0]
+                row_object = getattr(ctype_object.data, row_name)
+                row = []
+                for col_item in row_object._fields_:
+                    col_name = col_item[0]
+                    col_object = getattr(row_object, col_name)
+                    row.append(
+                        AnyDataObject.to_python(col_object, *args, **kwargs)
+                    )
+                result['data'].append(row)
+            return result
+
+
+@attr.s
+class Query:
+    op_code = attr.ib(type=int)
+    following = attr.ib(type=list, factory=list)
+    query_id = attr.ib(type=int, default=None)
+    _query_c_type = None
+
+    @classmethod
+    def build_c_type(cls):
+        if cls._query_c_type is None:
+            cls._query_c_type = type(
+                cls.__name__,
+                (ctypes.LittleEndianStructure,),
+                {
+                    '_pack_': 1,
+                    '_fields_': [
+                        ('length', ctypes.c_int),
+                        ('op_code', ctypes.c_short),
+                        ('query_id', ctypes.c_long),
+                    ],
+                },
+            )
+        return cls._query_c_type
+
+    def from_python(self, values: dict=None):
+        if values is None:
+            values = {}
+        buffer = b''
+
+        header_class = self.build_c_type()
+        header = header_class()
+        header.op_code = self.op_code
+        if self.query_id is None:
+            header.query_id = randint(MIN_LONG, MAX_LONG)
+
+        for name, c_type in self.following:
+            buffer += c_type.from_python(values[name])
+
+        header.length = (
+            len(buffer)
+            + ctypes.sizeof(header_class)
+            - ctypes.sizeof(ctypes.c_int)
+        )
+        return header.query_id, bytes(header) + buffer
+
+    def perform(
+        self, conn: 'Connection', query_params: dict=None,
+        response_config: list=None,
+    ) -> APIResult:
+        """
+        Perform query and process result.
+
+        :param conn: connection to Ignite server,
+        :param query_params: (optional) dict of named query parameters.
+         Defaults to no parameters,
+        :param response_config: (optional) response configuration − list of
+         (name, type_hint) tuples. Defaults to empty return value,
+        :return: instance of :class:`~pyignite.api.result.APIResult` with raw
+         value (may undergo further processing in API functions).
+        """
+        _, send_buffer = self.from_python(query_params)
+        conn.send(send_buffer)
+        response_struct = Response(response_config)
+        response_ctype, recv_buffer = response_struct.parse(conn)
+        response = response_ctype.from_buffer_copy(recv_buffer)
+        result = APIResult(response)
+        if result.status == 0:
+            result.value = response_struct.to_python(response)
+        return result
+
+
+class ConfigQuery(Query):
+    """
+    This is a special query, used for creating caches with configuration.
+    """
+    _query_c_type = None
+
+    @classmethod
+    def build_c_type(cls):
+        if cls._query_c_type is None:
+            cls._query_c_type = type(
+                cls.__name__,
+                (ctypes.LittleEndianStructure,),
+                {
+                    '_pack_': 1,
+                    '_fields_': [
+                        ('length', ctypes.c_int),
+                        ('op_code', ctypes.c_short),
+                        ('query_id', ctypes.c_long),
+                        ('config_length', ctypes.c_int),
+                    ],
+                },
+            )
+        return cls._query_c_type
+
+    def from_python(self, values: dict = None):
+        if values is None:
+            values = {}
+        buffer = b''
+
+        header_class = self.build_c_type()
+        header = header_class()
+        header.op_code = self.op_code
+        if self.query_id is None:
+            header.query_id = randint(MIN_LONG, MAX_LONG)
+
+        for name, c_type in self.following:
+            buffer += c_type.from_python(values[name])
+
+        header.length = (
+            len(buffer)
+            + ctypes.sizeof(header_class)
+            - ctypes.sizeof(ctypes.c_int)
+        )
+        header.config_length = header.length - ctypes.sizeof(header_class)
+        return header.query_id, bytes(header) + buffer
diff --git a/pyignite/queries/op_codes.py b/pyignite/queries/op_codes.py
new file mode 100644
index 0000000..1396e83
--- /dev/null
+++ b/pyignite/queries/op_codes.py
@@ -0,0 +1,65 @@
+# 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.
+
+"""
+Named constants that represents request operation codes. These are the way
+of telling Ignite server what one want to do in their request.
+"""
+
+OP_SUCCESS = 0
+
+OP_RESOURCE_CLOSE = 0
+
+OP_CACHE_GET = 1000
+OP_CACHE_PUT = 1001
+OP_CACHE_PUT_IF_ABSENT = 1002
+OP_CACHE_GET_ALL = 1003
+OP_CACHE_PUT_ALL = 1004
+OP_CACHE_GET_AND_PUT = 1005
+OP_CACHE_GET_AND_REPLACE = 1006
+OP_CACHE_GET_AND_REMOVE = 1007
+OP_CACHE_GET_AND_PUT_IF_ABSENT = 1008
+OP_CACHE_REPLACE = 1009
+OP_CACHE_REPLACE_IF_EQUALS = 1010
+OP_CACHE_CONTAINS_KEY = 1011
+OP_CACHE_CONTAINS_KEYS = 1012
+OP_CACHE_CLEAR = 1013
+OP_CACHE_CLEAR_KEY = 1014
+OP_CACHE_CLEAR_KEYS = 1015
+OP_CACHE_REMOVE_KEY = 1016
+OP_CACHE_REMOVE_IF_EQUALS = 1017
+OP_CACHE_REMOVE_KEYS = 1018
+OP_CACHE_REMOVE_ALL = 1019
+OP_CACHE_GET_SIZE = 1020
+
+OP_CACHE_GET_NAMES = 1050
+OP_CACHE_CREATE_WITH_NAME = 1051
+OP_CACHE_GET_OR_CREATE_WITH_NAME = 1052
+OP_CACHE_CREATE_WITH_CONFIGURATION = 1053
+OP_CACHE_GET_OR_CREATE_WITH_CONFIGURATION = 1054
+OP_CACHE_GET_CONFIGURATION = 1055
+OP_CACHE_DESTROY = 1056
+
+OP_QUERY_SCAN = 2000
+OP_QUERY_SCAN_CURSOR_GET_PAGE = 2001
+OP_QUERY_SQL = 2002
+OP_QUERY_SQL_CURSOR_GET_PAGE = 2003
+OP_QUERY_SQL_FIELDS = 2004
+OP_QUERY_SQL_FIELDS_CURSOR_GET_PAGE = 2005
+
+P_GET_BINARY_TYPE_NAME = 3000
+OP_REGISTER_BINARY_TYPE_NAME = 3001
+OP_GET_BINARY_TYPE = 3002
+OP_PUT_BINARY_TYPE = 3003
diff --git a/pyignite/utils.py b/pyignite/utils.py
new file mode 100644
index 0000000..a08bc9b
--- /dev/null
+++ b/pyignite/utils.py
@@ -0,0 +1,168 @@
+# 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 functools import wraps
+from typing import Any, Type, Union
+
+from .constants import *
+
+
+def is_iterable(value):
+    """ Check if value is iterable. """
+    try:
+        iter(value)
+        return True
+    except TypeError:
+        return False
+
+
+def is_binary(value):
+    """
+    Check if a value is a pythonic representation of a Complex object.
+    """
+    return all([
+        hasattr(value, 'type_name'),
+        hasattr(value, 'type_id'),
+        hasattr(value, 'schema'),
+        hasattr(value, 'schema_id'),
+    ])
+
+
+def is_hinted(value):
+    """
+    Check if a value is a tuple of data item and its type hint.
+    """
+    return (
+        isinstance(value, tuple)
+        and len(value) == 2
+        and isinstance(value[1], object)
+    )
+
+
+def is_wrapped(value: Any) -> bool:
+    return (
+        type(value) is tuple
+        and len(value) == 2
+        and type(value[0]) is bytes
+        and type(value[1]) is int
+    )
+
+
+def int_overflow(value: int) -> int:
+    """
+    Simulates 32bit integer overflow.
+    """
+    return ((value ^ 0x80000000) & 0xffffffff) - 0x80000000
+
+
+def unwrap_binary(client: 'Client', wrapped: tuple):
+    """
+    Unwrap wrapped BinaryObject and convert it to Python data.
+
+    :param client: connection to Ignite cluster,
+    :param wrapped: `WrappedDataObject` value,
+    :return: dict representing wrapped BinaryObject.
+    """
+    from pyignite.datatypes.complex import BinaryObject
+
+    blob, offset = wrapped
+    client_clone = client.clone(prefetch=blob)
+    client_clone.pos = offset
+    data_class, data_bytes = BinaryObject.parse(client_clone)
+    return BinaryObject.to_python(
+        data_class.from_buffer_copy(data_bytes),
+        client,
+    )
+
+
+def hashcode(string: Union[str, bytes]) -> int:
+    """
+    Calculate hash code used for identifying objects in Ignite binary API.
+
+    :param string: UTF-8-encoded string identifier of binary buffer,
+    :return: hash code.
+    """
+    result = 0
+    for char in string:
+        try:
+            char = ord(char)
+        except TypeError:
+            pass
+        result = int_overflow(31 * result + char)
+    return result
+
+
+def cache_id(cache: Union[str, int]) -> int:
+    """
+    Create a cache ID from cache name.
+
+    :param cache: cache name or ID,
+    :return: cache ID.
+    """
+    return cache if type(cache) is int else hashcode(cache)
+
+
+def entity_id(cache: Union[str, int]) -> int:
+    """
+    Create a type ID from type name or field ID from field name.
+
+    :param cache: entity name or ID,
+    :return: entity ID.
+    """
+    return cache if type(cache) is int else hashcode(cache.lower())
+
+
+def schema_id(schema: Union[int, dict]) -> int:
+    """
+    Calculate Complex Object schema ID.
+
+    :param schema: a dict of field names: field types,
+    :return: schema ID.
+    """
+    if type(schema) is int:
+        return schema
+    if schema is None:
+        return 0
+    s_id = FNV1_OFFSET_BASIS if schema else 0
+    for field_name in schema.keys():
+        field_id = entity_id(field_name)
+        s_id ^= (field_id & 0xff)
+        s_id = int_overflow(s_id * FNV1_PRIME)
+        s_id ^= ((field_id >> 8) & 0xff)
+        s_id = int_overflow(s_id * FNV1_PRIME)
+        s_id ^= ((field_id >> 16) & 0xff)
+        s_id = int_overflow(s_id * FNV1_PRIME)
+        s_id ^= ((field_id >> 24) & 0xff)
+        s_id = int_overflow(s_id * FNV1_PRIME)
+    return s_id
+
+
+def status_to_exception(exc: Type[Exception]):
+    """
+    Converts erroneous status code with error message to an exception
+    of the given class.
+
+    :param exc: the class of exception to raise,
+    :return: decorator.
+    """
+    def ste_decorator(fn):
+        @wraps(fn)
+        def ste_wrapper(*args, **kwargs):
+            result = fn(*args, **kwargs)
+            if result.status != 0:
+                raise exc(result.message)
+            return result.value
+        return ste_wrapper
+    return ste_decorator
diff --git a/requirements/docs.txt b/requirements/docs.txt
new file mode 100644
index 0000000..75ab231
--- /dev/null
+++ b/requirements/docs.txt
@@ -0,0 +1,6 @@
+# these packages are required for documentation building
+# (look up the prebuilt docs in `docs/generated`)
+
+-r install.txt
+Sphinx==1.7.5
+sphinxcontrib-fulltoc==1.2.0
diff --git a/requirements/install.txt b/requirements/install.txt
new file mode 100644
index 0000000..9b87ae8
--- /dev/null
+++ b/requirements/install.txt
@@ -0,0 +1,4 @@
+# these pip packages are necessary for the pyignite to run
+
+typing==3.6.6; python_version<'3.5'
+attrs==18.1.0
diff --git a/requirements/setup.txt b/requirements/setup.txt
new file mode 100644
index 0000000..7c55f83
--- /dev/null
+++ b/requirements/setup.txt
@@ -0,0 +1,3 @@
+# additional package for integrating pytest in setuptools
+
+pytest-runner==4.2
diff --git a/requirements/tests.txt b/requirements/tests.txt
new file mode 100644
index 0000000..c107c8b
--- /dev/null
+++ b/requirements/tests.txt
@@ -0,0 +1,5 @@
+# these packages are used for testing
+
+pytest==3.6.1
+pytest-cov==2.5.1
+teamcity-messages==1.21
diff --git a/setup.py b/setup.py
new file mode 100644
index 0000000..403b170
--- /dev/null
+++ b/setup.py
@@ -0,0 +1,100 @@
+# 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 collections import defaultdict
+import setuptools
+import sys
+
+
+PYTHON_REQUIRED = (3, 4)
+PYTHON_INSTALLED = sys.version_info[:2]
+
+if PYTHON_INSTALLED < PYTHON_REQUIRED:
+    sys.stderr.write('''
+
+`pyignite` is not compatible with Python {}.{}!
+Use Python {}.{} or above.
+
+
+'''.format(
+            PYTHON_INSTALLED[0],
+            PYTHON_INSTALLED[1],
+            PYTHON_REQUIRED[0],
+            PYTHON_REQUIRED[1],
+        )
+    )
+    sys.exit(1)
+
+
+def is_a_requirement(line):
+    return not any([
+        line.startswith('#'),
+        line.startswith('-r'),
+        len(line) == 0,
+    ])
+
+
+requirement_sections = [
+    'install',
+    'setup',
+    'tests',
+    'docs',
+]
+requirements = defaultdict(list)
+
+for section in requirement_sections:
+    with open('requirements/{}.txt'.format(section), 'r') as requirements_file:
+        for line in requirements_file.readlines():
+            line = line.strip('\n')
+            if is_a_requirement(line):
+                requirements[section].append(line)
+
+with open('README.md', 'r') as readme_file:
+    long_description = readme_file.read()
+
+setuptools.setup(
+    name='pyignite',
+    version='0.3.1',
+    python_requires='>={}.{}'.format(*PYTHON_REQUIRED),
+    author='Dmitry Melnichuk',
+    author_email='dmitry.melnichuk@nobitlost.com',
+    description='Apache Ignite binary client Python API',
+    long_description=long_description,
+    long_description_content_type='text/markdown',
+    url=(
+        'https://github.com/apache/ignite/tree/master'
+        '/modules/platforms/python'
+    ),
+    packages=setuptools.find_packages(),
+    install_requires=requirements['install'],
+    tests_require=requirements['tests'],
+    setup_requires=requirements['setup'],
+    extras_require={
+        'docs': requirements['docs'],
+    },
+    classifiers=[
+        'Programming Language :: Python',
+        'Programming Language :: Python :: 3',
+        'Programming Language :: Python :: 3.4',
+        'Programming Language :: Python :: 3.5',
+        'Programming Language :: Python :: 3.6',
+        'Programming Language :: Python :: 3 :: Only',
+        'Intended Audience :: Developers',
+        'Topic :: Database :: Front-Ends',
+        'Topic :: Software Development :: Libraries :: Python Modules',
+        'License :: OSI Approved :: Apache Software License',
+        'Operating System :: OS Independent',
+    ],
+)
diff --git a/tests/conftest.py b/tests/conftest.py
new file mode 100644
index 0000000..be6d029
--- /dev/null
+++ b/tests/conftest.py
@@ -0,0 +1,218 @@
+# 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.
+
+import argparse
+from distutils.util import strtobool
+import ssl
+
+import pytest
+
+from pyignite import Client
+from pyignite.constants import *
+from pyignite.api import cache_create, cache_get_names, cache_destroy
+
+
+class UseSSLParser(argparse.Action):
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        values = True if values is None else bool(strtobool(values))
+        setattr(namespace, self.dest, values)
+
+
+class CertReqsParser(argparse.Action):
+    conv_map = {
+        'NONE': ssl.CERT_NONE,
+        'OPTIONAL': ssl.CERT_OPTIONAL,
+        'REQUIRED': ssl.CERT_REQUIRED,
+    }
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        value = values.upper()
+        if value in self.conv_map:
+            setattr(namespace, self.dest, self.conv_map[value])
+        else:
+            raise ValueError(
+                'Undefined argument: --ssl-cert-reqs={}'.format(value)
+            )
+
+
+class SSLVersionParser(argparse.Action):
+    conv_map = {
+        'TLSV1_1': ssl.PROTOCOL_TLSv1_1,
+        'TLSV1_2': ssl.PROTOCOL_TLSv1_2,
+    }
+
+    def __call__(self, parser, namespace, values, option_string=None):
+        value = values.upper()
+        if value in self.conv_map:
+            setattr(namespace, self.dest, self.conv_map[value])
+        else:
+            raise ValueError(
+                'Undefined argument: --ssl-version={}'.format(value)
+            )
+
+
+@pytest.fixture(scope='module')
+def client(
+    ignite_host, ignite_port, timeout, use_ssl, ssl_keyfile, ssl_certfile,
+    ssl_ca_certfile, ssl_cert_reqs, ssl_ciphers, ssl_version,
+    username, password,
+):
+    client = Client(
+        timeout=timeout,
+        use_ssl=use_ssl,
+        ssl_keyfile=ssl_keyfile,
+        ssl_certfile=ssl_certfile,
+        ssl_ca_certfile=ssl_ca_certfile,
+        ssl_cert_reqs=ssl_cert_reqs,
+        ssl_ciphers=ssl_ciphers,
+        ssl_version=ssl_version,
+        username=username,
+        password=password,
+    )
+    client.connect(ignite_host, ignite_port)
+    yield client
+    for cache_name in cache_get_names(client).value:
+        cache_destroy(client, cache_name)
+    client.close()
+
+
+@pytest.fixture
+def cache(client):
+    cache_name = 'my_bucket'
+    cache_create(client, cache_name)
+    yield cache_name
+    cache_destroy(client, cache_name)
+
+
+def pytest_addoption(parser):
+    parser.addoption(
+        '--ignite-host',
+        action='append',
+        default=[IGNITE_DEFAULT_HOST],
+        help='Ignite binary protocol test server host (default: localhost)'
+    )
+    parser.addoption(
+        '--ignite-port',
+        action='append',
+        default=[IGNITE_DEFAULT_PORT],
+        type=int,
+        help='Ignite binary protocol test server port (default: 10800)'
+    )
+    parser.addoption(
+        '--timeout',
+        action='store',
+        type=float,
+        default=None,
+        help=(
+            'Timeout (in seconds) for each socket operation. Can accept '
+            'integer or float value. Default is None'
+        )
+    )
+    parser.addoption(
+        '--use-ssl',
+        action=UseSSLParser,
+        nargs='?',
+        default=False,
+        help='Use SSL encryption'
+    )
+    parser.addoption(
+        '--ssl-keyfile',
+        action='store',
+        default=None,
+        type=str,
+        help='a path to SSL key file to identify local party'
+    )
+    parser.addoption(
+        '--ssl-certfile',
+        action='store',
+        default=None,
+        type=str,
+        help='a path to ssl certificate file to identify local party'
+    )
+    parser.addoption(
+        '--ssl-ca-certfile',
+        action='store',
+        default=None,
+        type=str,
+        help='a path to a trusted certificate or a certificate chain'
+    )
+    parser.addoption(
+        '--ssl-cert-reqs',
+        action=CertReqsParser,
+        default=ssl.CERT_NONE,
+        help=(
+            'determines how the remote side certificate is treated: '
+            'NONE (ignore, default), '
+            'OPTIONAL (validate, if provided) or '
+            'REQUIRED (valid remote certificate is required)'
+        )
+    )
+    parser.addoption(
+        '--ssl-ciphers',
+        action='store',
+        default=SSL_DEFAULT_CIPHERS,
+        type=str,
+        help='ciphers to use'
+    )
+    parser.addoption(
+        '--ssl-version',
+        action=SSLVersionParser,
+        default=SSL_DEFAULT_VERSION,
+        help='SSL version: TLSV1_1 or TLSV1_2'
+    )
+    parser.addoption(
+        '--username',
+        action='store',
+        type=str,
+        help='user name'
+    )
+    parser.addoption(
+        '--password',
+        action='store',
+        type=str,
+        help='password'
+    )
+    parser.addoption(
+        '--examples',
+        action='store_true',
+        help='check if examples can be run',
+    )
+
+
+def pytest_generate_tests(metafunc):
+    session_parameters = {
+        'ignite_host': IGNITE_DEFAULT_HOST,
+        'ignite_port': IGNITE_DEFAULT_PORT,
+        'timeout': None,
+        'use_ssl': False,
+        'ssl_keyfile': None,
+        'ssl_certfile': None,
+        'ssl_ca_certfile': None,
+        'ssl_cert_reqs': ssl.CERT_NONE,
+        'ssl_ciphers': SSL_DEFAULT_CIPHERS,
+        'ssl_version': SSL_DEFAULT_VERSION,
+        'username': None,
+        'password': None,
+    }
+
+    for param_name in session_parameters:
+        if param_name in metafunc.fixturenames:
+            param = metafunc.config.getoption(param_name)
+            if param is None:
+                param = session_parameters[param_name]
+            if type(param) is not list:
+                param = [param]
+            metafunc.parametrize(param_name, param, scope='session')
diff --git a/tests/test_binary.py b/tests/test_binary.py
new file mode 100644
index 0000000..f6c48e9
--- /dev/null
+++ b/tests/test_binary.py
@@ -0,0 +1,281 @@
+# 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 collections import OrderedDict
+from decimal import Decimal
+
+from pyignite import GenericObjectMeta
+from pyignite.datatypes import (
+    BinaryObject, BoolObject, IntObject, DecimalObject, LongObject, String,
+)
+from pyignite.datatypes.prop_codes import *
+
+
+insert_data = [
+    [1, True, 'asdf', 42, Decimal('2.4')],
+    [2, False, 'zxcvb', 43, Decimal('2.5')],
+    [3, True, 'qwerty', 44, Decimal('2.6')],
+]
+
+page_size = 100
+
+scheme_name = 'PUBLIC'
+
+table_sql_name = 'AllDataType'
+table_cache_name = 'SQL_{}_{}'.format(
+    scheme_name,
+    table_sql_name.upper(),
+)
+
+create_query = '''
+CREATE TABLE {} (
+  test_pk INTEGER(11) PRIMARY KEY,
+  test_bool BOOLEAN,
+  test_str VARCHAR(24),
+  test_int INTEGER(11),
+  test_decimal DECIMAL(11, 5),
+)
+'''.format(table_sql_name)
+
+insert_query = '''
+INSERT INTO {} (
+  test_pk, test_bool, test_str, test_int, test_decimal, 
+) VALUES (?, ?, ?, ?, ?)'''.format(table_sql_name)
+
+select_query = '''SELECT * FROM {}'''.format(table_sql_name)
+
+drop_query = 'DROP TABLE {} IF EXISTS'.format(table_sql_name)
+
+
+def test_sql_read_as_binary(client):
+
+    client.sql(drop_query)
+
+    # create table
+    client.sql(create_query)
+
+    # insert some rows
+    for line in insert_data:
+        client.sql(insert_query, query_args=line)
+
+    table_cache = client.get_cache(table_cache_name)
+    result = table_cache.scan()
+
+    # convert Binary object fields' values to a tuple
+    # to compare it with the initial data
+    for key, value in result:
+        assert key in {x[0] for x in insert_data}
+        assert (
+                   value.TEST_BOOL,
+                   value.TEST_STR,
+                   value.TEST_INT,
+                   value.TEST_DECIMAL
+               ) in {tuple(x[1:]) for x in insert_data}
+
+    client.sql(drop_query)
+
+
+def test_sql_write_as_binary(client):
+
+    client.get_or_create_cache(scheme_name)
+
+    # configure cache as an SQL table
+    type_name = table_cache_name
+
+    # register binary type
+    class AllDataType(
+        metaclass=GenericObjectMeta,
+        type_name=type_name,
+        schema=OrderedDict([
+            ('TEST_BOOL', BoolObject),
+            ('TEST_STR', String),
+            ('TEST_INT', IntObject),
+            ('TEST_DECIMAL', DecimalObject),
+        ]),
+    ):
+        pass
+
+    table_cache = client.get_or_create_cache({
+        PROP_NAME: table_cache_name,
+        PROP_SQL_SCHEMA: scheme_name,
+        PROP_QUERY_ENTITIES: [
+            {
+                'table_name': table_sql_name.upper(),
+                'key_field_name': 'TEST_PK',
+                'key_type_name': 'java.lang.Integer',
+                'field_name_aliases': [],
+                'query_fields': [
+                    {
+                        'name': 'TEST_PK',
+                        'type_name': 'java.lang.Integer',
+                        'is_key_field': True,
+                        'is_notnull_constraint_field': True,
+                    },
+                    {
+                        'name': 'TEST_BOOL',
+                        'type_name': 'java.lang.Boolean',
+                    },
+                    {
+                        'name': 'TEST_STR',
+                        'type_name': 'java.lang.String',
+                    },
+                    {
+                        'name': 'TEST_INT',
+                        'type_name': 'java.lang.Integer',
+                    },
+                    {
+                        'name': 'TEST_DECIMAL',
+                        'type_name': 'java.math.BigDecimal',
+                        'default_value': Decimal('0.00'),
+                        'precision': 11,
+                        'scale': 2,
+                    },
+                ],
+                'query_indexes': [],
+                'value_type_name': type_name,
+                'value_field_name': None,
+            },
+        ],
+    })
+    table_settings = table_cache.settings
+    assert table_settings, 'SQL table cache settings are empty'
+
+    # insert rows as k-v
+    for row in insert_data:
+        value = AllDataType()
+        (
+            value.TEST_BOOL,
+            value.TEST_STR,
+            value.TEST_INT,
+            value.TEST_DECIMAL,
+        ) = row[1:]
+        table_cache.put(row[0], value, key_hint=IntObject)
+
+    data = table_cache.scan()
+    assert len(list(data)) == len(insert_data), (
+        'Not all data was read as key-value'
+    )
+
+    # read rows as SQL
+    data = client.sql(select_query, include_field_names=True)
+
+    header_row = next(data)
+    for field_name in AllDataType.schema.keys():
+        assert field_name in header_row, 'Not all field names in header row'
+
+    data = list(data)
+    assert len(data) == len(insert_data), 'Not all data was read as SQL rows'
+
+    # cleanup
+    table_cache.destroy()
+
+
+def test_nested_binary_objects(client):
+
+    nested_cache = client.get_or_create_cache('nested_binary')
+
+    class InnerType(
+        metaclass=GenericObjectMeta,
+        schema=OrderedDict([
+            ('inner_int', LongObject),
+            ('inner_str', String),
+        ]),
+    ):
+        pass
+
+    class OuterType(
+        metaclass=GenericObjectMeta,
+        schema=OrderedDict([
+            ('outer_int', LongObject),
+            ('nested_binary', BinaryObject),
+            ('outer_str', String),
+        ]),
+    ):
+        pass
+
+    inner = InnerType(inner_int=42, inner_str='This is a test string')
+
+    outer = OuterType(
+        outer_int=43,
+        nested_binary=inner,
+        outer_str='This is another test string'
+    )
+
+    nested_cache.put(1, outer)
+
+    result = nested_cache.get(1)
+    assert result.outer_int == 43
+    assert result.outer_str == 'This is another test string'
+    assert result.nested_binary.inner_int == 42
+    assert result.nested_binary.inner_str == 'This is a test string'
+
+    nested_cache.destroy()
+
+
+def test_add_schema_to_binary_object(client):
+
+    migrate_cache = client.create_cache('migrate_binary')
+
+    class MyBinaryType(
+        metaclass=GenericObjectMeta,
+        schema=OrderedDict([
+            ('test_str', String),
+            ('test_int', LongObject),
+            ('test_bool', BoolObject),
+        ]),
+    ):
+        pass
+
+    binary_object = MyBinaryType(
+        test_str='Test string',
+        test_int=42,
+        test_bool=True,
+    )
+    migrate_cache.put(1, binary_object)
+
+    result = migrate_cache.get(1)
+    assert result.test_str == 'Test string'
+    assert result.test_int == 42
+    assert result.test_bool is True
+
+    modified_schema = MyBinaryType.schema.copy()
+    modified_schema['test_decimal'] = DecimalObject
+    del modified_schema['test_bool']
+
+    class MyBinaryTypeV2(
+        metaclass=GenericObjectMeta,
+        type_name='MyBinaryType',
+        schema=modified_schema,
+    ):
+        pass
+
+    assert MyBinaryType.type_id == MyBinaryTypeV2.type_id
+    assert MyBinaryType.schema_id != MyBinaryTypeV2.schema_id
+
+    binary_object_v2 = MyBinaryTypeV2(
+        test_str='Another test',
+        test_int=43,
+        test_decimal=Decimal('2.34')
+    )
+
+    migrate_cache.put(2, binary_object_v2)
+
+    result = migrate_cache.get(2)
+    assert result.test_str == 'Another test'
+    assert result.test_int == 43
+    assert result.test_decimal == Decimal('2.34')
+    assert not hasattr(result, 'test_bool')
+
+    migrate_cache.destroy()
diff --git a/tests/test_cache_class.py b/tests/test_cache_class.py
new file mode 100644
index 0000000..22865be
--- /dev/null
+++ b/tests/test_cache_class.py
@@ -0,0 +1,221 @@
+# 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 collections import OrderedDict
+from decimal import Decimal
+
+import pytest
+
+from pyignite import GenericObjectMeta
+from pyignite.datatypes import (
+    BoolObject, DecimalObject, FloatObject, IntObject, String,
+)
+from pyignite.datatypes.prop_codes import *
+from pyignite.exceptions import CacheError
+
+
+def test_cache_create(client):
+    cache = client.get_or_create_cache('my_oop_cache')
+    assert cache.name == cache.settings[PROP_NAME] == 'my_oop_cache'
+    cache.destroy()
+
+
+def test_cache_remove(client):
+    cache = client.get_or_create_cache('my_cache')
+    cache.clear()
+    assert cache.get_size() == 0
+
+    cache.put_all({
+        'key_1': 1,
+        'key_2': 2,
+        'key_3': 3,
+        'key_4': 4,
+        'key_5': 5,
+    })
+    assert cache.get_size() == 5
+
+    result = cache.remove_if_equals('key_1', 42)
+    assert result is False
+    assert cache.get_size() == 5
+
+    result = cache.remove_if_equals('key_1', 1)
+    assert result is True
+    assert cache.get_size() == 4
+
+    cache.remove_keys(['key_1', 'key_3', 'key_5', 'key_7'])
+    assert cache.get_size() == 2
+
+    cache.remove_all()
+    assert cache.get_size() == 0
+
+
+def test_cache_get(client):
+    client.get_or_create_cache('my_cache')
+
+    my_cache = client.get_cache('my_cache')
+    assert my_cache.settings[PROP_NAME] == 'my_cache'
+    my_cache.destroy()
+
+    error = None
+
+    my_cache = client.get_cache('my_cache')
+    try:
+        _ = my_cache.settings[PROP_NAME]
+    except CacheError as e:
+        error = e
+
+    assert type(error) is CacheError
+
+
+def test_cache_config(client):
+    cache_config = {
+        PROP_NAME: 'my_oop_cache',
+        PROP_CACHE_KEY_CONFIGURATION: [
+            {
+                'type_name': 'blah',
+                'affinity_key_field_name': 'abc1234',
+            },
+        ],
+    }
+    client.create_cache(cache_config)
+
+    cache = client.get_or_create_cache('my_oop_cache')
+    assert cache.name == cache_config[PROP_NAME]
+    assert (
+        cache.settings[PROP_CACHE_KEY_CONFIGURATION]
+        == cache_config[PROP_CACHE_KEY_CONFIGURATION]
+    )
+
+    cache.destroy()
+
+
+def test_cache_get_put(client):
+    cache = client.get_or_create_cache('my_oop_cache')
+    cache.put('my_key', 42)
+    result = cache.get('my_key')
+    assert result, 42
+    cache.destroy()
+
+
+def test_cache_binary_get_put(client):
+
+    class TestBinaryType(
+        metaclass=GenericObjectMeta,
+        schema=OrderedDict([
+            ('test_bool', BoolObject),
+            ('test_str', String),
+            ('test_int', IntObject),
+            ('test_decimal', DecimalObject),
+        ]),
+    ):
+        pass
+
+    cache = client.create_cache('my_oop_cache')
+
+    my_value = TestBinaryType(
+        test_bool=True,
+        test_str='This is a test',
+        test_int=42,
+        test_decimal=Decimal('34.56'),
+    )
+    cache.put('my_key', my_value)
+
+    value = cache.get('my_key')
+    assert value.test_bool is True
+    assert value.test_str == 'This is a test'
+    assert value.test_int == 42
+    assert value.test_decimal == Decimal('34.56')
+
+    cache.destroy()
+
+
+def test_get_binary_type(client):
+    client.put_binary_type(
+        'TestBinaryType',
+        schema=OrderedDict([
+            ('TEST_BOOL', BoolObject),
+            ('TEST_STR', String),
+            ('TEST_INT', IntObject),
+        ])
+    )
+    client.put_binary_type(
+        'TestBinaryType',
+        schema=OrderedDict([
+            ('TEST_BOOL', BoolObject),
+            ('TEST_STR', String),
+            ('TEST_INT', IntObject),
+            ('TEST_FLOAT', FloatObject),
+        ])
+    )
+    client.put_binary_type(
+        'TestBinaryType',
+        schema=OrderedDict([
+            ('TEST_BOOL', BoolObject),
+            ('TEST_STR', String),
+            ('TEST_INT', IntObject),
+            ('TEST_DECIMAL', DecimalObject),
+        ])
+    )
+
+    binary_type_info = client.get_binary_type('TestBinaryType')
+    assert len(binary_type_info['schemas']) == 3
+
+    binary_type_info = client.get_binary_type('NonExistentType')
+    assert binary_type_info['type_exists'] is False
+    assert len(binary_type_info) == 1
+
+
+@pytest.mark.parametrize('page_size', range(1, 17, 5))
+def test_cache_scan(client, page_size):
+    test_data = {
+        1: 'This is a test',
+        2: 'One more test',
+        3: 'Foo',
+        4: 'Buzz',
+        5: 'Bar',
+        6: 'Lorem ipsum',
+        7: 'dolor sit amet',
+        8: 'consectetur adipiscing elit',
+        9: 'Nullam aliquet',
+        10: 'nisl at ante',
+        11: 'suscipit',
+        12: 'ut cursus',
+        13: 'metus interdum',
+        14: 'Nulla tincidunt',
+        15: 'sollicitudin iaculis',
+    }
+
+    cache = client.get_or_create_cache('my_oop_cache')
+    cache.put_all(test_data)
+
+    gen = cache.scan(page_size=page_size)
+    received_data = []
+    for k, v in gen:
+        assert k in test_data.keys()
+        assert v in test_data.values()
+        received_data.append((k, v))
+    assert len(received_data) == len(test_data)
+
+    cache.destroy()
+
+
+def test_get_and_put_if_absent(client):
+    cache = client.get_or_create_cache('my_oop_cache')
+
+    value = cache.get_and_put_if_absent('my_key', 42)
+    assert value is None
+    cache.put('my_key', 43)
+    value = cache.get_and_put_if_absent('my_key', 42)
+    assert value is 43
diff --git a/tests/test_cache_class_sql.py b/tests/test_cache_class_sql.py
new file mode 100644
index 0000000..5f72b39
--- /dev/null
+++ b/tests/test_cache_class_sql.py
@@ -0,0 +1,103 @@
+# 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.
+
+import pytest
+
+
+initial_data = [
+        ('John', 'Doe', 5),
+        ('Jane', 'Roe', 4),
+        ('Joe', 'Bloggs', 4),
+        ('Richard', 'Public', 3),
+        ('Negidius', 'Numerius', 3),
+    ]
+
+create_query = '''CREATE TABLE Student (
+    id INT(11) PRIMARY KEY,
+    first_name CHAR(24),
+    last_name CHAR(32),
+    grade INT(11))'''
+
+insert_query = '''INSERT INTO Student(id, first_name, last_name, grade)
+VALUES (?, ?, ?, ?)'''
+
+select_query = 'SELECT id, first_name, last_name, grade FROM Student'
+
+drop_query = 'DROP TABLE Student IF EXISTS'
+
+
+@pytest.mark.parametrize('page_size', range(1, 6, 2))
+def test_sql_fields(client, page_size):
+
+    client.sql(drop_query, page_size)
+
+    result = client.sql(create_query, page_size)
+    assert next(result)[0] == 0
+
+    for i, data_line in enumerate(initial_data, start=1):
+        fname, lname, grade = data_line
+        result = client.sql(
+            insert_query,
+            page_size,
+            query_args=[i, fname, lname, grade]
+        )
+        assert next(result)[0] == 1
+
+    result = client.sql(
+        select_query,
+        page_size,
+        include_field_names=True,
+    )
+    field_names = next(result)
+    assert set(field_names) == {'ID', 'FIRST_NAME', 'LAST_NAME', 'GRADE'}
+
+    data = list(result)
+    assert len(data) == 5
+    for row in data:
+        assert len(row) == 4
+
+    client.sql(drop_query, page_size)
+
+
+@pytest.mark.parametrize('page_size', range(1, 6, 2))
+def test_sql(client, page_size):
+
+    client.sql(drop_query, page_size)
+
+    result = client.sql(create_query, page_size)
+    assert next(result)[0] == 0
+
+    for i, data_line in enumerate(initial_data, start=1):
+        fname, lname, grade = data_line
+        result = client.sql(
+            insert_query,
+            page_size,
+            query_args=[i, fname, lname, grade]
+        )
+        assert next(result)[0] == 1
+
+    student = client.get_or_create_cache('SQL_PUBLIC_STUDENT')
+    result = student.select_row('TRUE', page_size)
+    for k, v in result:
+        assert k in range(1, 6)
+        assert v.FIRST_NAME in [
+            'John',
+            'Jane',
+            'Joe',
+            'Richard',
+            'Negidius',
+        ]
+
+    client.sql(drop_query, page_size)
diff --git a/tests/test_cache_config.py b/tests/test_cache_config.py
new file mode 100644
index 0000000..2f01618
--- /dev/null
+++ b/tests/test_cache_config.py
@@ -0,0 +1,75 @@
+# 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 pyignite.api import *
+from pyignite.datatypes.prop_codes import *
+
+
+def test_get_configuration(client):
+
+    result = cache_get_or_create(client, 'my_unique_cache')
+    assert result.status == 0
+
+    result = cache_get_configuration(client, 'my_unique_cache')
+    assert result.status == 0
+    assert result.value[PROP_NAME] == 'my_unique_cache'
+
+
+def test_create_with_config(client):
+
+    cache_name = 'my_very_unique_name'
+
+    result = cache_create_with_config(client, {
+        PROP_NAME: cache_name,
+        PROP_CACHE_KEY_CONFIGURATION: [
+            {
+                'type_name': 'blah',
+                'affinity_key_field_name': 'abc1234',
+            }
+        ],
+    })
+    assert result.status == 0
+
+    result = cache_get_names(client)
+    assert cache_name in result.value
+
+    result = cache_create_with_config(client, {
+        PROP_NAME: cache_name,
+    })
+    assert result.status != 0
+
+
+def test_get_or_create_with_config(client):
+
+    cache_name = 'my_very_unique_name'
+
+    result = cache_get_or_create_with_config(client, {
+        PROP_NAME: cache_name,
+        PROP_CACHE_KEY_CONFIGURATION: [
+            {
+                'type_name': 'blah',
+                'affinity_key_field_name': 'abc1234',
+            }
+        ],
+    })
+    assert result.status == 0
+
+    result = cache_get_names(client)
+    assert cache_name in result.value
+
+    result = cache_get_or_create_with_config(client, {
+        PROP_NAME: cache_name,
+    })
+    assert result.status == 0
diff --git a/tests/test_datatypes.py b/tests/test_datatypes.py
new file mode 100644
index 0000000..d7c7977
--- /dev/null
+++ b/tests/test_datatypes.py
@@ -0,0 +1,134 @@
+# 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 datetime import datetime, timedelta
+import decimal
+import pytest
+import uuid
+
+from pyignite.api.key_value import cache_get, cache_put
+from pyignite.datatypes import *
+
+
+@pytest.mark.parametrize(
+    'value, value_hint',
+    [
+        # integers
+        (42, None),
+        (42, ByteObject),
+        (42, ShortObject),
+        (42, IntObject),
+
+        # floats
+        (3.1415, None),  # True for Double but not Float
+        (3.5, FloatObject),
+
+        # char is never autodetected
+        ('ы', CharObject),
+        ('カ', CharObject),
+
+        # bool
+        (True, None),
+        (False, None),
+        (True, BoolObject),
+        (False, BoolObject),
+
+        # arrays of integers
+        ([1, 2, 3, 5], None),
+        ([1, 2, 3, 5], ByteArrayObject),
+        ([1, 2, 3, 5], ShortArrayObject),
+        ([1, 2, 3, 5], IntArrayObject),
+
+        # arrays of floats
+        ([2.2, 4.4, 6.6], None),
+        ([2.5, 6.5], FloatArrayObject),
+
+        # array of char
+        (['ы', 'カ'], CharArrayObject),
+
+        # array of bool
+        ([True, False, True], None),
+
+        # string
+        ('Little Mary had a lamb', None),
+        ('This is a test', String),
+
+        # decimals
+        (decimal.Decimal('2.5'), None),
+        (decimal.Decimal('-1.3'), None),
+
+        # uuid
+        (uuid.uuid4(), None),
+
+        # date
+        (datetime(year=1998, month=4, day=6, hour=18, minute=30), None),
+
+        # no autodetection for timestamp either
+        (
+            (datetime(year=1998, month=4, day=6, hour=18, minute=30), 1000),
+            TimestampObject
+        ),
+
+        # time
+        (timedelta(days=4, hours=4, minutes=24), None),
+
+        # enum is useless in Python, except for interoperability with Java.
+        # Also no autodetection
+        ((5, 6), BinaryEnumObject),
+
+        # arrays of standard types
+        (['String 1', 'String 2'], None),
+        (['Some of us are empty', None, 'But not the others'], None),
+
+        ([decimal.Decimal('2.71828'), decimal.Decimal('100')], None),
+        ([decimal.Decimal('2.1'), None, decimal.Decimal('3.1415')], None),
+
+        ([uuid.uuid4(), uuid.uuid4()], None),
+        (
+            [
+                datetime(year=2010, month=1, day=1),
+                datetime(year=2010, month=12, day=31),
+            ],
+            None,
+        ),
+        ([timedelta(minutes=30), timedelta(hours=2)], None),
+        (
+            [
+                (datetime(year=2010, month=1, day=1), 1000),
+                (datetime(year=2010, month=12, day=31), 200),
+            ],
+            TimestampArrayObject
+        ),
+        ((-1, [(6001, 1), (6002, 2), (6003, 3)]), BinaryEnumArrayObject),
+
+        # object array
+        ((-1, [1, 2, decimal.Decimal('3')]), None),
+
+        # collection
+        ((3, [1, 2, 3]), CollectionObject),
+
+        # map
+        ((1, {'key': 4, 5: 6.0}), None),
+        ((2, {'key': 4, 5: 6.0}), None),
+    ]
+)
+def test_put_get_data(client, cache, value, value_hint):
+
+    result = cache_put(client, cache, 'my_key', value, value_hint=value_hint)
+    assert result.status == 0
+
+    result = cache_get(client, cache, 'my_key')
+    assert result.status == 0
+    assert result.value == value
diff --git a/tests/test_examples.py b/tests/test_examples.py
new file mode 100644
index 0000000..4665d8c
--- /dev/null
+++ b/tests/test_examples.py
@@ -0,0 +1,57 @@
+# 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.
+
+import glob
+import subprocess
+import sys
+
+import pytest
+
+
+SKIP_LIST = [
+    'failover.py',  # it hangs by design
+]
+
+
+def run_subprocess_34(script: str):
+    return subprocess.call([
+        'python',
+        '../examples/{}'.format(script),
+    ])
+
+
+def run_subprocess_35(script: str):
+    return subprocess.run([
+        'python',
+        '../examples/{}'.format(script),
+    ]).returncode
+
+
+@pytest.mark.skipif(
+    condition=not pytest.config.option.examples,
+    reason=(
+        'If you wish to test examples, invoke pytest with '
+        '`--examples` option.'
+    ),
+)
+def test_examples():
+    for script in glob.glob1('../examples', '*.py'):
+        if script not in SKIP_LIST:
+            # `subprocess` module was refactored in Python 3.5
+            if sys.version_info >= (3, 5):
+                return_code = run_subprocess_35(script)
+            else:
+                return_code = run_subprocess_34(script)
+            assert return_code == 0
diff --git a/tests/test_generic_object.py b/tests/test_generic_object.py
new file mode 100644
index 0000000..73dc870
--- /dev/null
+++ b/tests/test_generic_object.py
@@ -0,0 +1,33 @@
+# 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 pyignite import GenericObjectMeta
+from pyignite.datatypes import *
+
+
+def test_go():
+
+    class GenericObject(
+        metaclass=GenericObjectMeta,
+        schema={
+            'TEST_ID': IntObject,
+            'TEST_NAME': String,
+        },
+        version=2,
+    ):
+        pass
+
+    x = GenericObject()
+    print(x.__class__.__name__)
diff --git a/tests/test_get_names.py b/tests/test_get_names.py
new file mode 100644
index 0000000..0e50f3d
--- /dev/null
+++ b/tests/test_get_names.py
@@ -0,0 +1,30 @@
+# 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 pyignite.api import cache_create, cache_get_names
+
+
+def test_get_names(client):
+
+    bucket_names = ['my_bucket', 'my_bucket_2', 'my_bucket_3']
+    for name in bucket_names:
+        cache_create(client, name)
+
+    result = cache_get_names(client)
+    assert result.status == 0
+    assert type(result.value) == list
+    assert len(result.value) >= len(bucket_names)
+    for i, name in enumerate(bucket_names):
+        assert name in result.value
diff --git a/tests/test_handshake.py b/tests/test_handshake.py
new file mode 100644
index 0000000..54315f0
--- /dev/null
+++ b/tests/test_handshake.py
@@ -0,0 +1,63 @@
+# 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.
+
+import socket
+
+from pyignite import Client
+from pyignite.connection.handshake import HandshakeRequest, read_response
+
+
+def test_handshake(
+    monkeypatch,
+    ignite_host, ignite_port, use_ssl, ssl_keyfile, ssl_certfile,
+    ssl_ca_certfile, ssl_cert_reqs, ssl_ciphers, ssl_version,
+    username, password,
+):
+    client = Client(
+        use_ssl=use_ssl,
+        ssl_keyfile=ssl_keyfile,
+        ssl_certfile=ssl_certfile,
+        ssl_ca_certfile=ssl_ca_certfile,
+        ssl_cert_reqs=ssl_cert_reqs,
+        ssl_ciphers=ssl_ciphers,
+        ssl_version=ssl_version,
+        username=username,
+        password=password,
+    )
+    client._socket = client._wrap(
+        socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    )
+    client.socket.connect((ignite_host, ignite_port))
+    hs_request = HandshakeRequest(username, password)
+    client.send(hs_request)
+    hs_response = read_response(client)
+    assert hs_response['op_code'] != 0
+
+    client.close()
+
+    # intentionally pass wrong protocol version
+    from pyignite.connection import handshake
+    monkeypatch.setattr(handshake, 'PROTOCOL_VERSION_MAJOR', 10)
+
+    client._socket = client._wrap(
+        socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    )
+    client.socket.connect((ignite_host, ignite_port))
+    hs_request = HandshakeRequest(username, password)
+    client.send(hs_request)
+    hs_response = read_response(client)
+    assert hs_response['op_code'] == 0
+
+    client.close()
diff --git a/tests/test_key_value.py b/tests/test_key_value.py
new file mode 100644
index 0000000..c569c77
--- /dev/null
+++ b/tests/test_key_value.py
@@ -0,0 +1,327 @@
+# 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 pyignite.api import *
+from pyignite.datatypes import IntObject
+
+
+def test_put_get(client, cache):
+
+    result = cache_put(client, cache, 'my_key', 5)
+    assert result.status == 0
+
+    result = cache_get(client, cache, 'my_key')
+    assert result.status == 0
+    assert result.value == 5
+
+
+def test_get_all(client, cache):
+
+    result = cache_get_all(client, cache, ['key_1', 2, (3, IntObject)])
+    assert result.status == 0
+    assert result.value == {}
+
+    cache_put(client, cache, 'key_1', 4)
+    cache_put(client, cache, 3, 18, key_hint=IntObject)
+
+    result = cache_get_all(client, cache, ['key_1', 2, (3, IntObject)])
+    assert result.status == 0
+    assert result.value == {'key_1': 4, 3: 18}
+
+
+def test_put_all(client, cache):
+
+    test_dict = {
+        1: 2,
+        'key_1': 4,
+        (3, IntObject): 18,
+    }
+    test_keys = ['key_1', 1, 3]
+
+    result = cache_put_all(client, cache, test_dict)
+    assert result.status == 0
+
+    result = cache_get_all(client, cache, test_keys)
+    assert result.status == 0
+    assert len(test_dict) == 3
+
+    for key in result.value:
+        assert key in test_keys
+
+
+def test_contains_key(client, cache):
+
+    cache_put(client, cache, 'test_key', 42)
+
+    result = cache_contains_key(client, cache, 'test_key')
+    assert result.value is True
+
+    result = cache_contains_key(client, cache, 'non-existant-key')
+    assert result.value is False
+
+
+def test_contains_keys(client, cache):
+
+    cache_put(client, cache, 5, 6)
+    cache_put(client, cache, 'test_key', 42)
+
+    result = cache_contains_keys(client, cache, [5, 'test_key'])
+    assert result.value is True
+
+    result = cache_contains_keys(client, cache, [5, 'non-existent-key'])
+    assert result.value is False
+
+
+def test_get_and_put(client, cache):
+
+    result = cache_get_and_put(client, cache, 'test_key', 42)
+    assert result.status == 0
+    assert result.value is None
+
+    result = cache_get(client, cache, 'test_key')
+    assert result.status == 0
+    assert result.value is 42
+
+    result = cache_get_and_put(client, cache, 'test_key', 1234)
+    assert result.status == 0
+    assert result.value == 42
+
+
+def test_get_and_replace(client, cache):
+
+    result = cache_get_and_replace(client, cache, 'test_key', 42)
+    assert result.status == 0
+    assert result.value is None
+
+    result = cache_get(client, cache, 'test_key')
+    assert result.status == 0
+    assert result.value is None
+
+    cache_put(client, cache, 'test_key', 42)
+
+    result = cache_get_and_replace(client, cache, 'test_key', 1234)
+    assert result.status == 0
+    assert result.value == 42
+
+
+def test_get_and_remove(client, cache):
+
+    result = cache_get_and_remove(client, cache, 'test_key')
+    assert result.status == 0
+    assert result.value is None
+
+    cache_put(client, cache, 'test_key', 42)
+
+    result = cache_get_and_remove(client, cache, 'test_key')
+    assert result.status == 0
+    assert result.value == 42
+
+
+def test_put_if_absent(client, cache):
+
+    result = cache_put_if_absent(client, cache, 'test_key', 42)
+    assert result.status == 0
+    assert result.value is True
+
+    result = cache_put_if_absent(client, cache, 'test_key', 1234)
+    assert result.status == 0
+    assert result.value is False
+
+
+def test_get_and_put_if_absent(client, cache):
+
+    result = cache_get_and_put_if_absent(client, cache, 'test_key', 42)
+    assert result.status == 0
+    assert result.value is None
+
+    result = cache_get_and_put_if_absent(client, cache, 'test_key', 1234)
+    assert result.status == 0
+    assert result.value == 42
+
+    result = cache_get_and_put_if_absent(client, cache, 'test_key', 5678)
+    assert result.status == 0
+    assert result.value == 42
+
+
+def test_replace(client, cache):
+
+    result = cache_replace(client, cache, 'test_key', 42)
+    assert result.status == 0
+    assert result.value is False
+
+    cache_put(client, cache, 'test_key', 1234)
+
+    result = cache_replace(client, cache, 'test_key', 42)
+    assert result.status == 0
+    assert result.value is True
+
+    result = cache_get(client, cache, 'test_key')
+    assert result.status == 0
+    assert result.value == 42
+
+
+def test_replace_if_equals(client, cache):
+
+    result = cache_replace_if_equals(client, cache, 'my_test', 42, 1234)
+    assert result.status == 0
+    assert result.value is False
+
+    cache_put(client, cache, 'my_test', 42)
+
+    result = cache_replace_if_equals(client, cache, 'my_test', 42, 1234)
+    assert result.status == 0
+    assert result.value is True
+
+    result = cache_get(client, cache, 'my_test')
+    assert result.status == 0
+    assert result.value == 1234
+
+
+def test_clear(client, cache):
+
+    result = cache_put(client, cache, 'my_test', 42)
+    assert result.status == 0
+
+    result = cache_clear(client, cache)
+    assert result.status == 0
+
+    result = cache_get(client, cache, 'my_test')
+    assert result.status == 0
+    assert result.value is None
+
+
+def test_clear_key(client, cache):
+
+    result = cache_put(client, cache, 'my_test', 42)
+    assert result.status == 0
+
+    result = cache_put(client, cache, 'another_test', 24)
+    assert result.status == 0
+
+    result = cache_clear_key(client, cache, 'my_test')
+    assert result.status == 0
+
+    result = cache_get(client, cache, 'my_test')
+    assert result.status == 0
+    assert result.value is None
+
+    result = cache_get(client, cache, 'another_test')
+    assert result.status == 0
+    assert result.value == 24
+
+
+def test_clear_keys(client, cache):
+
+    result = cache_put(client, cache, 'my_test_key', 42)
+    assert result.status == 0
+
+    result = cache_put(client, cache, 'another_test', 24)
+    assert result.status == 0
+
+    result = cache_clear_keys(client, cache, [
+        'my_test_key',
+        'nonexistent_key',
+    ])
+    assert result.status == 0
+
+    result = cache_get(client, cache, 'my_test_key')
+    assert result.status == 0
+    assert result.value is None
+
+    result = cache_get(client, cache, 'another_test')
+    assert result.status == 0
+    assert result.value == 24
+
+
+def test_remove_key(client, cache):
+
+    result = cache_put(client, cache, 'my_test_key', 42)
+    assert result.status == 0
+
+    result = cache_remove_key(client, cache, 'my_test_key')
+    assert result.status == 0
+    assert result.value is True
+
+    result = cache_remove_key(client, cache, 'non_existent_key')
+    assert result.status == 0
+    assert result.value is False
+
+
+def test_remove_if_equals(client, cache):
+
+    result = cache_put(client, cache, 'my_test', 42)
+    assert result.status == 0
+
+    result = cache_remove_if_equals(client, cache, 'my_test', 1234)
+    assert result.status == 0
+    assert result.value is False
+
+    result = cache_remove_if_equals(client, cache, 'my_test', 42)
+    assert result.status == 0
+    assert result.value is True
+
+    result = cache_get(client, cache, 'my_test')
+    assert result.status == 0
+    assert result.value is None
+
+
+def test_remove_keys(client, cache):
+
+    result = cache_put(client, cache, 'my_test', 42)
+    assert result.status == 0
+
+    result = cache_put(client, cache, 'another_test', 24)
+    assert result.status == 0
+
+    result = cache_remove_keys(client, cache, ['my_test', 'non_existent'])
+    assert result.status == 0
+
+    result = cache_get(client, cache, 'my_test')
+    assert result.status == 0
+    assert result.value is None
+
+    result = cache_get(client, cache, 'another_test')
+    assert result.status == 0
+    assert result.value == 24
+
+
+def test_remove_all(client, cache):
+
+    result = cache_put(client, cache, 'my_test', 42)
+    assert result.status == 0
+
+    result = cache_put(client, cache, 'another_test', 24)
+    assert result.status == 0
+
+    result = cache_remove_all(client, cache)
+    assert result.status == 0
+
+    result = cache_get(client, cache, 'my_test')
+    assert result.status == 0
+    assert result.value is None
+
+    result = cache_get(client, cache, 'another_test')
+    assert result.status == 0
+    assert result.value is None
+
+
+def test_cache_get_size(client, cache):
+
+    result = cache_put(client, cache, 'my_test', 42)
+    assert result.status == 0
+
+    result = cache_get_size(client, cache)
+    assert result.status == 0
+    assert result.value == 1
diff --git a/tests/test_scan.py b/tests/test_scan.py
new file mode 100644
index 0000000..77e9613
--- /dev/null
+++ b/tests/test_scan.py
@@ -0,0 +1,66 @@
+# 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 pyignite.api import (
+    scan, scan_cursor_get_page, resource_close, cache_put_all,
+)
+
+
+def test_scan(client, cache):
+
+    page_size = 10
+
+    result = cache_put_all(client, cache, {
+        'key_{}'.format(v): v for v in range(page_size * 2)
+    })
+    assert result.status == 0
+
+    result = scan(client, cache, page_size)
+    assert result.status == 0
+    assert len(result.value['data']) == page_size
+    assert result.value['more'] is True
+
+    cursor = result.value['cursor']
+
+    result = scan_cursor_get_page(client, cursor)
+    assert result.status == 0
+    assert len(result.value['data']) == page_size
+    assert result.value['more'] is False
+
+    result = scan_cursor_get_page(client, cursor)
+    assert result.status != 0
+
+
+def test_close_resource(client, cache):
+
+    page_size = 10
+
+    result = cache_put_all(client, cache, {
+        'key_{}'.format(v): v for v in range(page_size * 2)
+    })
+    assert result.status == 0
+
+    result = scan(client, cache, page_size)
+    assert result.status == 0
+    assert len(result.value['data']) == page_size
+    assert result.value['more'] is True
+
+    cursor = result.value['cursor']
+
+    result = resource_close(client, cursor)
+    assert result.status == 0
+
+    result = scan_cursor_get_page(client, cursor)
+    assert result.status != 0
diff --git a/tests/test_sql.py b/tests/test_sql.py
new file mode 100644
index 0000000..d3c5f84
--- /dev/null
+++ b/tests/test_sql.py
@@ -0,0 +1,154 @@
+# 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 pyignite.api import (
+    sql_fields, sql_fields_cursor_get_page,
+    cache_get_or_create, sql, sql_cursor_get_page,
+    cache_get_configuration,
+)
+from pyignite.datatypes.prop_codes import *
+from pyignite.utils import entity_id, unwrap_binary
+
+initial_data = [
+        ('John', 'Doe', 5),
+        ('Jane', 'Roe', 4),
+        ('Joe', 'Bloggs', 4),
+        ('Richard', 'Public', 3),
+        ('Negidius', 'Numerius', 3),
+    ]
+
+create_query = '''CREATE TABLE Student (
+    id INT(11) PRIMARY KEY,
+    first_name CHAR(24),
+    last_name CHAR(32),
+    grade INT(11))'''
+
+insert_query = '''INSERT INTO Student(id, first_name, last_name, grade)
+VALUES (?, ?, ?, ?)'''
+
+select_query = 'SELECT id, first_name, last_name, grade FROM Student'
+
+drop_query = 'DROP TABLE Student IF EXISTS'
+
+page_size = 4
+
+
+def test_sql(client):
+
+    # cleanup
+    client.sql(drop_query)
+
+    result = sql_fields(
+        client,
+        'PUBLIC',
+        create_query,
+        page_size,
+        include_field_names=True
+    )
+    assert result.status == 0, result.message
+
+    for i, data_line in enumerate(initial_data, start=1):
+        fname, lname, grade = data_line
+        result = sql_fields(
+            client,
+            'PUBLIC',
+            insert_query,
+            page_size,
+            query_args=[i, fname, lname, grade],
+            include_field_names=True
+        )
+        assert result.status == 0, result.message
+
+    result = cache_get_configuration(client, 'SQL_PUBLIC_STUDENT')
+    assert result.status == 0, result.message
+
+    binary_type_name = result.value[PROP_QUERY_ENTITIES][0]['value_type_name']
+    result = sql(
+        client,
+        'SQL_PUBLIC_STUDENT',
+        binary_type_name,
+        'TRUE',
+        page_size
+    )
+    assert result.status == 0, result.message
+    assert len(result.value['data']) == page_size
+    assert result.value['more'] is True
+
+    for wrapped_object in result.value['data'].values():
+        data = unwrap_binary(client, wrapped_object)
+        assert data.type_id == entity_id(binary_type_name)
+
+    cursor = result.value['cursor']
+
+    while result.value['more']:
+        result = sql_cursor_get_page(client, cursor)
+        assert result.status == 0, result.message
+
+        for wrapped_object in result.value['data'].values():
+            data = unwrap_binary(client, wrapped_object)
+            assert data.type_id == entity_id(binary_type_name)
+
+    # repeat cleanup
+    result = sql_fields(client, 'PUBLIC', drop_query, page_size)
+    assert result.status == 0
+
+
+def test_sql_fields(client):
+
+    # cleanup
+    client.sql(drop_query)
+
+    result = sql_fields(
+        client,
+        'PUBLIC',
+        create_query,
+        page_size,
+        include_field_names=True
+    )
+    assert result.status == 0, result.message
+
+    for i, data_line in enumerate(initial_data, start=1):
+        fname, lname, grade = data_line
+        result = sql_fields(
+            client,
+            'PUBLIC',
+            insert_query,
+            page_size,
+            query_args=[i, fname, lname, grade],
+            include_field_names=True
+        )
+        assert result.status == 0, result.message
+
+    result = sql_fields(
+        client,
+        'PUBLIC',
+        select_query,
+        page_size,
+        include_field_names=True
+    )
+    assert result.status == 0
+    assert len(result.value['data']) == page_size
+    assert result.value['more'] is True
+
+    cursor = result.value['cursor']
+
+    result = sql_fields_cursor_get_page(client, cursor, field_count=4)
+    assert result.status == 0
+    assert len(result.value['data']) == len(initial_data) - page_size
+    assert result.value['more'] is False
+
+    # repeat cleanup
+    result = sql_fields(client, 'PUBLIC', drop_query, page_size)
+    assert result.status == 0