clickhouse-driver 0.2.5__cp311-cp311-musllinux_1_1_aarch64.whl → 0.2.9__cp311-cp311-musllinux_1_1_aarch64.whl

clickhouse_driver/connection.py

@@ -3,6 +3,7 @@ import socket
 import ssl
 from collections import deque
 from contextlib import contextmanager
+from sys import platform
 from time import time
 from urllib.parse import urlparse
 
@@ -19,11 +20,12 @@ from .log import log_block
 from .progress import Progress
 from .protocol import Compression, ClientPacketTypes, ServerPacketTypes
 from .queryprocessingstage import QueryProcessingStage
-from .reader import read_binary_str
+from .reader import read_binary_str, read_binary_uint64
 from .readhelpers import read_exception
-from .settings.writer import write_settings
+from .settings.writer import write_settings, SettingsFlags
 from .streams.native import BlockInputStream, BlockOutputStream
 from .util.compat import threading
+from .util.escape import escape_params
 from .varint import write_varint, read_varint
 from .writer import write_binary_str
 
@@ -44,17 +46,22 @@ class Packet(object):
 
 class ServerInfo(object):
     def __init__(self, name, version_major, version_minor, version_patch,
-                 revision, timezone, display_name):
+                 revision, timezone, display_name, used_revision):
         self.name = name
         self.version_major = version_major
         self.version_minor = version_minor
         self.version_patch = version_patch
         self.revision = revision
         self.timezone = timezone
+        self.session_timezone = None
         self.display_name = display_name
+        self.used_revision = used_revision
 
         super(ServerInfo, self).__init__()
 
+    def get_timezone(self):
+        return self.session_timezone or self.timezone
+
     def version_tuple(self):
         return self.version_major, self.version_minor, self.version_patch
 
@@ -66,6 +73,7 @@ class ServerInfo(object):
             ('name', self.name),
             ('version', version),
             ('revision', self.revision),
+            ('used revision', self.used_revision),
             ('timezone', self.timezone),
             ('display_name', self.display_name)
         ]
@@ -124,6 +132,15 @@ class Connection(object):
                                   ignored, ``True`` means that the query will
                                   fail with UNKNOWN_SETTING error.
                                   Defaults to ``False``.
+    :param tcp_keepalive: enables `TCP keepalive <https://tldp.org/HOWTO/
+                          TCP-Keepalive-HOWTO/overview.html>`_ on established
+                          connection. If is set to ``True``` system keepalive
+                          settings are used. You can also specify custom
+                          keepalive setting with tuple:
+                          ``(idle_time_sec, interval_sec, probes)``.
+                          Defaults to ``False``.
+    :param client_revision: can be used for client version downgrading.
+                          Defaults to ``None``.
     """
 
     def __init__(
@@ -143,6 +160,8 @@ class Connection(object):
             server_hostname=None,
             alt_hosts=None,
             settings_is_important=False,
+            tcp_keepalive=False,
+            client_revision=None
     ):
         if secure:
             default_port = defines.DEFAULT_SECURE_PORT
@@ -164,6 +183,10 @@ class Connection(object):
         self.send_receive_timeout = send_receive_timeout
         self.sync_request_timeout = sync_request_timeout
         self.settings_is_important = settings_is_important
+        self.tcp_keepalive = tcp_keepalive
+        self.client_revision = min(
+            client_revision or defines.CLIENT_REVISION, defines.CLIENT_REVISION
+        )
 
         self.secure_socket = secure
         self.verify_cert = verify
@@ -282,19 +305,19 @@ class Connection(object):
     def _create_ssl_context(self, ssl_options):
         purpose = ssl.Purpose.SERVER_AUTH
 
-        version = ssl_options.get('ssl_version', ssl.PROTOCOL_TLS)
+        version = ssl_options.get('ssl_version', ssl.PROTOCOL_TLS_CLIENT)
         context = ssl.SSLContext(version)
+        context.check_hostname = self.verify_cert
 
         if 'ca_certs' in ssl_options:
             context.load_verify_locations(ssl_options['ca_certs'])
         elif ssl_options.get('cert_reqs') != ssl.CERT_NONE:
-            context.load_default_certs(purpose
-                                       )
+            context.load_default_certs(purpose)
         if 'ciphers' in ssl_options:
             context.set_ciphers(ssl_options['ciphers'])
 
         if 'cert_reqs' in ssl_options:
-            context.options = ssl_options['cert_reqs']
+            context.verify_mode = ssl_options['cert_reqs']
 
         if 'certfile' in ssl_options:
             keyfile = ssl_options.get('keyfile')
@@ -310,6 +333,8 @@ class Connection(object):
 
         # performance tweak
         self.socket.setsockopt(socket.IPPROTO_TCP, socket.TCP_NODELAY, 1)
+        if self.tcp_keepalive:
+            self._set_keepalive()
 
         self.fin = BufferedSocketReader(self.socket, defines.BUFFER_SIZE)
         self.fout = BufferedSocketWriter(self.socket, defines.BUFFER_SIZE)
@@ -317,10 +342,42 @@ class Connection(object):
         self.send_hello()
         self.receive_hello()
 
+        revision = self.server_info.used_revision
+        if revision >= defines.DBMS_MIN_PROTOCOL_VERSION_WITH_ADDENDUM:
+            self.send_addendum()
+
         self.block_in = self.get_block_in_stream()
         self.block_in_raw = BlockInputStream(self.fin, self.context)
         self.block_out = self.get_block_out_stream()
 
+    def _set_keepalive(self):
+        self.socket.setsockopt(socket.SOL_SOCKET, socket.SO_KEEPALIVE, 1)
+
+        if not isinstance(self.tcp_keepalive, tuple):
+            return
+
+        idle_time_sec, interval_sec, probes = self.tcp_keepalive
+
+        if platform == 'linux' or platform == 'win32':
+            # This should also work for Windows
+            # starting with Windows 10, version 1709.
+            self.socket.setsockopt(
+                socket.IPPROTO_TCP, socket.TCP_KEEPIDLE, idle_time_sec
+            )
+            self.socket.setsockopt(
+                socket.IPPROTO_TCP, socket.TCP_KEEPINTVL, interval_sec
+            )
+            self.socket.setsockopt(
+                socket.IPPROTO_TCP, socket.TCP_KEEPCNT, probes
+            )
+
+        elif platform == 'darwin':
+            TCP_KEEPALIVE = 0x10
+            # Only interval is available in mac os.
+            self.socket.setsockopt(
+                socket.IPPROTO_TCP, TCP_KEEPALIVE, interval_sec
+            )
+
     def _format_connection_error(self, e, host, port):
         err = (e.strerror + ' ') if e.strerror else ''
         return err + '({}:{})'.format(host, port)
@@ -410,7 +467,7 @@ class Connection(object):
         write_varint(defines.CLIENT_VERSION_MINOR, self.fout)
         # NOTE For backward compatibility of the protocol,
         # client cannot send its version_patch.
-        write_varint(defines.CLIENT_REVISION, self.fout)
+        write_varint(self.client_revision, self.fout)
         write_binary_str(self.database, self.fout)
         write_binary_str(self.user, self.fout)
         write_binary_str(self.password, self.fout)
@@ -426,25 +483,38 @@ class Connection(object):
             server_version_minor = read_varint(self.fin)
             server_revision = read_varint(self.fin)
 
+            used_revision = min(self.client_revision, server_revision)
+
             server_timezone = None
-            if server_revision >= \
+            if used_revision >= \
                     defines.DBMS_MIN_REVISION_WITH_SERVER_TIMEZONE:
                 server_timezone = read_binary_str(self.fin)
 
             server_display_name = ''
-            if server_revision >= \
+            if used_revision >= \
                     defines.DBMS_MIN_REVISION_WITH_SERVER_DISPLAY_NAME:
                 server_display_name = read_binary_str(self.fin)
 
             server_version_patch = server_revision
-            if server_revision >= \
+            if used_revision >= \
                     defines.DBMS_MIN_REVISION_WITH_VERSION_PATCH:
                 server_version_patch = read_varint(self.fin)
 
+            if used_revision >= defines. \
+                    DBMS_MIN_PROTOCOL_VERSION_WITH_PASSWORD_COMPLEXITY_RULES:
+                rules_size = read_varint(self.fin)
+                for _i in range(rules_size):
+                    read_binary_str(self.fin)  # original_pattern
+                    read_binary_str(self.fin)  # exception_message
+
+            if used_revision >= defines. \
+                    DBMS_MIN_REVISION_WITH_INTERSERVER_SECRET_V2:
+                read_binary_uint64(self.fin)  # read_nonce
+
             self.server_info = ServerInfo(
                 server_name, server_version_major, server_version_minor,
                 server_version_patch, server_revision,
-                server_timezone, server_display_name
+                server_timezone, server_display_name, used_revision
             )
             self.context.server_info = self.server_info
 
@@ -463,6 +533,14 @@ class Connection(object):
             self.disconnect()
             raise errors.UnexpectedPacketFromServerError(message)
 
+    def send_addendum(self):
+        revision = self.server_info.used_revision
+
+        if revision >= defines.DBMS_MIN_PROTOCOL_VERSION_WITH_QUOTA_KEY:
+            write_binary_str(
+                self.context.client_settings['quota_key'], self.fout
+            )
+
     def ping(self):
         timeout = self.sync_request_timeout
 
@@ -538,6 +616,12 @@ class Connection(object):
         elif packet_type == ServerPacketTypes.PROFILE_EVENTS:
             packet.block = self.receive_data(may_be_compressed=False)
 
+        elif packet_type == ServerPacketTypes.TIMEZONE_UPDATE:
+            timezone = read_binary_str(self.fin)
+            if timezone:
+                logger.info('Server timezone changed to %s', timezone)
+                self.server_info.session_timezone = timezone
+
         else:
             message = 'Unknown packet {} from server {}'.format(
                 packet_type, self.get_description()
@@ -567,7 +651,7 @@ class Connection(object):
             return BlockOutputStream(self.fout, self.context)
 
     def receive_data(self, may_be_compressed=True, may_be_use_numpy=False):
-        revision = self.server_info.revision
+        revision = self.server_info.used_revision
 
         if revision >= defines.DBMS_MIN_REVISION_WITH_TEMPORARY_TABLES:
             read_binary_str(self.fin)
@@ -581,7 +665,7 @@ class Connection(object):
 
     def receive_progress(self):
         progress = Progress()
-        progress.read(self.server_info.revision, self.fin)
+        progress.read(self.server_info, self.fin)
         return progress
 
     def receive_profile_info(self):
@@ -597,14 +681,14 @@ class Connection(object):
         start = time()
         write_varint(ClientPacketTypes.DATA, self.fout)
 
-        revision = self.server_info.revision
+        revision = self.server_info.used_revision
         if revision >= defines.DBMS_MIN_REVISION_WITH_TEMPORARY_TABLES:
             write_binary_str(table_name, self.fout)
 
         self.block_out.write(block)
         logger.debug('Block "%s" send time: %f', table_name, time() - start)
 
-    def send_query(self, query, query_id=None):
+    def send_query(self, query, query_id=None, params=None):
         if not self.connected:
             self.connect()
 
@@ -612,9 +696,10 @@ class Connection(object):
 
         write_binary_str(query_id or '', self.fout)
 
-        revision = self.server_info.revision
+        revision = self.server_info.used_revision
         if revision >= defines.DBMS_MIN_REVISION_WITH_CLIENT_INFO:
-            client_info = ClientInfo(self.client_name, self.context)
+            client_info = ClientInfo(self.client_name, self.context,
+                                     client_revision=self.client_revision)
             client_info.query_kind = ClientInfo.QueryKind.INITIAL_QUERY
 
             client_info.write(revision, self.fout)
@@ -623,8 +708,11 @@ class Connection(object):
             revision >= defines
             .DBMS_MIN_REVISION_WITH_SETTINGS_SERIALIZED_AS_STRINGS
         )
+        settings_flags = 0
+        if self.settings_is_important:
+            settings_flags |= SettingsFlags.IMPORTANT
         write_settings(self.context.settings, self.fout, settings_as_strings,
-                       self.settings_is_important)
+                       settings_flags)
 
         if revision >= defines.DBMS_MIN_REVISION_WITH_INTERSERVER_SECRET:
             write_binary_str('', self.fout)
@@ -634,6 +722,16 @@ class Connection(object):
 
         write_binary_str(query, self.fout)
 
+        if revision >= defines.DBMS_MIN_PROTOCOL_VERSION_WITH_PARAMETERS:
+            if self.context.client_settings['server_side_params']:
+                # Always settings_as_strings = True
+                escaped = escape_params(
+                    params or {}, self.context, for_server=True
+                )
+            else:
+                escaped = {}
+            write_settings(escaped, self.fout, True, SettingsFlags.CUSTOM)
+
         logger.debug('Query: %s', query)
 
         self.fout.flush()

clickhouse_driver/defines.py

@@ -25,6 +25,17 @@ DBMS_MIN_PROTOCOL_VERSION_WITH_DISTRIBUTED_DEPTH = 54448
 DBMS_MIN_PROTOCOL_VERSION_WITH_INITIAL_QUERY_START_TIME = 54449
 DBMS_MIN_PROTOCOL_VERSION_WITH_INCREMENTAL_PROFILE_EVENTS = 54451
 DBMS_MIN_REVISION_WITH_PARALLEL_REPLICAS = 54453
+DBMS_MIN_REVISION_WITH_CUSTOM_SERIALIZATION = 54454
+DBMS_MIN_PROTOCOL_VERSION_WITH_PROFILE_EVENTS_IN_INSERT = 54456
+DBMS_MIN_PROTOCOL_VERSION_WITH_ADDENDUM = 54458
+DBMS_MIN_PROTOCOL_VERSION_WITH_QUOTA_KEY = 54458
+DBMS_MIN_PROTOCOL_VERSION_WITH_PARAMETERS = 54459
+DBMS_MIN_PROTOCOL_VERSION_WITH_SERVER_QUERY_TIME_IN_PROGRESS = 54460
+DBMS_MIN_PROTOCOL_VERSION_WITH_PASSWORD_COMPLEXITY_RULES = 54461
+DBMS_MIN_REVISION_WITH_INTERSERVER_SECRET_V2 = 54462
+DBMS_MIN_PROTOCOL_VERSION_WITH_TOTAL_BYTES_IN_PROGRESS = 54463
+DBMS_MIN_PROTOCOL_VERSION_WITH_TIMEZONE_UPDATES = 54464
+DBMS_MIN_REVISION_WITH_SYSTEM_KEYWORDS_TABLE = 54468
 
 # Timeouts
 DBMS_DEFAULT_CONNECT_TIMEOUT_SEC = 10
@@ -40,7 +51,7 @@ CLIENT_NAME = 'python-driver'
 CLIENT_VERSION_MAJOR = 20
 CLIENT_VERSION_MINOR = 10
 CLIENT_VERSION_PATCH = 2
-CLIENT_REVISION = 54453
+CLIENT_REVISION = DBMS_MIN_REVISION_WITH_SYSTEM_KEYWORDS_TABLE
 
 BUFFER_SIZE = 1048576
 

clickhouse_driver/log.py

@@ -2,7 +2,8 @@ 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',
@@ -12,9 +13,12 @@ log_priorities = (
     'Notice',
     'Information',
     'Debug',
-    'Trace'
+    'Trace',
+    'Test',
 )
 
+num_priorities = len(log_priorities)
+
 
 def log_block(block):
     if block is None:
@@ -25,7 +29,7 @@ def log_block(block):
     for row in block.get_rows():
         row = dict(zip(column_names, row))
 
-        if 1 <= row['priority'] <= 8:
+        if 1 <= row['priority'] <= num_priorities:
             priority = log_priorities[row['priority']]
         else:
             priority = row[0]

clickhouse_driver/numpy/helpers.py

@@ -1,13 +1,16 @@
 import numpy as np
 import pandas as pd
+from pandas.core.arrays import ExtensionArray
 
 
 def column_chunks(columns, n):
     for column in columns:
-        if not isinstance(column, (np.ndarray, pd.DatetimeIndex)):
+        if not isinstance(
+            column, (np.ndarray, pd.DatetimeIndex, ExtensionArray)
+        ):
             raise TypeError(
                 'Unsupported column type: {}. '
-                'ndarray/DatetimeIndex is expected.'
+                'ndarray/DatetimeIndex/ExtensionArray is expected.'
                 .format(type(column))
             )
 

clickhouse_driver/progress.py

@@ -6,27 +6,39 @@ class Progress(object):
     def __init__(self):
         self.rows = 0
         self.bytes = 0
-        self.total_rows = 0
+        self.total_rows = 0  # total_rows_to_read
+        self.total_bytes = 0  # total_bytes_to_read
         self.written_rows = 0
         self.written_bytes = 0
+        self.elapsed_ns = 0
 
         super(Progress, self).__init__()
 
-    def read(self, server_revision, fin):
+    def read(self, server_info, fin):
         self.rows = read_varint(fin)
         self.bytes = read_varint(fin)
 
-        revision = server_revision
+        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_PROTOCOL_VERSION_WITH_TOTAL_BYTES_IN_PROGRESS:
+            self.total_bytes = 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.total_bytes += another_progress.total_bytes
         self.written_rows += another_progress.written_rows
         self.written_bytes += another_progress.written_bytes
+        self.elapsed_ns += another_progress.elapsed_ns

clickhouse_driver/protocol.py

@@ -29,7 +29,10 @@ class ClientPacketTypes(object):
 
     @classmethod
     def to_str(cls, packet):
-        return 'Unknown packet' if packet > 5 else cls._types_str[packet]
+        try:
+            return cls._types_str[packet]
+        except IndexError:
+            return 'Unknown packet'
 
 
 class ServerPacketTypes(object):
@@ -81,15 +84,28 @@ class ServerPacketTypes(object):
     # Packet with profile events from server.
     PROFILE_EVENTS = 14
 
+    MERGE_TREE_ALL_RANGES_ANNOUNCEMENT = 15
+
+    # Request from a MergeTree replica to a coordinator
+    MERGE_TREE_READ_TASK_REQUEST = 16
+
+    # Receive server's (session-wide) default timezone
+    TIMEZONE_UPDATE = 17
+
     _types_str = [
         'Hello', 'Data', 'Exception', 'Progress', 'Pong', 'EndOfStream',
         'ProfileInfo', 'Totals', 'Extremes', 'TablesStatusResponse', 'Log',
-        'TableColumns', 'PartUUIDs', 'ReadTaskRequest', 'ProfileEvents'
+        'TableColumns', 'PartUUIDs', 'ReadTaskRequest', 'ProfileEvents',
+        'MergeTreeAllRangesAnnouncement', 'MergeTreeReadTaskRequest',
+        'TimezoneUpdate'
     ]
 
     @classmethod
     def to_str(cls, packet):
-        return 'Unknown packet' if packet > 14 else cls._types_str[packet]
+        try:
+            return cls._types_str[packet]
+        except IndexError:
+            return 'Unknown packet'
 
     @classmethod
     def strings_in_message(cls, packet):

clickhouse_driver/settings/writer.py

@@ -7,13 +7,18 @@ from .available import settings as available_settings
 logger = logging.getLogger(__name__)
 
 
-def write_settings(settings, buf, settings_as_strings, is_important=False):
+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(int(is_important), buf)
+            write_binary_uint8(flags, buf)
             write_binary_str(str(value), buf)
 
         else:

clickhouse_driver/streams/native.py

@@ -1,10 +1,14 @@
+import logging
+
 from ..block import ColumnOrientedBlock, BlockInfo
 from ..columns.service import read_column, write_column
-from ..reader import read_binary_str
+from ..reader import read_binary_str, read_binary_uint8
 from ..varint import write_varint, read_varint
-from ..writer import write_binary_str
+from ..writer import write_binary_str, write_binary_uint8
 from .. import defines
 
+logger = logging.getLogger(__name__)
+
 
 class BlockOutputStream(object):
     def __init__(self, fout, context):
@@ -14,7 +18,7 @@ class BlockOutputStream(object):
         super(BlockOutputStream, self).__init__()
 
     def write(self, block):
-        revision = self.context.server_info.revision
+        revision = self.context.server_info.used_revision
         if revision >= defines.DBMS_MIN_REVISION_WITH_BLOCK_INFO:
             block.info.write(self.fout)
 
@@ -35,6 +39,12 @@ class BlockOutputStream(object):
                 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)
 
@@ -54,7 +64,7 @@ class BlockInputStream(object):
     def read(self, use_numpy=None):
         info = BlockInfo()
 
-        revision = self.context.server_info.revision
+        revision = self.context.server_info.used_revision
         if revision >= defines.DBMS_MIN_REVISION_WITH_BLOCK_INFO:
             info.read(self.fin)
 
@@ -70,9 +80,17 @@ class BlockInputStream(object):
             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:
-                column = read_column(self.context, column_type, n_rows,
-                                     self.fin, use_numpy=use_numpy)
+                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']:

clickhouse_driver/util/compat.py

@@ -5,6 +5,18 @@ try:
 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

clickhouse_driver/util/escape.py

@@ -1,5 +1,6 @@
-from datetime import date, datetime
+from datetime import date, datetime, time
 from enum import Enum
+from functools import wraps
 from uuid import UUID
 
 from pytz import timezone
@@ -20,7 +21,7 @@ escape_chars_map = {
 
 
 def escape_datetime(item, context):
-    server_tz = timezone(context.server_info.timezone)
+    server_tz = timezone(context.server_info.get_timezone())
 
     if item.tzinfo is not None:
         item = item.astimezone(server_tz)
@@ -28,7 +29,24 @@ def escape_datetime(item, context):
     return "'%s'" % item.strftime('%Y-%m-%d %H:%M:%S')
 
 
-def escape_param(item, context):
+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'
 
@@ -38,17 +56,27 @@ def escape_param(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 x in item)
+        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 x in item)
+        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)
+        return escape_param(item.value, context, for_server=for_server)
 
     elif isinstance(item, UUID):
         return "'%s'" % str(item)
@@ -57,10 +85,10 @@ def escape_param(item, context):
         return item
 
 
-def escape_params(params, context):
+def escape_params(params, context, for_server=False):
     escaped = {}
 
     for key, value in params.items():
-        escaped[key] = escape_param(value, context)
+        escaped[key] = escape_param(value, context, for_server=for_server)
 
     return escaped