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

clickhouse_driver/log.py

@@ -1,44 +1,48 @@
-import logging
-
-logger = logging.getLogger(__name__)
-
-
-log_priorities = (
-    'Unknown',
-    'Fatal',
-    'Critical',
-    'Error',
-    'Warning',
-    'Notice',
-    'Information',
-    'Debug',
-    'Trace'
-)
-
-
-def log_block(block):
-    if block is None:
-        return
-
-    column_names = [x[0] for x in block.columns_with_types]
-
-    for row in block.get_rows():
-        row = dict(zip(column_names, row))
-
-        if 1 <= row['priority'] <= 8:
-            priority = log_priorities[row['priority']]
-        else:
-            priority = row[0]
-
-        # thread_number in servers prior 20.x
-        thread_id = row.get('thread_id') or row['thread_number']
-
-        logger.info(
-            '[ %s ] [ %s ] {%s} <%s> %s: %s',
-            row['host_name'],
-            thread_id,
-            row['query_id'],
-            priority,
-            row['source'],
-            row['text']
-        )
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Keep in sync with ClickHouse priorities
+# https://github.com/ClickHouse/ClickHouse/blob/master/src/Interpreters/InternalTextLogsQueue.cpp
+log_priorities = (
+    'Unknown',
+    'Fatal',
+    'Critical',
+    'Error',
+    'Warning',
+    'Notice',
+    'Information',
+    'Debug',
+    'Trace',
+    'Test',
+)
+
+num_priorities = len(log_priorities)
+
+
+def log_block(block):
+    if block is None:
+        return
+
+    column_names = [x[0] for x in block.columns_with_types]
+
+    for row in block.get_rows():
+        row = dict(zip(column_names, row))
+
+        if 1 <= row['priority'] <= num_priorities:
+            priority = log_priorities[row['priority']]
+        else:
+            priority = row[0]
+
+        # thread_number in servers prior 20.x
+        thread_id = row.get('thread_id') or row['thread_number']
+
+        logger.info(
+            '[ %s ] [ %s ] {%s} <%s> %s: %s',
+            row['host_name'],
+            thread_id,
+            row['query_id'],
+            priority,
+            row['source'],
+            row['text']
+        )

clickhouse_driver/numpy/block.py

@@ -1,8 +1,8 @@
-import numpy as np
-
-from ..block import ColumnOrientedBlock
-
-
-class NumpyColumnOrientedBlock(ColumnOrientedBlock):
-    def transposed(self):
-        return np.transpose(self.data)
+import numpy as np
+
+from ..block import ColumnOrientedBlock
+
+
+class NumpyColumnOrientedBlock(ColumnOrientedBlock):
+    def transposed(self):
+        return np.transpose(self.data)

clickhouse_driver/numpy/helpers.py

@@ -1,25 +1,25 @@
-import numpy as np
-import pandas as pd
-
-
-def column_chunks(columns, n):
-    for column in columns:
-        if not isinstance(column, (np.ndarray, pd.DatetimeIndex)):
-            raise TypeError(
-                'Unsupported column type: {}. '
-                'ndarray/DatetimeIndex is expected.'
-                .format(type(column))
-            )
-
-    # create chunk generator for every column
-    chunked = [
-        iter(np.array_split(c, range(0, len(c), n)) if len(c) > n else [c])
-        for c in columns
-    ]
-
-    while True:
-        # get next chunk for every column
-        item = [next(column, []) for column in chunked]
-        if not any(len(x) for x in item):
-            break
-        yield item
+import numpy as np
+import pandas as pd
+
+
+def column_chunks(columns, n):
+    for column in columns:
+        if not isinstance(column, (np.ndarray, pd.DatetimeIndex)):
+            raise TypeError(
+                'Unsupported column type: {}. '
+                'ndarray/DatetimeIndex is expected.'
+                .format(type(column))
+            )
+
+    # create chunk generator for every column
+    chunked = [
+        iter(np.array_split(c, len(c) // n) if len(c) > n else [c])
+        for c in columns
+    ]
+
+    while True:
+        # get next chunk for every column
+        item = [next(column, []) for column in chunked]
+        if not any(len(x) for x in item):
+            break
+        yield item

clickhouse_driver/numpy/result.py

@@ -1,123 +1,123 @@
-from itertools import chain
-
-import numpy as np
-import pandas as pd
-from pandas.api.types import union_categoricals
-
-from ..progress import Progress
-from ..result import QueryResult
-
-
-class NumpyQueryResult(QueryResult):
-    """
-    Stores query result from multiple blocks as numpy arrays.
-    """
-
-    def store(self, packet):
-        block = getattr(packet, 'block', None)
-        if block is None:
-            return
-
-        # Header block contains no rows. Pick columns from it.
-        if block.num_rows:
-            if self.columnar:
-                self.data.append(block.get_columns())
-            else:
-                self.data.extend(block.get_rows())
-
-        elif not self.columns_with_types:
-            self.columns_with_types = block.columns_with_types
-
-    def get_result(self):
-        """
-        :return: stored query result.
-        """
-
-        for packet in self.packet_generator:
-            self.store(packet)
-
-        if self.columnar:
-            data = []
-            # Transpose to a list of columns, each column is list of chunks
-            for column_chunks in zip(*self.data):
-                # Concatenate chunks for each column
-                if isinstance(column_chunks[0], np.ndarray):
-                    column = np.concatenate(column_chunks)
-                elif isinstance(column_chunks[0], pd.Categorical):
-                    column = union_categoricals(column_chunks)
-                else:
-                    column = tuple(chain.from_iterable(column_chunks))
-                data.append(column)
-        else:
-            data = self.data
-
-        if self.with_column_types:
-            return data, self.columns_with_types
-        else:
-            return data
-
-
-class NumpyProgressQueryResult(NumpyQueryResult):
-    """
-    Stores query result and progress information from multiple blocks.
-    Provides iteration over query progress.
-    """
-
-    def __init__(self, *args, **kwargs):
-        self.progress_totals = Progress()
-
-        super(NumpyProgressQueryResult, self).__init__(*args, **kwargs)
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        while True:
-            packet = next(self.packet_generator)
-            progress_packet = getattr(packet, 'progress', None)
-            if progress_packet:
-                self.progress_totals.increment(progress_packet)
-                return (
-                    self.progress_totals.rows, self.progress_totals.total_rows
-                )
-            else:
-                self.store(packet)
-
-    def get_result(self):
-        # Read all progress packets.
-        for _ in self:
-            pass
-
-        return super(NumpyProgressQueryResult, self).get_result()
-
-
-class NumpyIterQueryResult(object):
-    """
-    Provides iteration over returned data by chunks (streaming by chunks).
-    """
-
-    def __init__(
-            self, packet_generator,
-            with_column_types=False):
-        self.packet_generator = packet_generator
-        self.with_column_types = with_column_types
-
-        self.first_block = True
-        super(NumpyIterQueryResult, self).__init__()
-
-    def __iter__(self):
-        return self
-
-    def __next__(self):
-        packet = next(self.packet_generator)
-        block = getattr(packet, 'block', None)
-        if block is None:
-            return []
-
-        if self.first_block and self.with_column_types:
-            self.first_block = False
-            rv = [block.columns_with_types]
-            rv.extend(block.get_rows())
-            return rv
-        else:
-            return block.get_rows()
+from itertools import chain
+
+import numpy as np
+import pandas as pd
+from pandas.api.types import union_categoricals
+
+from ..progress import Progress
+from ..result import QueryResult
+
+
+class NumpyQueryResult(QueryResult):
+    """
+    Stores query result from multiple blocks as numpy arrays.
+    """
+
+    def store(self, packet):
+        block = getattr(packet, 'block', None)
+        if block is None:
+            return
+
+        # Header block contains no rows. Pick columns from it.
+        if block.num_rows:
+            if self.columnar:
+                self.data.append(block.get_columns())
+            else:
+                self.data.extend(block.get_rows())
+
+        elif not self.columns_with_types:
+            self.columns_with_types = block.columns_with_types
+
+    def get_result(self):
+        """
+        :return: stored query result.
+        """
+
+        for packet in self.packet_generator:
+            self.store(packet)
+
+        if self.columnar:
+            data = []
+            # Transpose to a list of columns, each column is list of chunks
+            for column_chunks in zip(*self.data):
+                # Concatenate chunks for each column
+                if isinstance(column_chunks[0], np.ndarray):
+                    column = np.concatenate(column_chunks)
+                elif isinstance(column_chunks[0], pd.Categorical):
+                    column = union_categoricals(column_chunks)
+                else:
+                    column = tuple(chain.from_iterable(column_chunks))
+                data.append(column)
+        else:
+            data = self.data
+
+        if self.with_column_types:
+            return data, self.columns_with_types
+        else:
+            return data
+
+
+class NumpyProgressQueryResult(NumpyQueryResult):
+    """
+    Stores query result and progress information from multiple blocks.
+    Provides iteration over query progress.
+    """
+
+    def __init__(self, *args, **kwargs):
+        self.progress_totals = Progress()
+
+        super(NumpyProgressQueryResult, self).__init__(*args, **kwargs)
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        while True:
+            packet = next(self.packet_generator)
+            progress_packet = getattr(packet, 'progress', None)
+            if progress_packet:
+                self.progress_totals.increment(progress_packet)
+                return (
+                    self.progress_totals.rows, self.progress_totals.total_rows
+                )
+            else:
+                self.store(packet)
+
+    def get_result(self):
+        # Read all progress packets.
+        for _ in self:
+            pass
+
+        return super(NumpyProgressQueryResult, self).get_result()
+
+
+class NumpyIterQueryResult(object):
+    """
+    Provides iteration over returned data by chunks (streaming by chunks).
+    """
+
+    def __init__(
+            self, packet_generator,
+            with_column_types=False):
+        self.packet_generator = packet_generator
+        self.with_column_types = with_column_types
+
+        self.first_block = True
+        super(NumpyIterQueryResult, self).__init__()
+
+    def __iter__(self):
+        return self
+
+    def __next__(self):
+        packet = next(self.packet_generator)
+        block = getattr(packet, 'block', None)
+        if block is None:
+            return []
+
+        if self.first_block and self.with_column_types:
+            self.first_block = False
+            rv = [block.columns_with_types]
+            rv.extend(block.get_rows())
+            return rv
+        else:
+            return block.get_rows()

clickhouse_driver/opentelemetry.py

@@ -0,0 +1,43 @@
+
+class OpenTelemetryTraceContext(object):
+    traceparent_tpl = 'xx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx-xx'
+    translation = str.maketrans('1234567890abcdef', 'xxxxxxxxxxxxxxxx')
+
+    def __init__(self, traceparent, tracestate):
+        # xx-xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx-xxxxxxxxxxxxxxxx-xx
+        # ^              ^                           ^         ^
+        # version     trace_id                    span_id      flags
+
+        self.trace_id = None  # UUID
+        self.span_id = None  # UInt64
+        self.tracestate = tracestate  # String
+        self.trace_flags = None  # UInt8
+
+        if traceparent is not None:
+            self.parse_traceparent(traceparent)
+
+        super(OpenTelemetryTraceContext, self).__init__()
+
+    def parse_traceparent(self, traceparent):
+        traceparent = traceparent.lower()
+
+        if len(traceparent) != len(self.traceparent_tpl):
+            raise ValueError('unexpected length {}, expected {}'.format(
+                len(traceparent), len(self.traceparent_tpl)
+            ))
+
+        if traceparent.translate(self.translation) != self.traceparent_tpl:
+            raise ValueError(
+                'Malformed traceparant header: {}'.format(traceparent)
+            )
+
+        parts = traceparent.split('-')
+        version = int(parts[0], 16)
+        if version != 0:
+            raise ValueError(
+                'unexpected version {}, expected 00'.format(parts[0])
+            )
+
+        self.trace_id = (int(parts[1][16:], 16) << 64) + int(parts[1][:16], 16)
+        self.span_id = int(parts[2], 16)
+        self.trace_flags = int(parts[3], 16)

clickhouse_driver/progress.py

@@ -1,32 +1,38 @@
-from . import defines
-from .varint import read_varint
-
-
-class Progress(object):
-    def __init__(self):
-        self.rows = 0
-        self.bytes = 0
-        self.total_rows = 0
-        self.written_rows = 0
-        self.written_bytes = 0
-
-        super(Progress, self).__init__()
-
-    def read(self, server_revision, fin):
-        self.rows = read_varint(fin)
-        self.bytes = read_varint(fin)
-
-        revision = server_revision
-        if revision >= defines.DBMS_MIN_REVISION_WITH_TOTAL_ROWS_IN_PROGRESS:
-            self.total_rows = read_varint(fin)
-
-        if revision >= defines.DBMS_MIN_REVISION_WITH_CLIENT_WRITE_INFO:
-            self.written_rows = read_varint(fin)
-            self.written_bytes = read_varint(fin)
-
-    def increment(self, another_progress):
-        self.rows += another_progress.rows
-        self.bytes += another_progress.bytes
-        self.total_rows += another_progress.total_rows
-        self.written_rows += another_progress.written_rows
-        self.written_bytes += another_progress.written_bytes
+from . import defines
+from .varint import read_varint
+
+
+class Progress(object):
+    def __init__(self):
+        self.rows = 0
+        self.bytes = 0
+        self.total_rows = 0
+        self.written_rows = 0
+        self.written_bytes = 0
+        self.elapsed_ns = 0
+
+        super(Progress, self).__init__()
+
+    def read(self, server_info, fin):
+        self.rows = read_varint(fin)
+        self.bytes = read_varint(fin)
+
+        revision = server_info.used_revision
+        if revision >= defines.DBMS_MIN_REVISION_WITH_TOTAL_ROWS_IN_PROGRESS:
+            self.total_rows = read_varint(fin)
+
+        if revision >= defines.DBMS_MIN_REVISION_WITH_CLIENT_WRITE_INFO:
+            self.written_rows = read_varint(fin)
+            self.written_bytes = read_varint(fin)
+
+        if revision >= defines. \
+                DBMS_MIN_PROTOCOL_VERSION_WITH_SERVER_QUERY_TIME_IN_PROGRESS:
+            self.elapsed_ns = read_varint(fin)
+
+    def increment(self, another_progress):
+        self.rows += another_progress.rows
+        self.bytes += another_progress.bytes
+        self.total_rows += another_progress.total_rows
+        self.written_rows += another_progress.written_rows
+        self.written_bytes += another_progress.written_bytes
+        self.elapsed_ns += another_progress.elapsed_ns