clickhouse-driver 0.2.1__cp39-cp39-win_amd64.whl → 0.2.10__cp39-cp39-win_amd64.whl

clickhouse_driver/settings/types.py

@@ -1,50 +1,50 @@
-from ..util.helpers import asbool
-from ..varint import write_varint
-from ..writer import write_binary_str
-
-
-class SettingType(object):
-    @classmethod
-    def write(cls, value, buf):
-        raise NotImplementedError
-
-
-class SettingUInt64(SettingType):
-    @classmethod
-    def write(cls, value, buf):
-        write_varint(int(value), buf)
-
-
-class SettingBool(SettingType):
-    @classmethod
-    def write(cls, value, buf):
-        write_varint(asbool(value), buf)
-
-
-class SettingString(SettingType):
-    @classmethod
-    def write(cls, value, buf):
-        write_binary_str(value, buf)
-
-
-class SettingChar(SettingType):
-    @classmethod
-    def write(cls, value, buf):
-        write_binary_str(value[0], buf)
-
-
-class SettingFloat(SettingType):
-    @classmethod
-    def write(cls, value, buf):
-        """
-        Float is written in string representation.
-        """
-        write_binary_str(str(value), buf)
-
-
-class SettingMaxThreads(SettingUInt64):
-    @classmethod
-    def write(cls, value, buf):
-        if value == 'auto':
-            value = 0
-        super(SettingMaxThreads, cls).write(value, buf)
+from ..util.helpers import asbool
+from ..varint import write_varint
+from ..writer import write_binary_str
+
+
+class SettingType(object):
+    @classmethod
+    def write(cls, value, buf):
+        raise NotImplementedError
+
+
+class SettingUInt64(SettingType):
+    @classmethod
+    def write(cls, value, buf):
+        write_varint(int(value), buf)
+
+
+class SettingBool(SettingType):
+    @classmethod
+    def write(cls, value, buf):
+        write_varint(asbool(value), buf)
+
+
+class SettingString(SettingType):
+    @classmethod
+    def write(cls, value, buf):
+        write_binary_str(value, buf)
+
+
+class SettingChar(SettingType):
+    @classmethod
+    def write(cls, value, buf):
+        write_binary_str(value[0], buf)
+
+
+class SettingFloat(SettingType):
+    @classmethod
+    def write(cls, value, buf):
+        """
+        Float is written in string representation.
+        """
+        write_binary_str(str(value), buf)
+
+
+class SettingMaxThreads(SettingUInt64):
+    @classmethod
+    def write(cls, value, buf):
+        if value == 'auto':
+            value = 0
+        super(SettingMaxThreads, cls).write(value, buf)

clickhouse_driver/settings/writer.py

@@ -1,29 +1,34 @@
-import logging
-
-from ..writer import write_binary_str, write_binary_uint8
-from .available import settings as available_settings
-
-
-logger = logging.getLogger(__name__)
-
-
-def write_settings(settings, buf, settings_as_strings, is_important=False):
-    for setting, value in (settings or {}).items():
-        # If the server support settings as string we do not need to know
-        # anything about them, so we can write any setting.
-        if settings_as_strings:
-            write_binary_str(setting, buf)
-            write_binary_uint8(int(is_important), buf)
-            write_binary_str(str(value), buf)
-
-        else:
-            # If the server requires string in binary,
-            # then they cannot be written without type.
-            setting_writer = available_settings.get(setting)
-            if not setting_writer:
-                logger.warning('Unknown setting %s. Skipping', setting)
-                continue
-            write_binary_str(setting, buf)
-            setting_writer.write(value, buf)
-
-    write_binary_str('', buf)  # end of settings
+import logging
+
+from ..writer import write_binary_str, write_binary_uint8
+from .available import settings as available_settings
+
+
+logger = logging.getLogger(__name__)
+
+
+class SettingsFlags:
+    IMPORTANT = 0x1
+    CUSTOM = 0x2
+
+
+def write_settings(settings, buf, settings_as_strings, flags):
+    for setting, value in (settings or {}).items():
+        # If the server support settings as string we do not need to know
+        # anything about them, so we can write any setting.
+        if settings_as_strings:
+            write_binary_str(setting, buf)
+            write_binary_uint8(flags, buf)
+            write_binary_str(str(value), buf)
+
+        else:
+            # If the server requires string in binary,
+            # then they cannot be written without type.
+            setting_writer = available_settings.get(setting)
+            if not setting_writer:
+                logger.warning('Unknown setting %s. Skipping', setting)
+                continue
+            write_binary_str(setting, buf)
+            setting_writer.write(value, buf)
+
+    write_binary_str('', buf)  # end of settings

clickhouse_driver/streams/compressed.py

@@ -1,88 +1,88 @@
-from io import BytesIO
-
-try:
-    from clickhouse_cityhash.cityhash import CityHash128
-except ImportError:
-    raise RuntimeError(
-        'Package clickhouse-cityhash is required to use compression'
-    )
-
-from .native import BlockOutputStream, BlockInputStream
-from ..bufferedreader import CompressedBufferedReader
-from ..bufferedwriter import CompressedBufferedWriter
-from ..compression import get_decompressor_cls
-from ..defines import BUFFER_SIZE
-from ..reader import read_binary_uint8, read_binary_uint128
-from ..writer import write_binary_uint8, write_binary_uint128
-
-
-class CompressedBlockOutputStream(BlockOutputStream):
-    def __init__(self, compressor_cls, compress_block_size, fout, context):
-        self.compressor_cls = compressor_cls
-        self.compress_block_size = compress_block_size
-        self.raw_fout = fout
-
-        self.compressor = self.compressor_cls()
-        self.fout = CompressedBufferedWriter(self.compressor, BUFFER_SIZE)
-        super(CompressedBlockOutputStream, self).__init__(self.fout, context)
-
-    def get_compressed_hash(self, data):
-        return CityHash128(data)
-
-    def finalize(self):
-        self.fout.flush()
-
-        compressed = self.get_compressed()
-        compressed_size = len(compressed)
-
-        compressed_hash = self.get_compressed_hash(compressed)
-        write_binary_uint128(compressed_hash, self.raw_fout)
-
-        block_size = self.compress_block_size
-
-        i = 0
-        while i < compressed_size:
-            self.raw_fout.write(compressed[i:i + block_size])
-            i += block_size
-
-        self.raw_fout.flush()
-
-    def get_compressed(self):
-        compressed = BytesIO()
-
-        if self.compressor.method_byte is not None:
-            write_binary_uint8(self.compressor.method_byte, compressed)
-            extra_header_size = 1  # method
-        else:
-            extra_header_size = 0
-
-        data = self.compressor.get_compressed_data(extra_header_size)
-        compressed.write(data)
-
-        return compressed.getvalue()
-
-
-class CompressedBlockInputStream(BlockInputStream):
-    def __init__(self, fin, context):
-        self.raw_fin = fin
-        fin = CompressedBufferedReader(self.read_block, BUFFER_SIZE)
-        super(CompressedBlockInputStream, self).__init__(fin, context)
-
-    def get_compressed_hash(self, data):
-        return CityHash128(data)
-
-    def read_block(self):
-        compressed_hash = read_binary_uint128(self.raw_fin)
-        method_byte = read_binary_uint8(self.raw_fin)
-
-        decompressor_cls = get_decompressor_cls(method_byte)
-        decompressor = decompressor_cls(self.raw_fin)
-
-        if decompressor.method_byte is not None:
-            extra_header_size = 1  # method
-        else:
-            extra_header_size = 0
-
-        return decompressor.get_decompressed_data(
-            method_byte, compressed_hash, extra_header_size
-        )
+from io import BytesIO
+
+try:
+    from clickhouse_cityhash.cityhash import CityHash128
+except ImportError:
+    raise RuntimeError(
+        'Package clickhouse-cityhash is required to use compression'
+    )
+
+from .native import BlockOutputStream, BlockInputStream
+from ..bufferedreader import CompressedBufferedReader
+from ..bufferedwriter import CompressedBufferedWriter
+from ..compression import get_decompressor_cls
+from ..defines import BUFFER_SIZE
+from ..reader import read_binary_uint8, read_binary_uint128
+from ..writer import write_binary_uint8, write_binary_uint128
+
+
+class CompressedBlockOutputStream(BlockOutputStream):
+    def __init__(self, compressor_cls, compress_block_size, fout, context):
+        self.compressor_cls = compressor_cls
+        self.compress_block_size = compress_block_size
+        self.raw_fout = fout
+
+        self.compressor = self.compressor_cls()
+        self.fout = CompressedBufferedWriter(self.compressor, BUFFER_SIZE)
+        super(CompressedBlockOutputStream, self).__init__(self.fout, context)
+
+    def get_compressed_hash(self, data):
+        return CityHash128(data)
+
+    def finalize(self):
+        self.fout.flush()
+
+        compressed = self.get_compressed()
+        compressed_size = len(compressed)
+
+        compressed_hash = self.get_compressed_hash(compressed)
+        write_binary_uint128(compressed_hash, self.raw_fout)
+
+        block_size = self.compress_block_size
+
+        i = 0
+        while i < compressed_size:
+            self.raw_fout.write(compressed[i:i + block_size])
+            i += block_size
+
+        self.raw_fout.flush()
+
+    def get_compressed(self):
+        compressed = BytesIO()
+
+        if self.compressor.method_byte is not None:
+            write_binary_uint8(self.compressor.method_byte, compressed)
+            extra_header_size = 1  # method
+        else:
+            extra_header_size = 0
+
+        data = self.compressor.get_compressed_data(extra_header_size)
+        compressed.write(data)
+
+        return compressed.getvalue()
+
+
+class CompressedBlockInputStream(BlockInputStream):
+    def __init__(self, fin, context):
+        self.raw_fin = fin
+        fin = CompressedBufferedReader(self.read_block, BUFFER_SIZE)
+        super(CompressedBlockInputStream, self).__init__(fin, context)
+
+    def get_compressed_hash(self, data):
+        return CityHash128(data)
+
+    def read_block(self):
+        compressed_hash = read_binary_uint128(self.raw_fin)
+        method_byte = read_binary_uint8(self.raw_fin)
+
+        decompressor_cls = get_decompressor_cls(method_byte)
+        decompressor = decompressor_cls(self.raw_fin)
+
+        if decompressor.method_byte is not None:
+            extra_header_size = 1  # method
+        else:
+            extra_header_size = 0
+
+        return decompressor.get_decompressed_data(
+            method_byte, compressed_hash, extra_header_size
+        )

clickhouse_driver/streams/native.py

@@ -1,90 +1,108 @@
-from ..block import ColumnOrientedBlock, BlockInfo
-from ..columns.service import read_column, write_column
-from ..reader import read_binary_str
-from ..varint import write_varint, read_varint
-from ..writer import write_binary_str
-from .. import defines
-
-
-class BlockOutputStream(object):
-    def __init__(self, fout, context):
-        self.fout = fout
-        self.context = context
-
-        super(BlockOutputStream, self).__init__()
-
-    def write(self, block):
-        revision = self.context.server_info.revision
-        if revision >= defines.DBMS_MIN_REVISION_WITH_BLOCK_INFO:
-            block.info.write(self.fout)
-
-        # We write transposed data.
-        n_columns = block.num_columns
-        n_rows = block.num_rows
-
-        write_varint(n_columns, self.fout)
-        write_varint(n_rows, self.fout)
-
-        for i, (col_name, col_type) in enumerate(block.columns_with_types):
-            write_binary_str(col_name, self.fout)
-            write_binary_str(col_type, self.fout)
-
-            if n_columns:
-                try:
-                    items = block.get_column_by_index(i)
-                except IndexError:
-                    raise ValueError('Different rows length')
-
-                write_column(self.context, col_name, col_type, items,
-                             self.fout, types_check=block.types_check)
-
-        self.finalize()
-
-    def finalize(self):
-        self.fout.flush()
-
-
-class BlockInputStream(object):
-    def __init__(self, fin, context):
-        self.fin = fin
-        self.context = context
-
-        super(BlockInputStream, self).__init__()
-
-    def read(self):
-        info = BlockInfo()
-
-        revision = self.context.server_info.revision
-        if revision >= defines.DBMS_MIN_REVISION_WITH_BLOCK_INFO:
-            info.read(self.fin)
-
-        n_columns = read_varint(self.fin)
-        n_rows = read_varint(self.fin)
-
-        data, names, types = [], [], []
-
-        for i in range(n_columns):
-            column_name = read_binary_str(self.fin)
-            column_type = read_binary_str(self.fin)
-
-            names.append(column_name)
-            types.append(column_type)
-
-            if n_rows:
-                column = read_column(self.context, column_type, n_rows,
-                                     self.fin)
-                data.append(column)
-
-        if self.context.client_settings['use_numpy']:
-            from ..numpy.block import NumpyColumnOrientedBlock
-            block_cls = NumpyColumnOrientedBlock
-        else:
-            block_cls = ColumnOrientedBlock
-
-        block = block_cls(
-            columns_with_types=list(zip(names, types)),
-            data=data,
-            info=info,
-        )
-
-        return block
+import logging
+
+from ..block import ColumnOrientedBlock, BlockInfo
+from ..columns.service import read_column, write_column
+from ..reader import read_binary_str, read_binary_uint8
+from ..varint import write_varint, read_varint
+from ..writer import write_binary_str, write_binary_uint8
+from .. import defines
+
+logger = logging.getLogger(__name__)
+
+
+class BlockOutputStream(object):
+    def __init__(self, fout, context):
+        self.fout = fout
+        self.context = context
+
+        super(BlockOutputStream, self).__init__()
+
+    def write(self, block):
+        revision = self.context.server_info.used_revision
+        if revision >= defines.DBMS_MIN_REVISION_WITH_BLOCK_INFO:
+            block.info.write(self.fout)
+
+        # We write transposed data.
+        n_columns = block.num_columns
+        n_rows = block.num_rows
+
+        write_varint(n_columns, self.fout)
+        write_varint(n_rows, self.fout)
+
+        for i, (col_name, col_type) in enumerate(block.columns_with_types):
+            write_binary_str(col_name, self.fout)
+            write_binary_str(col_type, self.fout)
+
+            if n_columns:
+                try:
+                    items = block.get_column_by_index(i)
+                except IndexError:
+                    raise ValueError('Different rows length')
+
+                if revision >= \
+                        defines.DBMS_MIN_REVISION_WITH_CUSTOM_SERIALIZATION:
+                    # We write always sparse data without custom serialization.
+                    write_binary_uint8(0, self.fout)
+
+                logger.debug('Writing column %s', col_name)
+                write_column(self.context, col_name, col_type, items,
+                             self.fout, types_check=block.types_check)
+
+        self.finalize()
+
+    def finalize(self):
+        self.fout.flush()
+
+
+class BlockInputStream(object):
+    def __init__(self, fin, context):
+        self.fin = fin
+        self.context = context
+
+        super(BlockInputStream, self).__init__()
+
+    def read(self, use_numpy=None):
+        info = BlockInfo()
+
+        revision = self.context.server_info.used_revision
+        if revision >= defines.DBMS_MIN_REVISION_WITH_BLOCK_INFO:
+            info.read(self.fin)
+
+        n_columns = read_varint(self.fin)
+        n_rows = read_varint(self.fin)
+
+        data, names, types = [], [], []
+
+        for i in range(n_columns):
+            column_name = read_binary_str(self.fin)
+            column_type = read_binary_str(self.fin)
+
+            names.append(column_name)
+            types.append(column_type)
+
+            has_custom_serialization = False
+            if revision >= defines.DBMS_MIN_REVISION_WITH_CUSTOM_SERIALIZATION:
+                has_custom_serialization = bool(read_binary_uint8(self.fin))
+
+            if n_rows:
+                logger.debug('Reading column %s', column_name)
+                column = read_column(
+                    self.context, column_type, n_rows,
+                    self.fin, use_numpy=use_numpy,
+                    has_custom_serialization=has_custom_serialization
+                )
+                data.append(column)
+
+        if self.context.client_settings['use_numpy']:
+            from ..numpy.block import NumpyColumnOrientedBlock
+            block_cls = NumpyColumnOrientedBlock
+        else:
+            block_cls = ColumnOrientedBlock
+
+        block = block_cls(
+            columns_with_types=list(zip(names, types)),
+            data=data,
+            info=info,
+        )
+
+        return block

clickhouse_driver/util/compat.py

@@ -0,0 +1,39 @@
+
+# Drop this when minimum supported version will be 3.7.
+try:
+    import threading
+except ImportError:
+    import dummy_threading as threading  # noqa: F401
+
+import json  # noqa: F401
+try:
+    import orjson as json  # noqa: F811
+except ImportError:
+    pass
+
+try:
+    import ujson as json  # noqa: F811,F401
+except ImportError:
+    pass
+
+
+try:
+    # since tzlocal 4.0+
+    # this will avoid warning for get_localzone().key
+    from tzlocal import get_localzone_name
+
+    def get_localzone_name_compat():
+        try:
+            return get_localzone_name()
+        except Exception:
+            return None
+except ImportError:
+    from tzlocal import get_localzone
+
+    def get_localzone_name_compat():
+        try:
+            return get_localzone().key
+        except AttributeError:
+            return get_localzone().zone
+        except Exception:
+            return None