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

singlestoredb/{http.py → http/connection.py}

@@ -1,8 +1,13 @@
 #!/usr/bin/env python
 """SingleStoreDB HTTP API interface."""
+import datetime
+import decimal
 import functools
 import json
+import math
+import os
 import re
+import time
 from base64 import b64decode
 from typing import Any
 from typing import Callable
@@ -10,41 +15,62 @@ from typing import Dict
 from typing import Iterable
 from typing import List
 from typing import Optional
+from typing import Sequence
 from typing import Tuple
 from typing import Union
 from urllib.parse import urljoin
+from urllib.parse import urlparse
 
 import requests
 
-from . import types
-from .config import get_option
-from .converters import converters
-from .exceptions import DatabaseError  # noqa: F401
-from .exceptions import DataError
-from .exceptions import Error
-from .exceptions import IntegrityError
-from .exceptions import InterfaceError
-from .exceptions import InternalError
-from .exceptions import NotSupportedError
-from .exceptions import OperationalError
-from .exceptions import ProgrammingError
-from .exceptions import Warning  # noqa: F401
-from .utils.convert_rows import convert_rows
-from .utils.results import Result
+try:
+    import numpy as np
+    has_numpy = True
+except ImportError:
+    has_numpy = False
+
+try:
+    import pygeos
+    has_pygeos = True
+except ImportError:
+    has_pygeos = False
+
+try:
+    import shapely.geometry
+    import shapely.wkt
+    has_shapely = True
+except ImportError:
+    has_shapely = False
+
+from .. import connection
+from .. import fusion
+from .. import types
+from ..config import get_option
+from ..converters import converters
+from ..exceptions import DatabaseError  # noqa: F401
+from ..exceptions import DataError
+from ..exceptions import Error  # noqa: F401
+from ..exceptions import IntegrityError
+from ..exceptions import InterfaceError
+from ..exceptions import InternalError
+from ..exceptions import NotSupportedError
+from ..exceptions import OperationalError
+from ..exceptions import ProgrammingError
+from ..exceptions import Warning  # noqa: F401
+from ..utils.convert_rows import convert_rows
+from ..utils.debug import log_query
+from ..utils.mogrify import mogrify
+from ..utils.results import Description
+from ..utils.results import format_results
+from ..utils.results import Result
 
 
 # DB-API settings
 apilevel = '2.0'
-paramstyle = 'qmark'
+paramstyle = 'named'
 threadsafety = 1
 
 
-Description = Tuple[
-    str, int, Optional[int], Optional[int], Optional[int],
-    Optional[int], bool,
-]
-
-
 _interface_errors = set([
     0,
     2013,  # CR_SERVER_LOST
@@ -145,6 +171,125 @@ def b64decode_converter(
     return converter(b64decode(x))
 
 
+def encode_timedelta(obj: datetime.timedelta) -> str:
+    """Encode timedelta as str."""
+    seconds = int(obj.seconds) % 60
+    minutes = int(obj.seconds // 60) % 60
+    hours = int(obj.seconds // 3600) % 24 + int(obj.days) * 24
+    if obj.microseconds:
+        fmt = '{0:02d}:{1:02d}:{2:02d}.{3:06d}'
+    else:
+        fmt = '{0:02d}:{1:02d}:{2:02d}'
+    return fmt.format(hours, minutes, seconds, obj.microseconds)
+
+
+def encode_time(obj: datetime.time) -> str:
+    """Encode time as str."""
+    if obj.microsecond:
+        fmt = '{0.hour:02}:{0.minute:02}:{0.second:02}.{0.microsecond:06}'
+    else:
+        fmt = '{0.hour:02}:{0.minute:02}:{0.second:02}'
+    return fmt.format(obj)
+
+
+def encode_datetime(obj: datetime.datetime) -> str:
+    """Encode datetime as str."""
+    if obj.microsecond:
+        fmt = '{0.year:04}-{0.month:02}-{0.day:02} ' \
+              '{0.hour:02}:{0.minute:02}:{0.second:02}.{0.microsecond:06}'
+    else:
+        fmt = '{0.year:04}-{0.month:02}-{0.day:02} ' \
+              '{0.hour:02}:{0.minute:02}:{0.second:02}'
+    return fmt.format(obj)
+
+
+def encode_date(obj: datetime.date) -> str:
+    """Encode date as str."""
+    fmt = '{0.year:04}-{0.month:02}-{0.day:02}'
+    return fmt.format(obj)
+
+
+def encode_struct_time(obj: time.struct_time) -> str:
+    """Encode time struct to str."""
+    return encode_datetime(datetime.datetime(*obj[:6]))
+
+
+def encode_decimal(o: decimal.Decimal) -> str:
+    """Encode decimal to str."""
+    return format(o, 'f')
+
+
+# Most argument encoding is done by the JSON encoder, but these
+# are exceptions to the rule.
+encoders = {
+    datetime.datetime: encode_datetime,
+    datetime.date: encode_date,
+    datetime.time: encode_time,
+    datetime.timedelta: encode_timedelta,
+    time.struct_time: encode_struct_time,
+    decimal.Decimal: encode_decimal,
+}
+
+
+if has_shapely:
+    encoders[shapely.geometry.Point] = shapely.wkt.dumps
+    encoders[shapely.geometry.Polygon] = shapely.wkt.dumps
+    encoders[shapely.geometry.LineString] = shapely.wkt.dumps
+
+if has_numpy:
+
+    def encode_ndarray(obj: np.ndarray) -> bytes:  # type: ignore
+        """Encode an ndarray as bytes."""
+        return obj.tobytes()
+
+    encoders[np.ndarray] = encode_ndarray
+
+if has_pygeos:
+    encoders[pygeos.Geometry] = pygeos.io.to_wkt
+
+
+def convert_special_type(
+    arg: Any,
+    nan_as_null: bool = False,
+    inf_as_null: bool = False,
+) -> Any:
+    """Convert special data type objects."""
+    dtype = type(arg)
+    if dtype is float or \
+            (
+                has_numpy and dtype in (
+                    np.float16, np.float32, np.float64,
+                    getattr(np, 'float128', np.float64),
+                )
+            ):
+        if nan_as_null and math.isnan(arg):
+            return None
+        if inf_as_null and math.isinf(arg):
+            return None
+    func = encoders.get(dtype, None)
+    if func is not None:
+        return func(arg)  # type: ignore
+    return arg
+
+
+def convert_special_params(
+    params: Optional[Union[Sequence[Any], Dict[str, Any]]] = None,
+    nan_as_null: bool = False,
+    inf_as_null: bool = False,
+) -> Optional[Union[Sequence[Any], Dict[str, Any]]]:
+    """Convert parameters of special data types."""
+    if params is None:
+        return params
+    converter = functools.partial(
+        convert_special_type,
+        nan_as_null=nan_as_null,
+        inf_as_null=inf_as_null,
+    )
+    if isinstance(params, Dict):
+        return {k: converter(v) for k, v in params.items()}
+    return tuple(map(converter, params))
+
+
 class PyMyField(object):
     """Field for PyMySQL compatibility."""
 
@@ -159,12 +304,13 @@ class PyMyResult(object):
 
     def __init__(self) -> None:
         self.fields: List[PyMyField] = []
+        self.unbuffered_active = False
 
     def append(self, item: PyMyField) -> None:
         self.fields.append(item)
 
 
-class Cursor(object):
+class Cursor(connection.Cursor):
     """
     SingleStoreDB HTTP database cursor.
 
@@ -178,17 +324,20 @@ class Cursor(object):
 
     """
 
-    def __init__(self, connection: 'Connection'):
-        self.connection: Optional[Connection] = connection
+    def __init__(self, conn: 'Connection'):
+        connection.Cursor.__init__(self, conn)
+        self._connection: Optional[Connection] = conn
         self._results: List[List[Tuple[Any, ...]]] = [[]]
+        self._results_type: str = self._connection._results_type \
+            if self._connection is not None else 'tuples'
         self._row_idx: int = -1
         self._result_idx: int = -1
         self._descriptions: List[List[Description]] = []
-        self.arraysize: int = 1000
+        self.arraysize: int = get_option('results.arraysize')
         self.rowcount: int = 0
-        self.messages: List[Tuple[int, str]] = []
         self.lastrowid: Optional[int] = None
         self._pymy_results: List[PyMyResult] = []
+        self._expect_results: bool = False
 
     @property
     def _result(self) -> Optional[PyMyResult]:
@@ -224,13 +373,13 @@ class Cursor(object):
         requests.Response
 
         """
-        if self.connection is None:
-            raise InterfaceError(errno=2048, msg='Connection is closed.')
-        return self.connection._post(path, *args, **kwargs)
+        if self._connection is None:
+            raise ProgrammingError(errno=2048, msg='Connection is closed.')
+        return self._connection._post(path, *args, **kwargs)
 
     def callproc(
         self, name: str,
-        params: Union[List[Any], Dict[str, Any]],
+        params: Optional[Sequence[Any]] = None,
     ) -> None:
         """
         Call a stored procedure.
@@ -239,47 +388,140 @@ class Cursor(object):
         ----------
         name : str
             Name of the stored procedure
-        params : iterable or dict, optional
+        params : sequence, optional
             Parameters to the stored procedure
 
         """
-        if self.connection is None:
-            raise InterfaceError(errno=2048, msg='Connection is closed.')
-        raise NotImplementedError
+        if self._connection is None:
+            raise ProgrammingError(errno=2048, msg='Connection is closed.')
+
+        name = connection._name_check(name)
+
+        if not params:
+            self._execute(f'CALL {name}();', is_callproc=True)
+        else:
+            keys = ', '.join(['%s' for i in range(len(params))])
+            self._execute(f'CALL {name}({keys});', params, is_callproc=True)
 
     def close(self) -> None:
         """Close the cursor."""
-        if self.connection is not None:
-            self.connection = None
+        self._connection = None
 
     def execute(
         self, query: str,
-        params: Optional[Union[List[Any], Dict[str, Any]]] = None,
-    ) -> None:
+        args: Optional[Union[Sequence[Any], Dict[str, Any]]] = None,
+    ) -> int:
         """
         Execute a SQL statement.
 
         Parameters
         ----------
-        oper : str
+        query : str
             The SQL statement to execute
-        params : iterable or dict, optional
+        args : iterable or dict, optional
             Parameters to substitute into the SQL code
 
         """
-        if self.connection is None:
-            raise InterfaceError(errno=2048, msg='Connection is closed.')
+        return self._execute(query, args)
 
-        data: Dict[str, Any] = dict(sql=query)
-        if params is not None:
-            data['args'] = params
-        if self.connection._database:
-            data['database'] = self.connection._database
+    def _validate_param_subs(
+        self, query: str,
+        args: Optional[Union[Sequence[Any], Dict[str, Any]]] = None,
+    ) -> None:
+        """Make sure the parameter substitions are valid."""
+        if args:
+            if isinstance(args, Sequence):
+                query = query % tuple(args)
+            else:
+                query = query % args
+
+    def _execute_fusion_query(
+        self,
+        oper: Union[str, bytes],
+        params: Optional[Union[Sequence[Any], Dict[str, Any]]] = None,
+        handler: Any = None,
+    ) -> int:
+        oper = mogrify(oper, params)
+
+        if isinstance(oper, bytes):
+            oper = oper.decode('utf-8')
+
+        log_query(oper, None)
+
+        results_type = self._results_type
+        self._results_type = 'tuples'
+        try:
+            mgmt_res = fusion.execute(
+                self._connection,  # type: ignore
+                oper,
+                handler=handler,
+            )
+        finally:
+            self._results_type = results_type
+
+        self._descriptions.append(list(mgmt_res.description))
+        self._results.append(list(mgmt_res.rows))
+        self.rowcount = len(self._results[-1])
+
+        pymy_res = PyMyResult()
+        for field in mgmt_res.fields:
+            pymy_res.append(
+                PyMyField(
+                    field.name,
+                    field.flags,
+                    field.charsetnr,
+                ),
+            )
+
+        self._pymy_results.append(pymy_res)
+
+        if self._results and self._results[0]:
+            self._row_idx = 0
+            self._result_idx = 0
+
+        return self.rowcount
+
+    def _execute(
+        self, oper: str,
+        params: Optional[Union[Sequence[Any], Dict[str, Any]]] = None,
+        is_callproc: bool = False,
+    ) -> int:
+        self._descriptions = []
+        self._results = []
+        self._pymy_results = []
+        self._row_idx = -1
+        self._result_idx = -1
+        self.rowcount = 0
+        self._expect_results = False
+
+        if self._connection is None:
+            raise ProgrammingError(errno=2048, msg='Connection is closed.')
 
         sql_type = 'exec'
-        if re.match(r'^\s*(select|show|call|echo)\s+', query, flags=re.I):
+        if re.match(r'^\s*(select|show|call|echo|describe|with)\s+', oper, flags=re.I):
+            self._expect_results = True
             sql_type = 'query'
 
+        self._validate_param_subs(oper, params)
+
+        handler = fusion.get_handler(oper)
+        if handler is not None:
+            return self._execute_fusion_query(oper, params, handler=handler)
+
+        oper, params = self._connection._convert_params(oper, params)
+
+        log_query(oper, params)
+
+        data: Dict[str, Any] = dict(sql=oper)
+        if params is not None:
+            data['args'] = convert_special_params(
+                params,
+                nan_as_null=self._connection.connection_params['nan_as_null'],
+                inf_as_null=self._connection.connection_params['inf_as_null'],
+            )
+        if self._connection._database:
+            data['database'] = self._connection._database
+
         if sql_type == 'query':
             res = self._post('query/tuples', json=data)
         else:
@@ -298,18 +540,18 @@ class Cursor(object):
 
         out = json.loads(res.text)
 
-        self._descriptions = []
-        self._results = []
-        self._row_idx = -1
-        self._result_idx = -1
-        self.rowcount = 0
+        if 'error' in out:
+            raise OperationalError(
+                errno=out['error'].get('code', 0),
+                msg=out['error'].get('message', 'HTTP Error'),
+            )
 
         if sql_type == 'query':
             # description: (name, type_code, display_size, internal_size,
             #               precision, scale, null_ok, column_flags, charset)
 
             # Remove converters for things the JSON parser already converted
-            http_converters = dict(converters)
+            http_converters = dict(self._connection.decoders)
             http_converters.pop(4, None)
             http_converters.pop(5, None)
             http_converters.pop(6, None)
@@ -323,6 +565,12 @@ class Cursor(object):
             http_converters.pop(253, None)
             http_converters.pop(254, None)
 
+            # Merge passed in converters
+            if self._connection._conv:
+                for k, v in self._connection._conv.items():
+                    if isinstance(k, int):
+                        http_converters[k] = v
+
             results = out['results']
 
             # Convert data to Python types
@@ -358,11 +606,14 @@ class Cursor(object):
                                 prec += 1  # for decimal
                         if converter is not None:
                             convs.append((i, None, converter))
-                        description.append((
-                            str(col['name']), type_code,
-                            None, None, prec, scale,
-                            col.get('nullable', False),
-                        ))
+                        description.append(
+                            Description(
+                                str(col['name']), type_code,
+                                None, None, prec, scale,
+                                col.get('nullable', False),
+                                flags, charset,
+                            ),
+                        )
                         pymy_res.append(PyMyField(col['name'], flags, charset))
                     self._descriptions.append(description)
 
@@ -371,21 +622,25 @@ class Cursor(object):
                     self._results.append(rows)
                     self._pymy_results.append(pymy_res)
 
+            # For compatibility with PyMySQL/MySQLdb
+            if is_callproc:
+                self._results.append([])
+
             self.rowcount = len(self._results[0])
+
         else:
+            # For compatibility with PyMySQL/MySQLdb
+            if is_callproc:
+                self._results.append([])
+
             self.rowcount = out['rowsAffected']
 
+        return self.rowcount
+
     def executemany(
         self, query: str,
-        param_seq: Optional[
-            List[
-                Union[
-                    List[Any],
-                    Dict[str, Any],
-                ]
-            ]
-        ] = None,
-    ) -> None:
+        args: Optional[Sequence[Union[Sequence[Any], Dict[str, Any]]]] = None,
+    ) -> int:
         """
         Execute SQL code against multiple sets of parameters.
 
@@ -393,28 +648,38 @@ class Cursor(object):
         ----------
         query : str
             The SQL statement to execute
-        params_seq : iterable of iterables or dicts, optional
+        args : iterable of iterables or dicts, optional
             Sets of parameters to substitute into the SQL code
 
         """
-        if self.connection is None:
-            raise InterfaceError(errno=2048, msg='Connection is closed.')
+        if self._connection is None:
+            raise ProgrammingError(errno=2048, msg='Connection is closed.')
 
         results = []
-        if param_seq:
+        rowcount = 0
+        if args is not None and len(args) > 0:
             description = []
-            for params in param_seq:
+            # Detect dataframes
+            if hasattr(args, 'itertuples'):
+                argiter = args.itertuples(index=False)  # type: ignore
+            else:
+                argiter = iter(args)
+            for params in argiter:
                 self.execute(query, params)
                 if self._descriptions:
                     description = self._descriptions[-1]
                 if self._rows is not None:
                     results.append(self._rows)
+                rowcount += self.rowcount
             self._results = results
             self._descriptions = [description for _ in range(len(results))]
-            if self._results:
-                self.rowcount = len(self._results[0])
         else:
             self.execute(query)
+            rowcount += self.rowcount
+
+        self.rowcount = rowcount
+
+        return self.rowcount
 
     @property
     def _has_row(self) -> bool:
@@ -444,11 +709,19 @@ class Cursor(object):
             If there are no rows left to return
 
         """
+        if self._connection is None:
+            raise ProgrammingError(errno=2048, msg='Connection is closed')
+        if not self._expect_results:
+            raise self._connection.ProgrammingError(msg='No query has been submitted')
         if not self._has_row:
             return None
         out = self._rows[self._row_idx]
         self._row_idx += 1
-        return out
+        return format_results(
+            self._results_type,
+            self.description or [],
+            out, single=True,
+        )
 
     def fetchmany(
         self,
@@ -465,15 +738,21 @@ class Cursor(object):
             Values of the returned rows if there are rows remaining
 
         """
+        if self._connection is None:
+            raise ProgrammingError(errno=2048, msg='Connection is closed')
+        if not self._expect_results:
+            raise self._connection.ProgrammingError(msg='No query has been submitted')
         if not self._has_row:
-            return []
+            if 'dict' in self._results_type:
+                return {}
+            return tuple()
         if not size:
             size = max(int(self.arraysize), 1)
         else:
             size = max(int(size), 1)
         out = self._rows[self._row_idx:self._row_idx+size]
-        self._row_idx += size
-        return out
+        self._row_idx += len(out)
+        return format_results(self._results_type, self.description or [], out)
 
     def fetchall(self) -> Result:
         """
@@ -485,17 +764,26 @@ class Cursor(object):
             Values of the returned rows if there are rows remaining
 
         """
+        if self._connection is None:
+            raise ProgrammingError(errno=2048, msg='Connection is closed')
+        if not self._expect_results:
+            raise self._connection.ProgrammingError(msg='No query has been submitted')
         if not self._has_row:
-            return []
-        out = list(self._rows)
-        self._row_idx = -1
-        return out
+            if 'dict' in self._results_type:
+                return {}
+            return tuple()
+        out = list(self._rows[self._row_idx:])
+        self._row_idx = len(out)
+        return format_results(self._results_type, self.description or [], out)
 
     def nextset(self) -> Optional[bool]:
         """Skip to the next available result set."""
+        if self._connection is None:
+            raise ProgrammingError(errno=2048, msg='Connection is closed')
+
         if self._result_idx < 0:
             self._row_idx = -1
-            return False
+            return None
 
         self._result_idx += 1
         self._row_idx = 0
@@ -503,13 +791,13 @@ class Cursor(object):
         if self._result_idx >= len(self._results):
             self._result_idx = -1
             self._row_idx = -1
-            return False
+            return None
 
         self.rowcount = len(self._results[self._result_idx])
 
         return True
 
-    def setinputsizes(self, sizes: List[int]) -> None:
+    def setinputsizes(self, sizes: Sequence[int]) -> None:
         """Predefine memory areas for parameters."""
         pass
 
@@ -517,7 +805,7 @@ class Cursor(object):
         """Set a column buffer size for fetches of large columns."""
         pass
 
-    @ property
+    @property
     def rownumber(self) -> Optional[int]:
         """
         Return the zero-based index of the cursor in the result set.
@@ -543,6 +831,8 @@ class Cursor(object):
             Type of move that should be made: 'relative' or 'absolute'
 
         """
+        if self._connection is None:
+            raise ProgrammingError(errno=2048, msg='Connection is closed')
         if mode == 'relative':
             self._row_idx += value
         elif mode == 'absolute':
@@ -565,6 +855,8 @@ class Cursor(object):
             If no more rows exist
 
         """
+        if self._connection is None:
+            raise InterfaceError(errno=2048, msg='Connection is closed')
         out = self.fetchone()
         if out is None:
             raise StopIteration
@@ -587,6 +879,13 @@ class Cursor(object):
         """Exit a context."""
         self.close()
 
+    @property
+    def open(self) -> bool:
+        """Check if the cursor is still connected."""
+        if self._connection is None:
+            return False
+        return self._connection.is_connected()
+
     def is_connected(self) -> bool:
         """
         Check if the cursor is still connected.
@@ -596,12 +895,10 @@ class Cursor(object):
         bool
 
         """
-        if self.connection is None:
-            return False
-        return self.connection.is_connected()
+        return self.open
 
 
-class Connection(object):
+class Connection(connection.Connection):
     """
     SingleStoreDB HTTP database connection.
 
@@ -613,19 +910,13 @@ class Connection(object):
     `connect`
 
     """
-
-    Warning = Warning
-    Error = Error
-    InterfaceError = InterfaceError
-    DatabaseError = DatabaseError
-    DataError = DataError
-    OperationalError = OperationalError
-    IntegrityError = IntegrityError
-    InternalError = InternalError
-    ProgrammingError = ProgrammingError
-    NotSupportedError = NotSupportedError
+    driver = 'https'
+    paramstyle = 'qmark'
 
     def __init__(self, **kwargs: Any):
+        from .. import __version__ as client_version
+        connection.Connection.__init__(self, **kwargs)
+
         host = kwargs.get('host', get_option('host'))
         port = kwargs.get('port', get_option('http_port'))
 
@@ -641,6 +932,7 @@ class Connection(object):
             'Content-Type': 'application/json',
             'Accept': 'application/json',
             'Accept-Encoding': 'compress,identity',
+            'User-Agent': f'SingleStoreDB-Python/{client_version}',
         })
 
         if kwargs.get('ssl_disabled', get_option('ssl_disabled')):
@@ -657,13 +949,104 @@ class Connection(object):
             if ssl_ca:
                 self._sess.verify = ssl_ca
 
-        version = kwargs.get('version', 'v1')
-        protocol = kwargs.get('protocol', 'https')
+            ssl_verify_cert = kwargs.get('ssl_verify_cert', True)
+            if not ssl_verify_cert:
+                self._sess.verify = False
+
+        if kwargs.get('multi_statements', False):
+            raise self.InterfaceError(
+                0, 'The Data API does not allow multiple '
+                'statements within a query',
+            )
+
+        self._version = kwargs.get('version', 'v2')
+        self.driver = kwargs.get('driver', 'https')
+
+        self.encoders = {k: v for (k, v) in converters.items() if type(k) is not int}
+        self.decoders = {k: v for (k, v) in converters.items() if type(k) is int}
 
         self._database = kwargs.get('database', get_option('database'))
-        self._url = f'{protocol}://{host}:{port}/api/{version}/'
-        self.messages: List[List[Any]] = []
+        self._url = f'{self.driver}://{host}:{port}/api/{self._version}/'
+        self._host = host
+        self._messages: List[Tuple[int, str]] = []
         self._autocommit: bool = True
+        self._conv = kwargs.get('conv', None)
+        self._in_sync: bool = False
+        self._track_env: bool = kwargs.get('track_env', False) \
+            or host == 'singlestore.com'
+
+    @property
+    def messages(self) -> List[Tuple[int, str]]:
+        return self._messages
+
+    def connect(self) -> 'Connection':
+        """Connect to the server."""
+        return self
+
+    def _sync_connection(self, kwargs: Dict[str, Any]) -> None:
+        """Synchronize connection with env variable."""
+        if self._sess is None:
+            raise InterfaceError(errno=2048, msg='Connection is closed.')
+
+        if self._in_sync:
+            return
+
+        if not self._track_env:
+            return
+
+        url = os.environ.get('SINGLESTOREDB_URL')
+        if not url:
+            if self._host == 'singlestore.com':
+                raise InterfaceError(0, 'Connection URL has not been established')
+            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']:
+            if out.get('driver', 'https') == 'http':
+                out['port'] = int(get_option('port') or 80)
+            else:
+                out['port'] = int(get_option('port') or 443)
+
+        # 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 InterfaceError(0, 'Connection URL has not been established')
+
+        # Get current connection attributes
+        curr_url = urlparse(self._url, scheme='singlestoredb', allow_fragments=True)
+        if self._sess.auth is not None:
+            auth = tuple(self._sess.auth)  # type: ignore
+        else:
+            auth = (None, None)  # type: ignore
+
+        # If it's just a password change, we don't need to reconnect
+        if (curr_url.hostname, curr_url.port, auth[0], self._database) == \
+                (out['host'], out['port'], out['user'], out.get('database')):
+            return
+
+        try:
+            self._in_sync = True
+            sess = requests.Session()
+            sess.auth = (out['user'], out['password'])
+            sess.headers.update(self._sess.headers)
+            sess.verify = self._sess.verify
+            sess.cert = self._sess.cert
+            self._database = out.get('database')
+            self._host = out['host']
+            self._url = f'{out.get("driver", "https")}://{out["host"]}:{out["port"]}' \
+                        f'/api/{self._version}/'
+            self._sess = sess
+            if self._database:
+                kwargs['json']['database'] = self._database
+        finally:
+            self._in_sync = False
 
     def _post(self, path: str, *args: Any, **kwargs: Any) -> requests.Response:
         """
@@ -685,24 +1068,46 @@ class Connection(object):
         """
         if self._sess is None:
             raise InterfaceError(errno=2048, msg='Connection is closed.')
+
+        self._sync_connection(kwargs)
+
+        if 'timeout' not in kwargs:
+            kwargs['timeout'] = get_option('connect_timeout')
+
         return self._sess.post(urljoin(self._url, path), *args, **kwargs)
 
     def close(self) -> None:
         """Close the connection."""
+        if self._host == 'singlestore.com':
+            return
+        if self._sess is None:
+            raise Error(errno=2048, msg='Connection is closed')
         self._sess = None
 
-    def autocommit(self, value: bool) -> None:
+    def autocommit(self, value: bool = True) -> None:
         """Set autocommit mode."""
+        if self._host == 'singlestore.com':
+            return
+        if self._sess is None:
+            raise InterfaceError(errno=2048, msg='Connection is closed')
         self._autocommit = value
 
     def commit(self) -> None:
         """Commit the pending transaction."""
+        if self._host == 'singlestore.com':
+            return
+        if self._sess is None:
+            raise InterfaceError(errno=2048, msg='Connection is closed')
         if self._autocommit:
             return
         raise NotSupportedError(msg='operation not supported')
 
     def rollback(self) -> None:
         """Rollback the pending transaction."""
+        if self._host == 'singlestore.com':
+            return
+        if self._sess is None:
+            raise InterfaceError(errno=2048, msg='Connection is closed')
         if self._autocommit:
             return
         raise NotSupportedError(msg='operation not supported')
@@ -729,6 +1134,17 @@ class Connection(object):
         """Exit a context."""
         self.close()
 
+    @property
+    def open(self) -> bool:
+        """Check if the database is still connected."""
+        if self._sess is None:
+            return False
+        url = '/'.join(self._url.split('/')[:3]) + '/ping'
+        res = self._sess.get(url)
+        if res.status_code <= 400 and res.text == 'pong':
+            return True
+        return False
+
     def is_connected(self) -> bool:
         """
         Check if the database is still connected.
@@ -738,54 +1154,39 @@ class Connection(object):
         bool
 
         """
-        if self._sess is None:
-            return False
-        url = '/'.join(self._url.split('/')[:3]) + '/ping'
-        res = self._sess.get(url)
-        if res.status_code <= 400 and res.text == 'pong':
-            return True
-        return False
+        return self.open
 
 
 def connect(
-    host: Optional[str] = None, port: Optional[int] = None,
-    user: Optional[str] = None, password: Optional[str] = None,
-    database: Optional[str] = None, protocol: str = 'https', version: str = 'v1',
-    ssl_key: Optional[str] = None, ssl_cert: Optional[str] = None,
-    ssl_ca: Optional[str] = None, ssl_disabled: Optional[bool] = None,
+    host: Optional[str] = None,
+    user: Optional[str] = None,
+    password: Optional[str] = None,
+    port: Optional[int] = None,
+    database: Optional[str] = None,
+    driver: Optional[str] = None,
+    pure_python: Optional[bool] = None,
+    local_infile: Optional[bool] = None,
+    charset: Optional[str] = None,
+    ssl_key: Optional[str] = None,
+    ssl_cert: Optional[str] = None,
+    ssl_ca: Optional[str] = None,
+    ssl_disabled: Optional[bool] = None,
+    ssl_cipher: Optional[str] = None,
+    ssl_verify_cert: Optional[bool] = None,
+    ssl_verify_identity: Optional[bool] = None,
+    conv: Optional[Dict[int, Callable[..., Any]]] = None,
+    credential_type: Optional[str] = None,
+    autocommit: Optional[bool] = None,
+    results_type: Optional[str] = None,
+    buffered: Optional[bool] = None,
+    results_format: Optional[str] = None,
+    program_name: Optional[str] = None,
+    conn_attrs: Optional[Dict[str, str]] = None,
+    multi_statements: Optional[bool] = None,
+    connect_timeout: Optional[int] = None,
+    nan_as_null: Optional[bool] = None,
+    inf_as_null: Optional[bool] = None,
+    encoding_errors: Optional[str] = None,
+    track_env: Optional[bool] = None,
 ) -> Connection:
-    """
-    Connect to a SingleStoreDB using HTTP.
-
-    Parameters
-    ----------
-    user : str, optional
-        Database user name
-    password : str, optional
-        Database user password
-    host : str, optional
-        Database host name or IP address
-    port : int, optional
-        Database port. This defaults to 3306 for non-HTTP connections, 80
-        for HTTP connections, and 443 for HTTPS connections.
-    database : str, optional
-        Database name
-    protocol : str, optional
-        HTTP protocol: `http` or `https`
-    version : str, optional
-        Version of the HTTP API
-    ssl_key : str, optional
-        File containing SSL key
-    ssl_cert : str, optional
-        File containing SSL certificate
-    ssl_ca : str, optional
-        File containing SSL certificate authority
-    ssl_disabled : bool, optional
-        Disable SSL usage
-
-    Returns
-    -------
-    Connection
-
-    """
     return Connection(**dict(locals()))