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

clickhouse_driver/util/escape.py

@@ -1,55 +1,94 @@
-from datetime import date, datetime
-from enum import Enum
-from uuid import UUID
-
-
-escape_chars_map = {
-    "\b": "\\b",
-    "\f": "\\f",
-    "\r": "\\r",
-    "\n": "\\n",
-    "\t": "\\t",
-    "\0": "\\0",
-    "\a": "\\a",
-    "\v": "\\v",
-    "\\": "\\\\",
-    "'": "\\'"
-}
-
-
-def escape_param(item):
-    if item is None:
-        return 'NULL'
-
-    elif isinstance(item, datetime):
-        return "'%s'" % item.strftime('%Y-%m-%d %H:%M:%S')
-
-    elif isinstance(item, date):
-        return "'%s'" % item.strftime('%Y-%m-%d')
-
-    elif isinstance(item, str):
-        return "'%s'" % ''.join(escape_chars_map.get(c, c) for c in item)
-
-    elif isinstance(item, list):
-        return "[%s]" % ', '.join(str(escape_param(x)) for x in item)
-
-    elif isinstance(item, tuple):
-        return "(%s)" % ', '.join(str(escape_param(x)) for x in item)
-
-    elif isinstance(item, Enum):
-        return escape_param(item.value)
-
-    elif isinstance(item, UUID):
-        return "'%s'" % str(item)
-
-    else:
-        return item
-
-
-def escape_params(params):
-    escaped = {}
-
-    for key, value in params.items():
-        escaped[key] = escape_param(value)
-
-    return escaped
+from datetime import date, datetime, time
+from enum import Enum
+from functools import wraps
+from uuid import UUID
+
+from pytz import timezone
+
+
+escape_chars_map = {
+    "\b": "\\b",
+    "\f": "\\f",
+    "\r": "\\r",
+    "\n": "\\n",
+    "\t": "\\t",
+    "\0": "\\0",
+    "\a": "\\a",
+    "\v": "\\v",
+    "\\": "\\\\",
+    "'": "\\'"
+}
+
+
+def escape_datetime(item, context):
+    server_tz = timezone(context.server_info.get_timezone())
+
+    if item.tzinfo is not None:
+        item = item.astimezone(server_tz)
+
+    return "'%s'" % item.strftime('%Y-%m-%d %H:%M:%S')
+
+
+def maybe_enquote_for_server(f):
+    @wraps(f)
+    def wrapper(*args, **kwargs):
+        rv = f(*args, **kwargs)
+
+        if kwargs.get('for_server'):
+            is_str = isinstance(rv, str)
+
+            if not is_str or (is_str and not rv.startswith("'")):
+                rv = "'%s'" % rv
+
+        return rv
+
+    return wrapper
+
+
+@maybe_enquote_for_server
+def escape_param(item, context, for_server=False):
+    if item is None:
+        return 'NULL'
+
+    elif isinstance(item, datetime):
+        return escape_datetime(item, context)
+
+    elif isinstance(item, date):
+        return "'%s'" % item.strftime('%Y-%m-%d')
+
+    elif isinstance(item, time):
+        return "'%s'" % item.strftime('%H:%M:%S')
+
+    elif isinstance(item, str):
+        # We need double escaping for server-side parameters.
+        if for_server:
+            item = ''.join(escape_chars_map.get(c, c) for c in item)
+        return "'%s'" % ''.join(escape_chars_map.get(c, c) for c in item)
+
+    elif isinstance(item, list):
+        return "[%s]" % ', '.join(
+            str(escape_param(x, context, for_server=for_server)) for x in item
+        )
+
+    elif isinstance(item, tuple):
+        return "(%s)" % ', '.join(
+            str(escape_param(x, context, for_server=for_server)) for x in item
+        )
+
+    elif isinstance(item, Enum):
+        return escape_param(item.value, context, for_server=for_server)
+
+    elif isinstance(item, UUID):
+        return "'%s'" % str(item)
+
+    else:
+        return item
+
+
+def escape_params(params, context, for_server=False):
+    escaped = {}
+
+    for key, value in params.items():
+        escaped[key] = escape_param(value, context, for_server=for_server)
+
+    return escaped

clickhouse_driver/util/helpers.py

@@ -1,57 +1,173 @@
-from itertools import islice, tee
-
-
-def chunks(seq, n):
-    # islice is MUCH slower than slice for lists and tuples.
-    if isinstance(seq, (list, tuple)):
-        i = 0
-        item = seq[i:i+n]
-        while item:
-            yield list(item)
-            i += n
-            item = seq[i:i+n]
-
-    else:
-        it = iter(seq)
-        item = list(islice(it, n))
-        while item:
-            yield item
-            item = list(islice(it, n))
-
-
-def pairwise(iterable):
-    a, b = tee(iterable)
-    next(b, None)
-    return zip(a, b)
-
-
-def column_chunks(columns, n):
-    for column in columns:
-        if not isinstance(column, (list, tuple)):
-            raise TypeError(
-                'Unsupported column type: {}. list or tuple is expected.'
-                .format(type(column))
-            )
-
-    # create chunk generator for every column
-    g = [chunks(column, n) for column in columns]
-
-    while True:
-        # get next chunk for every column
-        item = [next(column, []) for column in g]
-        if not any(item):
-            break
-        yield item
-
-
-# from paste.deploy.converters
-def asbool(obj):
-    if isinstance(obj, str):
-        obj = obj.strip().lower()
-        if obj in ['true', 'yes', 'on', 'y', 't', '1']:
-            return True
-        elif obj in ['false', 'no', 'off', 'n', 'f', '0']:
-            return False
-        else:
-            raise ValueError('String is not true/false: %r' % obj)
-    return bool(obj)
+import ssl
+from itertools import islice, tee
+from urllib.parse import urlparse, parse_qs, unquote
+
+
+def chunks(seq, n):
+    # islice is MUCH slower than slice for lists and tuples.
+    if isinstance(seq, (list, tuple)):
+        i = 0
+        item = seq[i:i+n]
+        while item:
+            yield list(item)
+            i += n
+            item = seq[i:i+n]
+
+    else:
+        it = iter(seq)
+        item = list(islice(it, n))
+        while item:
+            yield item
+            item = list(islice(it, n))
+
+
+def pairwise(iterable):
+    a, b = tee(iterable)
+    next(b, None)
+    return zip(a, b)
+
+
+def column_chunks(columns, n):
+    for column in columns:
+        if not isinstance(column, (list, tuple)):
+            raise TypeError(
+                'Unsupported column type: {}. list or tuple is expected.'
+                .format(type(column))
+            )
+
+    # create chunk generator for every column
+    g = [chunks(column, n) for column in columns]
+
+    while True:
+        # get next chunk for every column
+        item = [next(column, []) for column in g]
+        if not any(item):
+            break
+        yield item
+
+
+# from paste.deploy.converters
+def asbool(obj):
+    if isinstance(obj, str):
+        obj = obj.strip().lower()
+        if obj in ['true', 'yes', 'on', 'y', 't', '1']:
+            return True
+        elif obj in ['false', 'no', 'off', 'n', 'f', '0']:
+            return False
+        else:
+            raise ValueError('String is not true/false: %r' % obj)
+    return bool(obj)
+
+
+def parse_url(url):
+    """
+    Parses url into host and kwargs suitable for further Client construction.
+    Return host and kwargs.
+
+    For example::
+
+        clickhouse://[user:password]@localhost:9000/default
+        clickhouses://[user:password]@localhost:9440/default
+
+    Three URL schemes are supported:
+
+        * clickhouse:// creates a normal TCP socket connection
+        * clickhouses:// creates a SSL wrapped TCP socket connection
+
+    Any additional querystring arguments will be passed along to
+    the Connection class's initializer.
+    """
+    url = urlparse(url)
+
+    settings = {}
+    kwargs = {}
+
+    host = url.hostname
+
+    if url.port is not None:
+        kwargs['port'] = url.port
+
+    path = url.path.replace('/', '', 1)
+    if path:
+        kwargs['database'] = path
+
+    if url.username is not None:
+        kwargs['user'] = unquote(url.username)
+
+    if url.password is not None:
+        kwargs['password'] = unquote(url.password)
+
+    if url.scheme == 'clickhouses':
+        kwargs['secure'] = True
+
+    compression_algs = {'lz4', 'lz4hc', 'zstd'}
+    timeouts = {
+        'connect_timeout',
+        'send_receive_timeout',
+        'sync_request_timeout'
+    }
+
+    for name, value in parse_qs(url.query).items():
+        if not value or not len(value):
+            continue
+
+        value = value[0]
+
+        if name == 'compression':
+            value = value.lower()
+            if value in compression_algs:
+                kwargs[name] = value
+            else:
+                kwargs[name] = asbool(value)
+
+        elif name == 'secure':
+            kwargs[name] = asbool(value)
+
+        elif name == 'use_numpy':
+            settings[name] = asbool(value)
+
+        elif name == 'round_robin':
+            kwargs[name] = asbool(value)
+
+        elif name == 'client_name':
+            kwargs[name] = value
+
+        elif name in timeouts:
+            kwargs[name] = float(value)
+
+        elif name == 'compress_block_size':
+            kwargs[name] = int(value)
+
+        elif name == 'settings_is_important':
+            kwargs[name] = asbool(value)
+
+        elif name == 'tcp_keepalive':
+            try:
+                kwargs[name] = asbool(value)
+            except ValueError:
+                parts = value.split(',')
+                kwargs[name] = (
+                    int(parts[0]), int(parts[1]), int(parts[2])
+                )
+        elif name == 'client_revision':
+            kwargs[name] = int(value)
+
+        # ssl
+        elif name == 'verify':
+            kwargs[name] = asbool(value)
+        elif name == 'check_hostname':
+            kwargs[name] = asbool(value)
+        elif name == 'ssl_version':
+            kwargs[name] = getattr(ssl, value)
+        elif name in ['ca_certs', 'ciphers', 'keyfile', 'keypass', 'certfile',
+                      'server_hostname']:
+            kwargs[name] = value
+        elif name == 'alt_hosts':
+            kwargs['alt_hosts'] = value
+        else:
+            settings[name] = value
+
+    if settings:
+        kwargs['settings'] = settings
+
+    return host, kwargs

clickhouse_driver/writer.py

@@ -1,67 +1,67 @@
-import struct
-
-from .varint import write_varint
-
-
-MAX_UINT64 = (1 << 64) - 1
-MAX_INT64 = (1 << 63) - 1
-
-
-def _byte(b):
-    return bytes((b, ))
-
-
-def write_binary_str(text, buf):
-    text = text.encode('utf-8')
-    write_binary_bytes(text, buf)
-
-
-def write_binary_bytes(text, buf):
-    write_varint(len(text), buf)
-    buf.write(text)
-
-
-def write_binary_int(number, buf, fmt):
-    """
-    Writes int from buffer with provided format.
-    """
-    fmt = '<' + fmt
-    buf.write(struct.pack(fmt, number))
-
-
-def write_binary_int8(number, buf):
-    write_binary_int(number, buf, 'b')
-
-
-def write_binary_int16(number, buf):
-    write_binary_int(number, buf, 'h')
-
-
-def write_binary_int32(number, buf):
-    write_binary_int(number, buf, 'i')
-
-
-def write_binary_int64(number, buf):
-    write_binary_int(number, buf, 'q')
-
-
-def write_binary_uint8(number, buf):
-    write_binary_int(number, buf, 'B')
-
-
-def write_binary_uint16(number, buf):
-    write_binary_int(number, buf, 'H')
-
-
-def write_binary_uint32(number, buf):
-    write_binary_int(number, buf, 'I')
-
-
-def write_binary_uint64(number, buf):
-    write_binary_int(number, buf, 'Q')
-
-
-def write_binary_uint128(number, buf):
-    fmt = '<QQ'
-    packed = struct.pack(fmt, (number >> 64) & MAX_UINT64, number & MAX_UINT64)
-    buf.write(packed)
+import struct
+
+from .varint import write_varint
+
+
+MAX_UINT64 = (1 << 64) - 1
+MAX_INT64 = (1 << 63) - 1
+
+
+def _byte(b):
+    return bytes((b, ))
+
+
+def write_binary_str(text, buf):
+    text = text.encode('utf-8')
+    write_binary_bytes(text, buf)
+
+
+def write_binary_bytes(text, buf):
+    write_varint(len(text), buf)
+    buf.write(text)
+
+
+def write_binary_int(number, buf, fmt):
+    """
+    Writes int from buffer with provided format.
+    """
+    fmt = '<' + fmt
+    buf.write(struct.pack(fmt, number))
+
+
+def write_binary_int8(number, buf):
+    write_binary_int(number, buf, 'b')
+
+
+def write_binary_int16(number, buf):
+    write_binary_int(number, buf, 'h')
+
+
+def write_binary_int32(number, buf):
+    write_binary_int(number, buf, 'i')
+
+
+def write_binary_int64(number, buf):
+    write_binary_int(number, buf, 'q')
+
+
+def write_binary_uint8(number, buf):
+    write_binary_int(number, buf, 'B')
+
+
+def write_binary_uint16(number, buf):
+    write_binary_int(number, buf, 'H')
+
+
+def write_binary_uint32(number, buf):
+    write_binary_int(number, buf, 'I')
+
+
+def write_binary_uint64(number, buf):
+    write_binary_int(number, buf, 'Q')
+
+
+def write_binary_uint128(number, buf):
+    fmt = '<QQ'
+    packed = struct.pack(fmt, (number >> 64) & MAX_UINT64, number & MAX_UINT64)
+    buf.write(packed)