singlestoredb 0.4.0__py3-none-any.whl → 1.0.4__py3-none-any.whl

singlestoredb/{clients/pymysqlsv/connections.py → mysql/connection.py}

@@ -13,11 +13,9 @@ import traceback
 import warnings
 
 try:
-    import _pymysqlsv
+    import _singlestoredb_accel
 except (ImportError, ModuleNotFoundError):
-    _pymysqlsv = None
-#   warnings.warn('Accelerator extension could not be loaded; '
-#                 'running in pure Python mode.', RuntimeWarning)
+    _singlestoredb_accel = None
 
 from . import _auth
 
@@ -26,11 +24,17 @@ from .constants import CLIENT, COMMAND, CR, ER, FIELD_TYPE, SERVER_STATUS
 from . import converters
 from .cursors import (
     Cursor,
-    SSCursor,
+    CursorSV,
     DictCursor,
+    DictCursorSV,
+    NamedtupleCursor,
+    NamedtupleCursorSV,
+    SSCursor,
+    SSCursorSV,
     SSDictCursor,
-    #   SSCursorSV,
-    #   SSDictCursorSV,
+    SSDictCursorSV,
+    SSNamedtupleCursor,
+    SSNamedtupleCursorSV,
 )
 from .optionfile import Parser
 from .protocol import (
@@ -41,7 +45,12 @@ from .protocol import (
     EOFPacketWrapper,
     LoadLocalPacketWrapper,
 )
-from . import err, VERSION_STRING
+from . import err
+from ..config import get_option
+from .. import fusion
+from .. import connection
+from ..connection import Connection as BaseConnection
+from ..utils.debug import log_query
 
 try:
     import ssl
@@ -60,7 +69,7 @@ except (ImportError, KeyError):
     # KeyError occurs when there's no entry in OS database for a current user.
     DEFAULT_USER = None
 
-DEBUG = False
+DEBUG = get_option('debug.connection')
 
 TEXT_TYPES = {
     FIELD_TYPE.BIT,
@@ -106,87 +115,149 @@ def _lenenc_int(i):
         )
 
 
-class Connection:
+class Connection(BaseConnection):
     """
     Representation of a socket with a mysql server.
 
     The proper way to get an instance of this class is to call
-    connect().
-
-    Establish a connection to the MySQL database. Accepts several
-    arguments:
-
-    :param host: Host where the database server is located.
-    :param user: Username to log in as.
-    :param password: Password to use.
-    :param database: Database to use, None to not use a particular one.
-    :param port: MySQL port to use, default is usually OK. (default: 3306)
-    :param bind_address: When the client has multiple network interfaces, specify
+    ``connect()``.
+
+    Establish a connection to the SingleStoreDB database.
+
+    Parameters
+    ----------
+    host : str, optional
+        Host where the database server is located.
+    user : str, optional
+        Username to log in as.
+    password : str, optional
+        Password to use.
+    database : str, optional
+        Database to use, None to not use a particular one.
+    port : int, optional
+        Server port to use, default is usually OK. (default: 3306)
+    bind_address : str, optional
+        When the client has multiple network interfaces, specify
         the interface from which to connect to the host. Argument can be
         a hostname or an IP address.
-    :param unix_socket: Use a unix socket rather than TCP/IP.
-    :param read_timeout: The timeout for reading from the connection in seconds (default: None - no timeout)
-    :param write_timeout: The timeout for writing to the connection in seconds (default: None - no timeout)
-    :param charset: Charset to use.
-    :param sql_mode: Default SQL_MODE to use.
-    :param read_default_file:
-        Specifies  my.cnf file to read these parameters from under the [client] section.
-    :param conv:
+    unix_socket : str, optional
+        Use a unix socket rather than TCP/IP.
+    read_timeout : int, optional
+        The timeout for reading from the connection in seconds
+        (default: None - no timeout)
+    write_timeout : int, optional
+        The timeout for writing to the connection in seconds
+        (default: None - no timeout)
+    charset : str, optional
+        Charset to use.
+    collation : str, optional
+        The charset collation
+    sql_mode : str, optional
+        Default SQL_MODE to use.
+    read_default_file : str, optional
+        Specifies  my.cnf file to read these parameters from under the
+        [client] section.
+    conv : Dict[str, Callable[Any]], optional
         Conversion dictionary to use instead of the default one.
         This is used to provide custom marshalling and unmarshalling of types.
         See converters.
-    :param use_unicode:
+    use_unicode : bool, optional
         Whether or not to default to unicode strings.
         This option defaults to true.
-    :param client_flag: Custom flags to send to MySQL. Find potential values in constants.CLIENT.
-    :param cursorclass: Custom cursor class to use.
-    :param init_command: Initial SQL statement to run when connection is established.
-    :param connect_timeout: The timeout for connecting to the database in seconds.
+    client_flag : int, optional
+        Custom flags to send to MySQL. Find potential values in constants.CLIENT.
+    cursorclass : type, optional
+        Custom cursor class to use.
+    init_command : str, optional
+        Initial SQL statement to run when connection is established.
+    connect_timeout : int, optional
+        The timeout for connecting to the database in seconds.
         (default: 10, min: 1, max: 31536000)
-    :param ssl: A dict of arguments similar to mysql_ssl_set()'s parameters or an ssl.SSLContext.
-    :param ssl_ca: Path to the file that contains a PEM-formatted CA certificate.
-    :param ssl_cert: Path to the file that contains a PEM-formatted client certificate.
-    :param ssl_disabled: A boolean value that disables usage of TLS.
-    :param ssl_key: Path to the file that contains a PEM-formatted private key for the client certificate.
-    :param ssl_verify_cert: Set to true to check the server certificate's validity.
-    :param ssl_verify_identity: Set to true to check the server's identity.
-    :param read_default_group: Group to read from in the configuration file.
-    :param autocommit: Autocommit mode. None means use server default. (default: False)
-    :param local_infile: Boolean to enable the use of LOAD DATA LOCAL command. (default: False)
-    :param max_allowed_packet: Max size of packet sent to server in bytes. (default: 16MB)
-        Only used to limit size of "LOAD LOCAL INFILE" data packet smaller than default (16KB).
-    :param defer_connect: Don't explicitly connect on construction - wait for connect call.
+    ssl : Dict[str, str], optional
+        A dict of arguments similar to mysql_ssl_set()'s parameters or
+        an ssl.SSLContext.
+    ssl_ca : str, optional
+        Path to the file that contains a PEM-formatted CA certificate.
+    ssl_cert : str, optional
+        Path to the file that contains a PEM-formatted client certificate.
+    ssl_cipher : str, optional
+        SSL ciphers to allow.
+    ssl_disabled : bool, optional
+        A boolean value that disables usage of TLS.
+    ssl_key : str, optional
+        Path to the file that contains a PEM-formatted private key for the
+        client certificate.
+    ssl_verify_cert : str, optional
+        Set to true to check the server certificate's validity.
+    ssl_verify_identity : bool, optional
+        Set to true to check the server's identity.
+    read_default_group : str, optional
+        Group to read from in the configuration file.
+    autocommit : bool, optional
+        Autocommit mode. None means use server default. (default: False)
+    local_infile : bool, optional
+        Boolean to enable the use of LOAD DATA LOCAL command. (default: False)
+    max_allowed_packet : int, optional
+        Max size of packet sent to server in bytes. (default: 16MB)
+        Only used to limit size of "LOAD LOCAL INFILE" data packet smaller
+        than default (16KB).
+    defer_connect : bool, optional
+        Don't explicitly connect on construction - wait for connect call.
         (default: False)
-    :param auth_plugin_map: A dict of plugin names to a class that processes that plugin.
-        The class will take the Connection object as the argument to the constructor.
-        The class needs an authenticate method taking an authentication packet as
-        an argument.  For the dialog plugin, a prompt(echo, prompt) method can be used
-        (if no authenticate method) for returning a string from the user. (experimental)
-    :param server_public_key: SHA256 authentication plugin public key value. (default: None)
-    :param binary_prefix: Add _binary prefix on bytes and bytearray. (default: False)
-    :param compress: Not supported.
-    :param named_pipe: Not supported.
-    :param db: **DEPRECATED** Alias for database.
-    :param passwd: **DEPRECATED** Alias for password.
-    :param parse_json: Parse JSON values into Python objects?
-    :param invalid_values: Dictionary of values to use in place of invalid values
+    auth_plugin_map : Dict[str, type], optional
+        A dict of plugin names to a class that processes that plugin.
+        The class will take the Connection object as the argument to the
+        constructor.  The class needs an authenticate method taking an
+        authentication packet as an argument.  For the dialog plugin, a
+        prompt(echo, prompt) method can be used (if no authenticate method)
+        for returning a string from the user. (experimental)
+    server_public_key : str, optional
+        SHA256 authentication plugin public key value. (default: None)
+    binary_prefix : bool, optional
+        Add _binary prefix on bytes and bytearray. (default: False)
+    compress :
+        Not supported.
+    named_pipe :
+        Not supported.
+    db : str, optional
+        **DEPRECATED** Alias for database.
+    passwd : str, optional
+        **DEPRECATED** Alias for password.
+    parse_json : bool, optional
+        Parse JSON values into Python objects?
+    invalid_values : Dict[int, Any], optional
+        Dictionary of values to use in place of invalid values
         found during conversion of data. The default is to return the byte content
         containing the invalid value. The keys are the integers associtated with
         the column type.
-    :param pure_python: Should we ignore the C extension even if it's available?
+    pure_python : bool, optional
+        Should we ignore the C extension even if it's available?
         This can be given explicitly using True or False, or if the value is None,
-        the C extension will be loaded if it is available.
+        the C extension will be loaded if it is available. If set to False and
+        the C extension can't be loaded, a NotSupportedError is raised.
+    nan_as_null : bool, optional
+        Should NaN values be treated as NULLs in parameter substitution including
+        uploading data?
+    inf_as_null : bool, optional
+        Should Inf values be treated as NULLs in parameter substitution including
+        uploading data?
+    track_env : bool, optional
+        Should the connection track the SINGLESTOREDB_URL environment variable?
+
+    See `Connection <https://www.python.org/dev/peps/pep-0249/#connection-objects>`_
+    in the specification.
 
-    See `Connection <https://www.python.org/dev/peps/pep-0249/#connection-objects>`_ in the
-    specification.
     """
 
+    driver = 'mysql'
+    paramstyle = 'pyformat'
+
     _sock = None
     _auth_plugin_name = ''
     _closed = False
     _secure = False
 
-    def __init__(
+    def __init__(  # noqa: C901
         self,
         *,
         user=None,  # The first four arguments is based on DB-API 2.0 recommendation.
@@ -196,12 +267,13 @@ class Connection:
         unix_socket=None,
         port=0,
         charset='',
+        collation=None,
         sql_mode=None,
         read_default_file=None,
         conv=None,
         use_unicode=True,
         client_flag=0,
-        cursorclass=Cursor,
+        cursorclass=None,
         init_command=None,
         connect_timeout=10,
         read_default_group=None,
@@ -219,18 +291,30 @@ class Connection:
         ssl=None,
         ssl_ca=None,
         ssl_cert=None,
+        ssl_cipher=None,
         ssl_disabled=None,
         ssl_key=None,
         ssl_verify_cert=None,
         ssl_verify_identity=None,
-        parse_json=False,
+        parse_json=True,
         invalid_values=None,
         pure_python=None,
+        buffered=True,
+        results_type='tuples',
         compress=None,  # not supported
         named_pipe=None,  # not supported
         passwd=None,  # deprecated
         db=None,  # deprecated
+        driver=None,  # internal use
+        conn_attrs=None,
+        multi_statements=None,
+        nan_as_null=None,
+        inf_as_null=None,
+        encoding_errors='strict',
+        track_env=False,
     ):
+        BaseConnection.__init__(**dict(locals()))
+
         if db is not None and database is None:
             # We will raise warning in 2022 or later.
             # See https://github.com/PyMySQL/PyMySQL/issues/939
@@ -252,6 +336,8 @@ class Connection:
         self._local_infile = bool(local_infile)
         if self._local_infile:
             client_flag |= CLIENT.LOCAL_FILES
+        if multi_statements:
+            client_flag |= CLIENT.MULTI_STATEMENTS
 
         if read_default_group and not read_default_file:
             if sys.platform.startswith('win'):
@@ -292,7 +378,8 @@ class Connection:
 
         self.ssl = False
         if not ssl_disabled:
-            if ssl_ca or ssl_cert or ssl_key or ssl_verify_cert or ssl_verify_identity:
+            if ssl_ca or ssl_cert or ssl_key or ssl_cipher or \
+                    ssl_verify_cert or ssl_verify_identity:
                 ssl = {
                     'ca': ssl_ca,
                     'check_hostname': bool(ssl_verify_identity),
@@ -304,6 +391,8 @@ class Connection:
                     ssl['cert'] = ssl_cert
                 if ssl_key is not None:
                     ssl['key'] = ssl_key
+                if ssl_cipher is not None:
+                    ssl['cipher'] = ssl_cipher
             if ssl:
                 if not SSL_ENABLED:
                     raise NotImplementedError('ssl module not found')
@@ -333,31 +422,71 @@ class Connection:
         self._write_timeout = write_timeout
 
         self.charset = charset or DEFAULT_CHARSET
+        self.collation = collation
         self.use_unicode = use_unicode
+        self.encoding_errors = encoding_errors
 
         self.encoding = charset_by_name(self.charset).encoding
 
         client_flag |= CLIENT.CAPABILITIES
-        if self.db:
-            client_flag |= CLIENT.CONNECT_WITH_DB
+        client_flag |= CLIENT.CONNECT_WITH_DB
 
         self.client_flag = client_flag
 
         self.pure_python = pure_python
-        self.output_type = 'tuples'
-        self.cursorclass = cursorclass
+        self.results_type = results_type
         self.resultclass = MySQLResult
+        if cursorclass is not None:
+            self.cursorclass = cursorclass
+        elif buffered:
+            if 'dict' in self.results_type:
+                self.cursorclass = DictCursor
+            elif 'namedtuple' in self.results_type:
+                self.cursorclass = NamedtupleCursor
+            else:
+                self.cursorclass = Cursor
+        else:
+            if 'dict' in self.results_type:
+                self.cursorclass = SSDictCursor
+            elif 'namedtuple' in self.results_type:
+                self.cursorclass = SSNamedtupleCursor
+            else:
+                self.cursorclass = SSCursor
+
+        if self.pure_python is False and _singlestoredb_accel is None:
+            try:
+                import _singlestortedb_accel  # noqa: F401
+            except Exception:
+                import traceback
+                traceback.print_exc(file=sys.stderr)
+            finally:
+                raise err.NotSupportedError(
+                    'pure_python=False, but the '
+                    'C extension can not be loaded',
+                )
+
+        if self.pure_python is True:
+            pass
 
         # The C extension handles these types internally.
-#       if _pymysqlsv is not None and not self.pure_python:
-#           self.resultclass = MySQLResultSV
-#           if self.cursorclass is SSCursor:
-#               self.cursorclass = SSCursorSV
-#           elif self.cursorclass is DictCursor:
-#               self.output_type = 'dicts'
-#           elif self.cursorclass is SSDictCursor:
-#               self.cursorclass = SSDictCursorSV
-#               self.output_type = 'dicts'
+        elif _singlestoredb_accel is not None:
+            self.resultclass = MySQLResultSV
+            if self.cursorclass is Cursor:
+                self.cursorclass = CursorSV
+            elif self.cursorclass is SSCursor:
+                self.cursorclass = SSCursorSV
+            elif self.cursorclass is DictCursor:
+                self.cursorclass = DictCursorSV
+                self.results_type = 'dicts'
+            elif self.cursorclass is SSDictCursor:
+                self.cursorclass = SSDictCursorSV
+                self.results_type = 'dicts'
+            elif self.cursorclass is NamedtupleCursor:
+                self.cursorclass = NamedtupleCursorSV
+                self.results_type = 'namedtuples'
+            elif self.cursorclass is SSNamedtupleCursor:
+                self.cursorclass = SSNamedtupleCursorSV
+                self.results_type = 'namedtuples'
 
         self._result = None
         self._affected_rows = 0
@@ -382,20 +511,46 @@ class Connection:
         self._binary_prefix = binary_prefix
         self.server_public_key = server_public_key
 
+        if self.connection_params['nan_as_null'] or \
+                self.connection_params['inf_as_null']:
+            float_encoder = self.encoders.get(float)
+            if float_encoder is not None:
+                self.encoders[float] = functools.partial(
+                    float_encoder,
+                    nan_as_null=self.connection_params['nan_as_null'],
+                    inf_as_null=self.connection_params['inf_as_null'],
+                )
+
+        from .. import __version__ as VERSION_STRING
+
         self._connect_attrs = {
-            '_client_name': 'pymysqlsv',
+            '_os': str(sys.platform),
             '_pid': str(os.getpid()),
+            '_client_name': 'SingleStoreDB Python Client',
             '_client_version': VERSION_STRING,
         }
 
         if program_name:
             self._connect_attrs['program_name'] = program_name
+        if conn_attrs is not None:
+            # do not overwrite the attributes that we set ourselves
+            for k, v in conn_attrs.items():
+                if k not in self._connect_attrs:
+                    self._connect_attrs[k] = v
+
+        self._in_sync = False
+        self._track_env = bool(track_env) or self.host == 'singlestore.com'
 
-        if defer_connect:
+        if defer_connect or self._track_env:
             self._sock = None
         else:
             self.connect()
 
+    @property
+    def messages(self):
+        # TODO
+        []
+
     def __enter__(self):
         return self
 
@@ -442,11 +597,17 @@ class Connection:
         """
         Send the quit message and close the socket.
 
-        See `Connection.close() <https://www.python.org/dev/peps/pep-0249/#Connection.close>`_
+        See `Connection.close()
+        <https://www.python.org/dev/peps/pep-0249/#Connection.close>`_
         in the specification.
 
-        :raise Error: If the connection is already closed.
+        Raises
+        ------
+        Error : If the connection is already closed.
+
         """
+        if self.host == 'singlestore.com':
+            return
         if self._closed:
             raise err.Error('Already closed')
         self._closed = True
@@ -465,6 +626,10 @@ class Connection:
         """Return True if the connection is open."""
         return self._sock is not None
 
+    def is_connected(self):
+        """Return True if the connection is open."""
+        return self.open
+
     def _force_close(self):
         """Close connection without QUIT message."""
         if self._sock:
@@ -478,12 +643,14 @@ class Connection:
     __del__ = _force_close
 
     def autocommit(self, value):
+        """Enable autocommit in the server."""
         self.autocommit_mode = bool(value)
         current = self.get_autocommit()
         if value != current:
             self._send_autocommit_mode()
 
     def get_autocommit(self):
+        """Retrieve autocommit status."""
         return bool(self.server_status & SERVER_STATUS.SERVER_STATUS_AUTOCOMMIT)
 
     def _read_ok_packet(self):
@@ -499,6 +666,7 @@ class Connection:
 
     def _send_autocommit_mode(self):
         """Set whether or not to commit after every execute()."""
+        log_query('SET AUTOCOMMIT = %s' % self.escape(self.autocommit_mode))
         self._execute_command(
             COMMAND.COM_QUERY, 'SET AUTOCOMMIT = %s' % self.escape(self.autocommit_mode),
         )
@@ -506,6 +674,9 @@ class Connection:
 
     def begin(self):
         """Begin transaction."""
+        log_query('BEGIN')
+        if self.host == 'singlestore.com':
+            return
         self._execute_command(COMMAND.COM_QUERY, 'BEGIN')
         self._read_ok_packet()
 
@@ -515,7 +686,11 @@ class Connection:
 
         See `Connection.commit() <https://www.python.org/dev/peps/pep-0249/#commit>`_
         in the specification.
+
         """
+        log_query('COMMIT')
+        if self.host == 'singlestore.com':
+            return
         self._execute_command(COMMAND.COM_QUERY, 'COMMIT')
         self._read_ok_packet()
 
@@ -525,12 +700,17 @@ class Connection:
 
         See `Connection.rollback() <https://www.python.org/dev/peps/pep-0249/#rollback>`_
         in the specification.
+
         """
+        log_query('ROLLBACK')
+        if self.host == 'singlestore.com':
+            return
         self._execute_command(COMMAND.COM_QUERY, 'ROLLBACK')
         self._read_ok_packet()
 
     def show_warnings(self):
         """Send the "SHOW WARNINGS" SQL command."""
+        log_query('SHOW WARNINGS')
         self._execute_command(COMMAND.COM_QUERY, 'SHOW WARNINGS')
         result = self.resultclass(self)
         result.read()
@@ -540,80 +720,102 @@ class Connection:
         """
         Set current db.
 
-        :param db: The name of the db.
+        db : str
+            The name of the db.
+
         """
         self._execute_command(COMMAND.COM_INIT_DB, db)
         self._read_ok_packet()
 
     def escape(self, obj, mapping=None):
-        """Escape whatever value is passed.
+        """
+        Escape whatever value is passed.
 
         Non-standard, for internal use; do not use this in your applications.
+
         """
-        if isinstance(obj, str):
-            return "'" + self.escape_string(obj) + "'"
-        if isinstance(obj, (bytes, bytearray)):
-            ret = self._quote_bytes(obj)
-            if self._binary_prefix:
-                ret = '_binary' + ret
-            return ret
+        dtype = type(obj)
+        if dtype is str or isinstance(obj, str):
+            return "'{}'".format(self.escape_string(obj))
+        if dtype is bytes or dtype is bytearray or isinstance(obj, (bytes, bytearray)):
+            return self._quote_bytes(obj)
+        if mapping is None:
+            mapping = self.encoders
         return converters.escape_item(obj, self.charset, mapping=mapping)
 
     def literal(self, obj):
-        """Alias for escape().
+        """
+        Alias for escape().
 
         Non-standard, for internal use; do not use this in your applications.
+
         """
         return self.escape(obj, self.encoders)
 
     def escape_string(self, s):
+        """Escape a string value."""
         if self.server_status & SERVER_STATUS.SERVER_STATUS_NO_BACKSLASH_ESCAPES:
             return s.replace("'", "''")
         return converters.escape_string(s)
 
     def _quote_bytes(self, s):
         if self.server_status & SERVER_STATUS.SERVER_STATUS_NO_BACKSLASH_ESCAPES:
-            return "'%s'" % (s.replace(b"'", b"''").decode('ascii', 'surrogateescape'),)
+            if self._binary_prefix:
+                return "_binary X'{}'".format(s.hex())
+            return "X'{}'".format(s.hex())
         return converters.escape_bytes(s)
 
-    def cursor(self, cursor=None):
-        """
-        Create a new cursor to execute queries with.
-
-        :param cursor: The type of cursor to create. None means use Cursor.
-        :type cursor: :py:class:`Cursor`, :py:class:`SSCursor`, :py:class:`DictCursor`, or :py:class:`SSDictCursor`.
-        """
-        if cursor:
-            #           if cursor is SSCursor:
-            #               cursor = SSCursorSV
-            #           elif cursor is DictCursor:
-            #               # TODO: Passing in a cursor shouldn't affect connection output type
-            #               self.output_type = 'dicts'
-            #           elif cursor is SSDictCursor:
-            #               cursor = SSDictCursorSV
-            #               # TODO: Passing in a cursor shouldn't affect connection output type
-            #               self.output_type = 'dicts'
-            return cursor(self)
+    def cursor(self):
+        """Create a new cursor to execute queries with."""
         return self.cursorclass(self)
 
     # The following methods are INTERNAL USE ONLY (called from Cursor)
     def query(self, sql, unbuffered=False):
+        """
+        Run a query on the server.
+
+        Internal use only.
+
+        """
         # if DEBUG:
         #     print("DEBUG: sending query:", sql)
-        if isinstance(sql, str):
-            sql = sql.encode(self.encoding, 'surrogateescape')
-        self._execute_command(COMMAND.COM_QUERY, sql)
-        self._affected_rows = self._read_query_result(unbuffered=unbuffered)
+        handler = fusion.get_handler(sql)
+        if handler is not None:
+            self._result = fusion.execute(self, sql, handler=handler)
+            self._affected_rows = self._result.affected_rows
+        else:
+            if isinstance(sql, str):
+                sql = sql.encode(self.encoding, 'surrogateescape')
+            self._execute_command(COMMAND.COM_QUERY, sql)
+            self._affected_rows = self._read_query_result(unbuffered=unbuffered)
         return self._affected_rows
 
     def next_result(self, unbuffered=False):
+        """
+        Retrieve the next result set.
+
+        Internal use only.
+
+        """
         self._affected_rows = self._read_query_result(unbuffered=unbuffered)
         return self._affected_rows
 
     def affected_rows(self):
+        """
+        Return number of affected rows.
+
+        Internal use only.
+
+        """
         return self._affected_rows
 
     def kill(self, thread_id):
+        """
+        Execute kill command.
+
+        Internal use only.
+
+        """
         arg = struct.pack('<I', thread_id)
         self._execute_command(COMMAND.COM_PROCESS_KILL, arg)
         return self._read_ok_packet()
@@ -622,10 +824,15 @@ class Connection:
         """
         Check if the server is alive.
 
-        :param reconnect: If the connection is closed, reconnect.
-        :type reconnect: boolean
+        Parameters
+        ----------
+        reconnect : bool, optional
+            If the connection is closed, reconnect.
+
+        Raises
+        ------
+        Error : If the connection is closed and reconnect=False.
 
-        :raise Error: If the connection is closed and reconnect=False.
         """
         if self._sock is None:
             if reconnect:
@@ -644,15 +851,97 @@ class Connection:
                 raise
 
     def set_charset(self, charset):
+        """Deprecated. Use set_character_set() instead."""
+        # This function has been implemented in old PyMySQL.
+        # But this name is different from MySQLdb.
+        # So we keep this function for compatibility and add
+        # new set_character_set() function.
+        self.set_character_set(charset)
+
+    def set_character_set(self, charset, collation=None):
+        """
+        Set charaset (and collation) on the server.
+
+        Send "SET NAMES charset [COLLATE collation]" query.
+        Update Connection.encoding based on charset.
+
+        Parameters
+        ----------
+        charset : str
+            The charset to enable.
+        collation : str, optional
+            The collation value
+
+        """
         # Make sure charset is supported.
         encoding = charset_by_name(charset).encoding
 
-        self._execute_command(COMMAND.COM_QUERY, 'SET NAMES %s' % self.escape(charset))
+        if collation:
+            query = f'SET NAMES {charset} COLLATE {collation}'
+        else:
+            query = f'SET NAMES {charset}'
+        self._execute_command(COMMAND.COM_QUERY, query)
         self._read_packet()
         self.charset = charset
         self.encoding = encoding
+        self.collation = collation
+
+    def _sync_connection(self):
+        """Synchronize connection with env variable."""
+        if self._in_sync:
+            return
+
+        if not self._track_env:
+            return
+
+        url = os.environ.get('SINGLESTOREDB_URL')
+        if not url:
+            return
+
+        out = {}
+        urlp = connection._parse_url(url)
+        out.update(urlp)
+
+        out = connection._cast_params(out)
+
+        # Set default port based on driver.
+        if 'port' not in out or not out['port']:
+            out['port'] = int(get_option('port') or 3306)
+
+        # If there is no user and the password is empty, remove the password key.
+        if 'user' not in out and not out.get('password', None):
+            out.pop('password', None)
+
+        if out['host'] == 'singlestore.com':
+            raise err.InterfaceError(0, 'Connection URL has not been established')
+
+        # If it's just a password change, we don't need to reconnect
+        if self._sock is not None and \
+                (self.host, self.port, self.user, self.db) == \
+                (out['host'], out['port'], out['user'], out.get('database')):
+            return
+
+        self.host = out['host']
+        self.port = out['port']
+        self.user = out['user']
+        if isinstance(out['password'], str):
+            self.password = out['password'].encode('latin-1')
+        else:
+            self.password = out['password'] or b''
+        self.db = out.get('database')
+        try:
+            self._in_sync = True
+            self.connect()
+        finally:
+            self._in_sync = False
 
     def connect(self, sock=None):
+        """
+        Connect to server using existing parameters.
+
+        Internal use only.
+
+        """
         self._closed = False
         try:
             if sock is None:
@@ -674,7 +963,7 @@ class Connection:
                                 (self.host, self.port), self.connect_timeout, **kwargs,
                             )
                             break
-                        except (OSError, IOError) as e:
+                        except OSError as e:
                             if e.errno == errno.EINTR:
                                 continue
                             raise
@@ -692,18 +981,34 @@ class Connection:
             self._get_server_information()
             self._request_authentication()
 
+            # Send "SET NAMES" query on init for:
+            # - Ensure charaset (and collation) is set to the server.
+            #   - collation_id in handshake packet may be ignored.
+            # - If collation is not specified, we don't know what is server's
+            #   default collation for the charset. For example, default collation
+            #   of utf8mb4 is:
+            #   - MySQL 5.7, MariaDB 10.x: utf8mb4_general_ci
+            #   - MySQL 8.0: utf8mb4_0900_ai_ci
+            #
+            # Reference:
+            # - https://github.com/PyMySQL/PyMySQL/issues/1092
+            # - https://github.com/wagtail/wagtail/issues/9477
+            # - https://zenn.dev/methane/articles/2023-mysql-collation (Japanese)
+            self.set_character_set(self.charset, self.collation)
+
             if self.sql_mode is not None:
                 c = self.cursor()
                 c.execute('SET sql_mode=%s', (self.sql_mode,))
+                c.close()
 
             if self.init_command is not None:
                 c = self.cursor()
                 c.execute(self.init_command)
                 c.close()
-                self.commit()
 
             if self.autocommit_mode is not None:
                 self.autocommit(self.autocommit_mode)
+
         except BaseException as e:
             self._rfile = None
             if sock is not None:
@@ -712,10 +1017,10 @@ class Connection:
                 except:  # noqa
                     pass
 
-            if isinstance(e, (OSError, IOError)):
+            if isinstance(e, (OSError, IOError, socket.error)):
                 exc = err.OperationalError(
                     CR.CR_CONN_HOST_ERROR,
-                    "Can't connect to MySQL server on %r (%s)" % (self.host, e),
+                    f'Can\'t connect to MySQL server on {self.host!r} ({e})',
                 )
                 # Keep original exception and traceback to investigate error.
                 exc.original_exception = e
@@ -730,8 +1035,11 @@ class Connection:
             raise
 
     def write_packet(self, payload):
-        """Writes an entire "mysql packet" in its entirety to the network
-        adding its length and sequence number.
+        """
+        Writes an entire "mysql packet" in its entirety to the network.
+
+        Adds its length and sequence number.
+
         """
         # Internal note: when you build packet manually and calls _write_bytes()
         # directly, you should set self._next_seq_id properly.
@@ -742,11 +1050,18 @@ class Connection:
         self._next_seq_id = (self._next_seq_id + 1) % 256
 
     def _read_packet(self, packet_type=MysqlPacket):
-        """Read an entire "mysql packet" in its entirety from the network
-        and return a MysqlPacket type that represents the results.
+        """
+        Read an entire "mysql packet" in its entirety from the network.
+
+        Raises
+        ------
+        OperationalError : If the connection to the MySQL server is lost.
+        InternalError : If the packet sequence number is wrong.
+
+        Returns
+        -------
+        MysqlPacket
 
-        :raise OperationalError: If the connection to the MySQL server is lost.
-        :raise InternalError: If the packet sequence number is wrong.
         """
         buff = bytearray()
         while True:
@@ -787,12 +1102,13 @@ class Connection:
         return packet
 
     def _read_bytes(self, num_bytes):
-        self._sock.settimeout(self._read_timeout)
+        if self._read_timeout is not None:
+            self._sock.settimeout(self._read_timeout)
         while True:
             try:
                 data = self._rfile.read(num_bytes)
                 break
-            except (IOError, OSError) as e:
+            except OSError as e:
                 if e.errno == errno.EINTR:
                     continue
                 self._force_close()
@@ -812,13 +1128,14 @@ class Connection:
         return data
 
     def _write_bytes(self, data):
-        self._sock.settimeout(self._write_timeout)
+        if self._write_timeout is not None:
+            self._sock.settimeout(self._write_timeout)
         try:
             self._sock.sendall(data)
-        except IOError as e:
+        except OSError as e:
             self._force_close()
             raise err.OperationalError(
-                CR.CR_SERVER_GONE_ERROR, 'MySQL server has gone away (%r)' % (e,),
+                CR.CR_SERVER_GONE_ERROR, f'MySQL server has gone away ({e!r})',
             )
 
     def _read_query_result(self, unbuffered=False):
@@ -841,11 +1158,18 @@ class Connection:
 
     def _execute_command(self, command, sql):
         """
-        :raise InterfaceError: If the connection is closed.
-        :raise ValueError: If no username was specified.
+        Execute command.
+
+        Raises
+        ------
+        InterfaceError : If the connection is closed.
+        ValueError : If no username was specified.
+
         """
-        if not self._sock:
-            raise err.InterfaceError(0, '')
+        self._sync_connection()
+
+        if self._sock is None:
+            raise err.InterfaceError(0, 'The connection has been closed')
 
         # If the last query was unbuffered, make sure it finishes before
         # sending new commands
@@ -882,7 +1206,7 @@ class Connection:
             if not sql and packet_size < MAX_PACKET_LEN:
                 break
 
-    def _request_authentication(self):
+    def _request_authentication(self):  # noqa: C901
         # https://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::HandshakeResponse
         if int(self.server_version.split('.', 1)[0]) >= 5:
             self.client_flag |= CLIENT.MULTI_RESULTS
@@ -938,13 +1262,14 @@ class Connection:
             data += _lenenc_int(len(authresp)) + authresp
         elif self.server_capabilities & CLIENT.SECURE_CONNECTION:
             data += struct.pack('B', len(authresp)) + authresp
-        else:  # pragma: no cover - not testing against servers without secure auth (>=5.0)
+        else:  # pragma: no cover - no testing against servers w/o secure auth (>=5.0)
             data += authresp + b'\0'
 
-        if self.db and self.server_capabilities & CLIENT.CONNECT_WITH_DB:
-            if isinstance(self.db, str):
-                self.db = self.db.encode(self.encoding)
-            data += self.db + b'\0'
+        if self.server_capabilities & CLIENT.CONNECT_WITH_DB:
+            db = self.db
+            if isinstance(db, str):
+                db = db.encode(self.encoding)
+            data += (db or b'') + b'\0'
 
         if self.server_capabilities & CLIENT.PLUGIN_AUTH:
             data += (plugin_name or b'') + b'\0'
@@ -1021,6 +1346,8 @@ class Connection:
         elif plugin_name == b'mysql_clear_password':
             # https://dev.mysql.com/doc/internals/en/clear-text-authentication.html
             data = self.password + b'\0'
+        elif plugin_name == b'auth_gssapi_client':
+            data = _auth.gssapi_auth(auth_packet.read_all())
         elif plugin_name == b'dialog':
             pkt = auth_packet
             while True:
@@ -1157,7 +1484,8 @@ class Connection:
         if self.server_capabilities & CLIENT.PLUGIN_AUTH and len(data) >= i:
             # Due to Bug#59453 the auth-plugin-name is missing the terminating
             # NUL-char in versions prior to 5.5.10 and 5.6.2.
-            # ref: https://dev.mysql.com/doc/internals/en/connection-phase-packets.html#packet-Protocol::Handshake
+            # ref: https://dev.mysql.com/doc/internals/en/
+            #            connection-phase-packets.html#packet-Protocol::Handshake
             # didn't use version checks as mariadb is corrected and reports
             # earlier than those two.
             server_end = data.find(b'\0', i)
@@ -1183,10 +1511,19 @@ class Connection:
 
 
 class MySQLResult:
+    """
+    Results of a SQL query.
+
+    Parameters
+    ----------
+    connection : Connection
+        The connection the result came from.
+    unbuffered : bool, optional
+        Should the reads be unbuffered?
+
+    """
+
     def __init__(self, connection, unbuffered=False):
-        """
-        :type connection: Connection
-        """
         self.connection = connection
         self.affected_rows = None
         self.insert_id = None
@@ -1198,8 +1535,16 @@ class MySQLResult:
         self.rows = None
         self.has_next = None
         self.unbuffered_active = False
+        self.converters = []
+        self.fields = []
+        self.encoding_errors = self.connection.encoding_errors
         if unbuffered:
-            self.init_unbuffered_query()
+            try:
+                self.init_unbuffered_query()
+            except Exception:
+                self.connection = None
+                self.unbuffered_active = False
+                raise
 
     def __del__(self):
         if self.unbuffered_active:
@@ -1220,8 +1565,13 @@ class MySQLResult:
 
     def init_unbuffered_query(self):
         """
-        :raise OperationalError: If the connection to the MySQL server is lost.
-        :raise InternalError:
+        Initialize an unbuffered query.
+
+        Raises
+        ------
+        OperationalError : If the connection to the MySQL server is lost.
+        InternalError : Other errors.
+
         """
         self.unbuffered_active = True
         first_packet = self.connection._read_packet()
@@ -1261,7 +1611,7 @@ class MySQLResult:
         sender = LoadLocalFile(load_packet.filename, self.connection)
         try:
             sender.send_data()
-        except:
+        except Exception:
             self.connection._read_packet()  # skip ok packet
             raise
 
@@ -1281,7 +1631,8 @@ class MySQLResult:
         # TODO: Support CLIENT.DEPRECATE_EOF
         # 1) Add DEPRECATE_EOF to CAPABILITIES
         # 2) Mask CAPABILITIES with server_capabilities
-        # 3) if server_capabilities & CLIENT.DEPRECATE_EOF: use OKPacketWrapper instead of EOFPacketWrapper
+        # 3) if server_capabilities & CLIENT.DEPRECATE_EOF: use OKPacketWrapper
+        #    instead of EOFPacketWrapper
         wp = EOFPacketWrapper(packet)
         self.warning_count = wp.warning_count
         self.has_next = wp.has_next
@@ -1314,8 +1665,21 @@ class MySQLResult:
         # After much reading on the MySQL protocol, it appears that there is,
         # in fact, no way to stop MySQL from sending all the data after
         # executing a query, so we just spin, and wait for an EOF packet.
-        while self.unbuffered_active:
-            packet = self.connection._read_packet()
+        while self.unbuffered_active and self.connection._sock is not None:
+            try:
+                packet = self.connection._read_packet()
+            except err.OperationalError as e:
+                if e.args[0] in (
+                    ER.QUERY_TIMEOUT,
+                    ER.STATEMENT_TIMEOUT,
+                ):
+                    # if the query timed out we can simply ignore this error
+                    self.unbuffered_active = False
+                    self.connection = None
+                    return
+
+                raise
+
             if self._check_packet_is_eof(packet):
                 self.unbuffered_active = False
                 self.connection = None  # release reference to kill cyclic reference.
@@ -1344,7 +1708,7 @@ class MySQLResult:
                 break
             if data is not None:
                 if encoding is not None:
-                    data = data.decode(encoding)
+                    data = data.decode(encoding, errors=self.encoding_errors)
                 if DEBUG:
                     print('DEBUG: DATA = ', data)
                 if converter is not None:
@@ -1397,26 +1761,28 @@ class MySQLResult:
 
 
 class MySQLResultSV(MySQLResult):
+
     def __init__(self, connection, unbuffered=False):
         MySQLResult.__init__(self, connection, unbuffered=unbuffered)
         self.options = {
             k: v for k, v in dict(
                 default_converters=converters.decoders,
-                output_type=connection.output_type,
+                results_type=connection.results_type,
                 parse_json=connection.parse_json,
                 invalid_values=connection.invalid_values,
                 unbuffered=unbuffered,
             ).items() if v is not UNSET
         }
         self._read_rowdata_packet = functools.partial(
-            _pymysqlsv.read_rowdata_packet, self,
+            _singlestoredb_accel.read_rowdata_packet, self, False,
         )
         self._read_rowdata_packet_unbuffered = functools.partial(
-            _pymysqlsv.read_rowdata_packet, self,
+            _singlestoredb_accel.read_rowdata_packet, self, True,
         )
 
 
 class LoadLocalFile:
+
     def __init__(self, filename, connection):
         self.filename = filename
         self.connection = connection
@@ -1437,11 +1803,12 @@ class LoadLocalFile:
                     if not chunk:
                         break
                     conn.write_packet(chunk)
-        except IOError:
+        except OSError:
             raise err.OperationalError(
                 ER.FILE_NOT_FOUND,
                 f"Can't find file '{self.filename}'",
             )
         finally:
-            # send the empty packet to signify we are done sending data
-            conn.write_packet(b'')
+            if not conn._closed:
+                # send the empty packet to signify we are done sending data
+                conn.write_packet(b'')