singlestoredb 0.3.3__py3-none-any.whl → 1.0.3__py3-none-any.whl

singlestoredb/connection.py

@@ -1,12 +1,10 @@
 #!/usr/bin/env python
 """SingleStoreDB connections and cursors."""
-from __future__ import annotations
-
+import abc
 import inspect
-import pprint
 import re
+import warnings
 import weakref
-from collections import namedtuple
 from collections.abc import Mapping
 from collections.abc import MutableMapping
 from typing import Any
@@ -30,23 +28,17 @@ except ImportError:
             pass
 
 from . import auth
-from . import drivers
 from . import exceptions
-from . import types
 from .config import get_option
-from .drivers.base import Driver
-from .utils.convert_rows import convert_row
-from .utils.convert_rows import convert_rows
 from .utils.results import Description
-from .utils.results import format_results
 from .utils.results import Result
 
 
 # DB-API settings
 apilevel = '2.0'
 threadsafety = 1
-paramstyle = map_paramstyle = 'named'
-positional_paramstyle = 'numeric'
+paramstyle = map_paramstyle = 'pyformat'
+positional_paramstyle = 'format'
 
 
 # Type codes for character-based columns
@@ -104,7 +96,7 @@ def cast_bool_param(val: Any) -> bool:
         if val.lower() in ['on', 't', 'true', 'y', 'yes', 'enabled', 'enable']:
             return True
         elif val.lower() in ['off', 'f', 'false', 'n', 'no', 'disabled', 'disable']:
-            return True
+            return False
 
     raise ValueError('Unrecognized value for bool: {}'.format(val))
 
@@ -129,10 +121,18 @@ def build_params(**kwargs: Any) -> Dict[str, Any]:
 
     # Set known parameters
     for name in inspect.getfullargspec(connect).args:
-        if name == 'converters':
-            out[name] = kwargs.get(name, {})
-        elif name == 'results_format':
-            out[name] = kwargs.get(name, get_option('results.format'))
+        if name == 'conv':
+            out[name] = kwargs.get(name, None)
+        elif name == 'results_format':  # deprecated
+            if kwargs.get(name, None) is not None:
+                warnings.warn(
+                    'The `results_format=` parameter has been '
+                    'renamed to `results_type=`.',
+                    DeprecationWarning,
+                )
+                out['results_type'] = kwargs.get(name, get_option('results.type'))
+        elif name == 'results_type':
+            out[name] = kwargs.get(name, get_option('results.type'))
         else:
             out[name] = kwargs.get(name, get_option(name))
 
@@ -159,6 +159,9 @@ def build_params(**kwargs: Any) -> Dict[str, Any]:
     if 'user' not in out and not out.get('password', None):
         out.pop('password', None)
 
+    if out.get('ssl_ca', '') and not out.get('ssl_verify_cert', None):
+        out['ssl_verify_cert'] = True
+
     return out
 
 
@@ -217,7 +220,8 @@ def _cast_params(params: Dict[str, Any]) -> Dict[str, Any]:
         dtype = param_types[key]
         if dtype is bool:
             val = cast_bool_param(val)
-        elif getattr(dtype, '_name', '') in ['Dict', 'Mapping']:
+        elif getattr(dtype, '_name', '') in ['Dict', 'Mapping'] or \
+                str(dtype).startswith('typing.Dict'):
             val = dict(val)
         elif getattr(dtype, '_name', '') == 'List':
             val = list(val)
@@ -303,10 +307,17 @@ def quote_identifier(name: str) -> str:
     return f'`{name}`'
 
 
+class Driver(object):
+    """Compatibility class for driver name."""
+
+    def __init__(self, name: str):
+        self.name = name
+
+
 class VariableAccessor(MutableMapping):  # type: ignore
     """Variable accessor class."""
 
-    def __init__(self, conn: Connection, vtype: str):
+    def __init__(self, conn: 'Connection', vtype: str):
         object.__setattr__(self, 'connection', weakref.proxy(conn))
         object.__setattr__(self, 'vtype', vtype.lower())
         if self.vtype not in [
@@ -328,30 +339,30 @@ class VariableAccessor(MutableMapping):  # type: ignore
 
     def __getitem__(self, name: str) -> Any:
         name = _name_check(name)
-        with self.connection._i_cursor() as cur:
-            cur.execute('show {} variables like "{}";'.format(self.vtype, name))
-            out = list(cur)
-            if not out:
-                raise KeyError(f"No variable found with the name '{name}'.")
-            if len(out) > 1:
-                raise KeyError(f"Multiple variables found with the name '{name}'.")
-            return self._cast_value(out[0][1])
+        out = self.connection._iquery(
+            'show {} variables like %s;'.format(self.vtype),
+            [name],
+        )
+        if not out:
+            raise KeyError(f"No variable found with the name '{name}'.")
+        if len(out) > 1:
+            raise KeyError(f"Multiple variables found with the name '{name}'.")
+        return self._cast_value(out[0]['Value'])
 
     def __setitem__(self, name: str, value: Any) -> None:
         name = _name_check(name)
-        with self.connection._i_cursor() as cur:
-            if value is True:
-                value = 'ON'
-            elif value is False:
-                value = 'OFF'
-            if 'local' in self.vtype:
-                cur.execute(
-                    'set {} {}=:1;'.format(
-                        self.vtype.replace('local', 'session'), name,
-                    ), [value],
-                )
-            else:
-                cur.execute('set {} {}=:1;'.format(self.vtype, name), [value])
+        if value is True:
+            value = 'ON'
+        elif value is False:
+            value = 'OFF'
+        if 'local' in self.vtype:
+            self.connection._iquery(
+                'set {} {}=%s;'.format(
+                    self.vtype.replace('local', 'session'), name,
+                ), [value],
+            )
+        else:
+            self.connection._iquery('set {} {}=%s;'.format(self.vtype, name), [value])
 
     def __delitem__(self, name: str) -> None:
         raise TypeError('Variables can not be deleted.')
@@ -366,17 +377,15 @@ class VariableAccessor(MutableMapping):  # type: ignore
         del self[name]
 
     def __len__(self) -> int:
-        with self.connection._i_cursor() as cur:
-            cur.execute('show {} variables;'.format(self.vtype))
-            return len(list(cur))
+        out = self.connection._iquery('show {} variables;'.format(self.vtype))
+        return len(list(out))
 
     def __iter__(self) -> Iterator[str]:
-        with self.connection._i_cursor() as cur:
-            cur.execute('show {} variables;'.format(self.vtype))
-            return iter(x[0] for x in list(cur))
+        out = self.connection._iquery('show {} variables;'.format(self.vtype))
+        return iter(list(x.values())[0] for x in out)
 
 
-class Cursor(object):
+class Cursor(metaclass=abc.ABCMeta):
     """
     Database cursor for submitting commands and queries.
 
@@ -385,21 +394,14 @@ class Cursor(object):
 
     """
 
-    def __init__(
-            self, connection: Connection, cursor: Any, driver: Driver,
-    ):
+    def __init__(self, connection: 'Connection'):
         """Call ``Connection.cursor`` instead."""
         self.errorhandler = connection.errorhandler
-        self._results_format: str = connection.results_format
-        self._conn: Optional[Connection] = weakref.proxy(connection)
-        self._cursor = cursor
-        self._driver = driver
+        self._connection: Optional[Connection] = weakref.proxy(connection)
 
-        #: Current row of the cursor.
-        self.rownumber: Optional[int] = None
+        self._rownumber: Optional[int] = None
 
-        #: Description of columns in the last executed query.
-        self.description: Optional[List[Description]] = None
+        self._description: Optional[List[Description]] = None
 
         #: Default batch size of ``fetchmany`` calls.
         self.arraysize = get_option('results.arraysize')
@@ -414,86 +416,32 @@ class Cursor(object):
         #: Number of rows affected by the last query.
         self.rowcount: int = -1
 
-        #: Messages generated during last query.
-        self.messages: List[str] = []
+        self._messages: List[Tuple[int, str]] = []
 
         #: Row ID of the last modified row.
         self.lastrowid: Optional[int] = None
 
     @property
-    def connection(self) -> Optional[Connection]:
-        """
-        Return the connection that the cursor belongs to.
-
-        Returns
-        -------
-        Connection or None
-
-        """
-        return self._conn
+    def messages(self) -> List[Tuple[int, str]]:
+        """Messages created by the server."""
+        return self._messages
 
-    def _set_description(self) -> None:
-        """
-        Return column descriptions for the current result set.
+    @abc.abstractproperty
+    def description(self) -> Optional[List[Description]]:
+        """The field descriptions of the last query."""
+        return self._description
 
-        Returns
-        -------
-        list of Description
+    @abc.abstractproperty
+    def rownumber(self) -> Optional[int]:
+        """The last modified row number."""
+        return self._rownumber
 
-        """
-        if self._cursor.description:
-            self._converters.clear()
-            out = []
-            for i, item in enumerate(self._cursor.description):
-                item = list(item) + [None, None]
-                item[1] = types.ColumnType.get_code(item[1])
-                item[6] = not(not(item[6]))
-                out.append(Description(*item[:9]))
-
-                # Setup override converters, if the SET flag is set use that
-                # converter but keep the same type code.
-                if item[7] and item[7] & 2048:  # SET_FLAG = 2048
-                    conv = self._driver.converters.get(247, None)  # SET CODE = 247
-                else:
-                    conv = self._driver.converters.get(item[1], None)
-
-                encoding = None
-
-                # Determine proper encoding for character fields as needed
-                if self._driver.returns_bytes:
-                    if item[1] in CHAR_COLUMNS:
-                        if item[8] and item[8] == 63:  # BINARY / BLOB
-                            pass
-                        elif self._conn is not None:
-                            encoding = self._conn.encoding
-                        else:
-                            encoding = 'utf-8'
-                    elif item[1] == 16:  # BIT
-                        pass
-                    else:
-                        encoding = 'ascii'
-
-                if conv is not None:
-                    self._converters.append((i, encoding, conv))
-                elif encoding is not None:
-                    self._converters.append((i, encoding, None))
-
-            self.description = out
-
-    def _update_attrs(self) -> None:
-        """Update cursor attributes from the last query."""
-        if self._cursor is None:
-            return
-        self.messages[:] = getattr(self._cursor, 'messages', [])
-        self.lastrowid = getattr(
-            self._cursor, 'lastrowid',
-            getattr(self._cursor, '_lastrowid', None),
-        ) or None
-        self.rowcount = getattr(
-            self._cursor, 'rowcount',
-            getattr(self._cursor, '_rowcount', -1),
-        )
+    @property
+    def connection(self) -> Optional['Connection']:
+        """the connection that the cursor belongs to."""
+        return self._connection
 
+    @abc.abstractmethod
     def callproc(
         self, name: str,
         params: Optional[Sequence[Any]] = None,
@@ -507,18 +455,23 @@ class Cursor(object):
         multiple result sets, subsequent result sets can be accessed
         using :meth:`nextset`.
 
+        Examples
+        --------
+        >>> cur.callproc('myprocedure', ['arg1', 'arg2'])
+        >>> print(cur.fetchall())
+
         Parameters
         ----------
         name : str
             Name of the stored procedure
-        params : iterable,  optional
+        params : iterable, optional
             Parameters to the stored procedure
 
         """
         # NOTE: The `callproc` interface varies quite a bit between drivers
         #       so it is implemented using `execute` here.
 
-        if self._cursor is None:
+        if not self.is_connected():
             raise exceptions.InterfaceError(2048, 'Cursor is closed.')
 
         name = _name_check(name)
@@ -529,186 +482,144 @@ class Cursor(object):
             keys = ', '.join([f':{i+1}' for i in range(len(params))])
             self.execute(f'CALL {name}({keys});', params)
 
+    @abc.abstractmethod
+    def is_connected(self) -> bool:
+        """Is the cursor still connected?"""
+        raise NotImplementedError
+
+    @abc.abstractmethod
     def close(self) -> None:
         """Close the cursor."""
-        if self._cursor is None:
-            raise exceptions.InterfaceError(2048, 'Cursor is closed.')
-
-        try:
-            self._cursor.close()
-
-        # Ignore weak reference errors. It just means the connection
-        # was closed underneath us.
-        except ReferenceError:
-            pass
-
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
-
-        self._cursor = None
-        self._conn = None
+        raise NotImplementedError
 
+    @abc.abstractmethod
     def execute(
-        self, oper: str,
-        params: Optional[Union[Sequence[Any], Mapping[str, Any]]] = None,
-    ) -> None:
+        self, query: str,
+        args: Optional[Union[Sequence[Any], Dict[str, Any], Any]] = None,
+    ) -> int:
         """
         Execute a SQL statement.
 
+        Queries can use the ``format``-style parameters (``%s``) when using a
+        list of paramters or ``pyformat``-style parameters (``%(key)s``)
+        when using a dictionary of parameters.
+
         Parameters
         ----------
-        oper : str
+        query : str
             The SQL statement to execute
-        params : iterable or dict, optional
+        args : Sequence or dict, optional
             Parameters to substitute into the SQL code
 
-        """
-        if self._cursor is None:
-            raise exceptions.InterfaceError(2048, 'Cursor is closed.')
+        Examples
+        --------
+        >>> cur.execute('select * from mytable')
 
-        self.description = None
-        self.rownumber = None
+        >>> cur.execute('select * from mytable where id < %s', [100])
 
-        try:
-            if params:
-                param_converter = sqlparams.SQLParams(
-                    isinstance(params, Mapping) and
-                    map_paramstyle or positional_paramstyle,
-                    self._driver.dbapi.paramstyle,
-                    escape_char=True,
-                )
-                self._cursor.execute(*param_converter.format(oper, params))
-            else:
-                self._cursor.execute(oper)
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
+        >>> cur.execute('select * from mytable where id < %(max)s', dict(max=100))
+
+        Returns
+        -------
+        Number of rows affected
 
-        self._set_description()
-        self._update_attrs()
-        self.rownumber = 0
+        """
+        raise NotImplementedError
 
     def executemany(
-        self, oper: str,
-        param_seq: Optional[Sequence[Union[Sequence[Any], Mapping[str, Any]]]] = None,
-    ) -> None:
+        self, query: str,
+        args: Optional[Sequence[Union[Sequence[Any], Dict[str, Any], Any]]] = None,
+    ) -> int:
         """
         Execute SQL code against multiple sets of parameters.
 
+        Queries can use the ``format``-style parameters (``%s``) when using
+        lists of paramters or ``pyformat``-style parameters (``%(key)s``)
+        when using dictionaries of parameters.
+
         Parameters
         ----------
-        oper : str
+        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._cursor is None:
-            raise exceptions.InterfaceError(2048, 'Cursor is closed.')
-
-        self.description = None
-        self.rownumber = None
-
-        is_dataframe = False
-        if isinstance(param_seq, DataFrame):
-            is_dataframe = True
-        else:
-            param_seq = param_seq or [[]]
-
-        try:
-            # NOTE: Just implement using `execute` to cover driver inconsistencies
-            if is_dataframe:
-                for params in param_seq.itertuples(index=False):
-                    self.execute(oper, params)
+        Examples
+        --------
+        >>> cur.executemany('select * from mytable where id < %s',
+        ...                 [[100], [200], [300]])
 
-            elif param_seq[0]:
-                for params in param_seq:
-                    self.execute(oper, params)
-            else:
-                self.execute(oper)
+        >>> cur.executemany('select * from mytable where id < %(max)s',
+        ...                 [dict(max=100), dict(max=100), dict(max=300)])
 
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
+        Returns
+        -------
+        Number of rows affected
 
-        self._set_description()
-        self._update_attrs()
-        self.rownumber = 0
+        """
+        # NOTE: Just implement using `execute` to cover driver inconsistencies
+        if not args:
+            self.execute(query)
+        else:
+            for params in args:
+                self.execute(query, params)
+        return self.rowcount
 
+    @abc.abstractmethod
     def fetchone(self) -> Optional[Result]:
         """
         Fetch a single row from the result set.
 
+        Examples
+        --------
+        >>> while True:
+        ...    row = cur.fetchone()
+        ...    if row is None:
+        ...       break
+        ...    print(row)
+
         Returns
         -------
         tuple
             Values of the returned row if there are rows remaining
 
         """
-        if self._cursor is None:
-            raise exceptions.InterfaceError(2048, 'Cursor is closed.')
-
-        try:
-            out = self._cursor.fetchone()
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
-
-        if out is not None and self.rownumber is not None:
-            self.rownumber += 1
-
-        if out is not None:
-            out = convert_row(tuple(out), self._converters)
-
-        return format_results(
-            self._results_format,
-            self.description or [],
-            out, single=True,
-        )
+        raise NotImplementedError
 
+    @abc.abstractmethod
     def fetchmany(self, size: Optional[int] = None) -> Result:
         """
         Fetch `size` rows from the result.
 
         If `size` is not specified, the `arraysize` attribute is used.
 
+        Examples
+        --------
+        >>> while True:
+        ...    out = cur.fetchmany(100)
+        ...    if not len(out):
+        ...        break
+        ...    for row in out:
+        ...        print(row)
+
         Returns
         -------
         list of tuples
             Values of the returned rows if there are rows remaining
 
         """
-        if self._cursor is None:
-            raise exceptions.InterfaceError(2048, 'Cursor is closed.')
-
-        if size is not None:
-            size = max(int(size), 1)
-        else:
-            size = max(int(self.arraysize), 1)
-
-        try:
-            # This is to get around a bug in mysql.connector. For some reason,
-            # fetchmany(1) returns the same row over and over again.
-            if size == 1:
-                out = [self._cursor.fetchone()]
-            else:
-                # Don't use a keyword parameter for size=. Pyodbc fails with that.
-                out = self._cursor.fetchmany(size)
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
-
-        out = convert_rows(out, self._converters)
-
-        formatted: Result = format_results(
-            self._results_format, self.description or [], out,
-        )
-
-        if self.rownumber is not None:
-            self.rownumber += len(formatted)
-
-        return formatted
+        raise NotImplementedError
 
+    @abc.abstractmethod
     def fetchall(self) -> Result:
         """
         Fetch all rows in the result set.
 
+        Examples
+        --------
+        >>> for row in cur.fetchall():
+        ...     print(row)
+
         Returns
         -------
         list of tuples
@@ -717,29 +628,22 @@ class Cursor(object):
             If there are no rows to return
 
         """
-        if self._cursor is None:
-            raise exceptions.InterfaceError(2048, 'Cursor is closed.')
-
-        try:
-            out = self._cursor.fetchall()
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
-
-        out = convert_rows(out, self._converters)
-
-        formatted: Result = format_results(
-            self._results_format, self.description or [], out,
-        )
-
-        if self.rownumber is not None:
-            self.rownumber += len(formatted)
-
-        return formatted
+        raise NotImplementedError
 
+    @abc.abstractmethod
     def nextset(self) -> Optional[bool]:
         """
         Skip to the next available result set.
 
+        This is used when calling a procedure that returns multiple
+        results sets.
+
+        Note
+        ----
+        The ``nextset`` method must be called until it returns an empty
+        set (i.e., once more than the number of expected result sets).
+        This is to retain compatibility with PyMySQL and MySOLdb.
+
         Returns
         -------
         ``True``
@@ -748,46 +652,19 @@ class Cursor(object):
             If no other result set is available
 
         """
-        if self._cursor is None:
-            raise exceptions.InterfaceError(2048, 'Cursor is closed.')
-
-        self.rownumber = None
-
-        try:
-            out = self._cursor.nextset()
-            self._set_description()
-            if out:
-                self.rownumber = 0
-                return True
-            return False
-
-        except Exception as exc:
-            exc = self._driver.convert_exception(exc)
-            if getattr(exc, 'errno', -1) == 2053:
-                return False
-            self.rownumber = 0
-            return True
+        raise NotImplementedError
 
+    @abc.abstractmethod
     def setinputsizes(self, sizes: Sequence[int]) -> None:
         """Predefine memory areas for parameters."""
-        if self._cursor is None:
-            raise exceptions.InterfaceError(2048, 'Cursor is closed.')
-
-        try:
-            self._cursor.setinputsizes(sizes)
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
+        raise NotImplementedError
 
+    @abc.abstractmethod
     def setoutputsize(self, size: int, column: Optional[str] = None) -> None:
         """Set a column buffer size for fetches of large columns."""
-        if self._cursor is None:
-            raise exceptions.InterfaceError(2048, 'Cursor is closed.')
-
-        try:
-            self._cursor.setoutputsize(size, column)
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
+        raise NotImplementedError
 
+    @abc.abstractmethod
     def scroll(self, value: int, mode: str = 'relative') -> None:
         """
         Scroll the cursor to the position in the result set.
@@ -800,21 +677,7 @@ class Cursor(object):
             Where to move the cursor from: 'relative' or 'absolute'
 
         """
-        if self._cursor is None:
-            raise exceptions.InterfaceError(2048, 'Cursor is closed.')
-
-        value = int(value)
-        try:
-            self._cursor.scroll(value, mode=mode)
-            if self.rownumber is not None:
-                if mode == 'relative':
-                    self.rownumber += value
-                elif mode == 'absolute':
-                    self.rownumber = value
-                else:
-                    raise ValueError(f'Unrecognized scroll mode {mode}')
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
+        raise NotImplementedError
 
     def next(self) -> Optional[Result]:
         """
@@ -830,18 +693,12 @@ class Cursor(object):
         tuple of values
 
         """
-        if self._cursor is None:
+        if not self.is_connected():
             raise exceptions.InterfaceError(2048, 'Cursor is closed.')
-
-        try:
-            out = self.fetchone()
-            if out is None:
-                raise StopIteration
-            return out
-        except StopIteration:
-            raise
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
+        out = self.fetchone()
+        if out is None:
+            raise StopIteration
+        return out
 
     __next__ = next
 
@@ -849,7 +706,7 @@ class Cursor(object):
         """Return result iterator."""
         return self
 
-    def __enter__(self) -> Cursor:
+    def __enter__(self) -> 'Cursor':
         """Enter a context."""
         return self
 
@@ -860,24 +717,22 @@ class Cursor(object):
         """Exit a context."""
         self.close()
 
-    def is_connected(self) -> bool:
-        """
-        Check if the cursor is connected.
-
-        Returns
-        -------
-        bool
-
-        """
-        if self._conn is None:
-            return False
-        return self._conn.is_connected()
-
 
 class ShowResult(Sequence[Any]):
     """
     Simple result object.
 
+    This object is primarily used for displaying results to a
+    terminal or web browser, but it can also be treated like a
+    simple data frame where columns are accessible using either
+    dictionary key-like syntax or attribute syntax.
+
+    Examples
+    --------
+    >>> conn.show.status().Value[10]
+
+    >>> conn.show.status()[10]['Value']
+
     Parameters
     ----------
     *args : Any
@@ -885,10 +740,14 @@ class ShowResult(Sequence[Any]):
     **kwargs : Any
         Keyword parameters to send to underlying list constructor
 
+    See Also
+    --------
+    :attr:`Connection.show`
+
     """
 
     def __init__(self, *args: Any, **kwargs: Any) -> None:
-        self._data: List[Any] = []
+        self._data: List[Dict[str, Any]] = []
         item: Any = None
         for item in list(*args, **kwargs):
             self._data.append(item)
@@ -897,41 +756,69 @@ class ShowResult(Sequence[Any]):
         return self._data[item]
 
     def __getattr__(self, name: str) -> List[Any]:
+        if name.startswith('_ipython'):
+            raise AttributeError(name)
         out = []
         for item in self._data:
-            out.append(getattr(item, name))
+            out.append(item[name])
         return out
 
     def __len__(self) -> int:
         return len(self._data)
 
-    def _repr_pretty_(self, p: Any, cycle: bool) -> None:
-        if cycle:
-            p.text('[...]')
-        else:
-            p.text('[\n')
-            for item in self._data:
-                p.text('    ')
-                p.text(pprint.pformat(item))
-                p.text('\n')
-            p.text(']')
+    def __repr__(self) -> str:
+        if not self._data:
+            return ''
+        return '\n{}\n'.format(self._format_table(self._data))
+
+    @property
+    def columns(self) -> List[str]:
+        """The columns in the result."""
+        if not self._data:
+            return []
+        return list(self._data[0].keys())
+
+    def _format_table(self, rows: Sequence[Dict[str, Any]]) -> str:
+        if not self._data:
+            return ''
+
+        keys = rows[0].keys()
+        lens = [len(x) for x in keys]
+
+        for row in self._data:
+            align = ['<'] * len(keys)
+            for i, k in enumerate(keys):
+                lens[i] = max(lens[i], len(str(row[k])))
+                align[i] = '<' if isinstance(row[k], (bytes, bytearray, str)) else '>'
+
+        fmt = '| %s |' % '|'.join([' {:%s%d} ' % (x, y) for x, y in zip(align, lens)])
+
+        out = []
+        out.append(fmt.format(*keys))
+        out.append('-' * len(out[0]))
+        for row in rows:
+            out.append(fmt.format(*[str(x) for x in row.values()]))
+        return '\n'.join(out)
+
+    def __str__(self) -> str:
+        return self.__repr__()
 
     def _repr_html_(self) -> str:
         if not self._data:
             return ''
         cell_style = 'style="text-align: left; vertical-align: top"'
         out = []
-        out.append('<table>')
+        out.append('<table border="1" class="dataframe">')
         out.append('<thead>')
         out.append('<tr>')
-        for name in self._data[0]._fields:
+        for name in self._data[0].keys():
             out.append(f'<th {cell_style}>{name}</th>')
         out.append('</tr>')
         out.append('</thead>')
         out.append('<tbody>')
         for row in self._data:
             out.append('<tr>')
-            for item in row:
+            for item in row.values():
                 out.append(f'<td {cell_style}>{item}</td>')
             out.append('</tr>')
         out.append('</tbody>')
@@ -940,161 +827,188 @@ class ShowResult(Sequence[Any]):
 
 
 class ShowAccessor(object):
-    """Accessor for ``SHOW`` commands."""
+    """
+    Accessor for ``SHOW`` commands.
 
-    def __init__(self, conn: Connection):
+    See Also
+    --------
+    :attr:`Connection.show`
+
+    """
+
+    def __init__(self, conn: 'Connection'):
         self._conn = conn
 
     def columns(self, table: str, full: bool = False) -> ShowResult:
         """Show the column information for the given table."""
         table = quote_identifier(table)
         if full:
-            return self._query(f'full columns in {table}')
-        return self._query(f'columns in {table}')
+            return self._iquery(f'full columns in {table}')
+        return self._iquery(f'columns in {table}')
 
     def tables(self, extended: bool = False) -> ShowResult:
         """Show tables in the current database."""
         if extended:
-            return self._query('tables extended')
-        return self._query('tables')
+            return self._iquery('tables extended')
+        return self._iquery('tables')
 
     def warnings(self) -> ShowResult:
         """Show warnings."""
-        return self._query('warnings')
+        return self._iquery('warnings')
 
     def errors(self) -> ShowResult:
         """Show errors."""
-        return self._query('errors')
+        return self._iquery('errors')
 
     def databases(self, extended: bool = False) -> ShowResult:
         """Show all databases in the server."""
         if extended:
-            return self._query('databases extended')
-        return self._query('databases')
+            return self._iquery('databases extended')
+        return self._iquery('databases')
 
     def database_status(self) -> ShowResult:
         """Show status of the current database."""
-        return self._query('database status')
+        return self._iquery('database status')
 
     def global_status(self) -> ShowResult:
         """Show global status of the current server."""
-        return self._query('global status')
+        return self._iquery('global status')
 
     def indexes(self, table: str) -> ShowResult:
         """Show all indexes in the given table."""
         table = quote_identifier(table)
-        return self._query('indexes in {table}')
+        return self._iquery(f'indexes in {table}')
 
     def functions(self) -> ShowResult:
         """Show all functions in the current database."""
-        return self._query('functions')
+        return self._iquery('functions')
 
     def partitions(self, extended: bool = False) -> ShowResult:
         """Show partitions in the current database."""
         if extended:
-            return self._query('partitions extended')
-        return self._query('partitions')
+            return self._iquery('partitions extended')
+        return self._iquery('partitions')
 
     def pipelines(self) -> ShowResult:
         """Show all pipelines in the current database."""
-        return self._query('pipelines')
+        return self._iquery('pipelines')
 
-    def plan(self, plan_id: str, json: bool = False) -> ShowResult:
+    def plan(self, plan_id: int, json: bool = False) -> ShowResult:
         """Show the plan for the given plan ID."""
-        plan_id = quote_identifier(plan_id)
+        plan_id = int(plan_id)
         if json:
-            return self._query(f'plan json {plan_id}')
-        return self._query(f'plan {plan_id}')
+            return self._iquery(f'plan json {plan_id}')
+        return self._iquery(f'plan {plan_id}')
 
     def plancache(self) -> ShowResult:
         """Show all query statements compiled and executed."""
-        return self._query('plancache')
+        return self._iquery('plancache')
 
     def processlist(self) -> ShowResult:
         """Show details about currently running threads."""
-        return self._query('processlist')
+        return self._iquery('processlist')
 
     def reproduction(self, outfile: Optional[str] = None) -> ShowResult:
         """Show troubleshooting data for query optimizer and code generation."""
         if outfile:
             outfile = outfile.replace('"', r'\"')
-            return self._query('reproduction into outfile "{outfile}"')
-        return self._query('reproduction')
+            return self._iquery('reproduction into outfile "{outfile}"')
+        return self._iquery('reproduction')
 
     def schemas(self) -> ShowResult:
         """Show schemas in the server."""
-        return self._query('schemas')
+        return self._iquery('schemas')
 
     def session_status(self) -> ShowResult:
         """Show server status information for a session."""
-        return self._query('session status')
+        return self._iquery('session status')
 
     def status(self, extended: bool = False) -> ShowResult:
         """Show server status information."""
         if extended:
-            return self._query('status extended')
-        return self._query('status')
+            return self._iquery('status extended')
+        return self._iquery('status')
 
     def table_status(self) -> ShowResult:
         """Show table status information for the current database."""
-        return self._query('table status')
+        return self._iquery('table status')
 
     def procedures(self) -> ShowResult:
         """Show all procedures in the current database."""
-        return self._query('procedures')
+        return self._iquery('procedures')
 
     def aggregates(self) -> ShowResult:
         """Show all aggregate functions in the current database."""
-        return self._query('aggregates')
+        return self._iquery('aggregates')
 
     def create_aggregate(self, name: str) -> ShowResult:
         """Show the function creation code for the given aggregate function."""
         name = quote_identifier(name)
-        return self._query(f'create aggregate {name}')
+        return self._iquery(f'create aggregate {name}')
 
     def create_function(self, name: str) -> ShowResult:
         """Show the function creation code for the given function."""
         name = quote_identifier(name)
-        return self._query(f'create function {name}')
+        return self._iquery(f'create function {name}')
 
     def create_pipeline(self, name: str, extended: bool = False) -> ShowResult:
         """Show the pipeline creation code for the given pipeline."""
         name = quote_identifier(name)
         if extended:
-            return self._query(f'create pipeline {name} extended')
-        return self._query(f'create pipeline {name}')
+            return self._iquery(f'create pipeline {name} extended')
+        return self._iquery(f'create pipeline {name}')
 
     def create_table(self, name: str) -> ShowResult:
         """Show the table creation code for the given table."""
         name = quote_identifier(name)
-        return self._query(f'create table {name}')
+        return self._iquery(f'create table {name}')
 
     def create_view(self, name: str) -> ShowResult:
         """Show the view creation code for the given view."""
         name = quote_identifier(name)
-        return self._query(f'create view {name}')
-
-    def _query(self, qtype: str) -> ShowResult:
+        return self._iquery(f'create view {name}')
+
+#   def grants(
+#       self,
+#       user: Optional[str] = None,
+#       hostname: Optional[str] = None,
+#       role: Optional[str] = None
+#   ) -> ShowResult:
+#       """Show the privileges for the given user or role."""
+#       if user:
+#           if not re.match(r'^[\w+-_]+$', user):
+#               raise ValueError(f'User name is not valid: {user}')
+#           if hostname and not re.match(r'^[\w+-_\.]+$', hostname):
+#               raise ValueError(f'Hostname is not valid: {hostname}')
+#           if hostname:
+#               return self._iquery(f"grants for '{user}@{hostname}'")
+#           return self._iquery(f"grants for '{user}'")
+#       if role:
+#           if not re.match(r'^[\w+-_]+$', role):
+#               raise ValueError(f'Role is not valid: {role}')
+#           return self._iquery(f"grants for role '{role}'")
+#       return self._iquery('grants')
+
+    def _iquery(self, qtype: str) -> ShowResult:
         """Query the given object type."""
-        with self._conn._i_cursor() as cur:
-            cur.execute(f'show {qtype}')
-            out = []
-            if cur.description:
-                names = [under2camel(str(x[0]).replace(' ', '')) for x in cur.description]
-                names[0] = 'Name'
-                item_type = namedtuple('Row', names)  # type: ignore
-                for item in cur.fetchall():
-                    out.append(item_type(*item))
-            return ShowResult(out)
-
-
-class Connection(object):
+        out = self._conn._iquery(f'show {qtype}')
+        for i, row in enumerate(out):
+            new_row = {}
+            for j, (k, v) in enumerate(row.items()):
+                if j == 0:
+                    k = 'Name'
+                new_row[under2camel(k)] = v
+            out[i] = new_row
+        return ShowResult(out)
+
+
+class Connection(metaclass=abc.ABCMeta):
     """
     SingleStoreDB connection.
 
     Instances of this object are typically created through the
     :func:`singlestoredb.connect` function rather than creating them directly.
-    See the :func:`connect` function for parameter definitions.
+    See the :func:`singlestoredb.connect` function for parameter definitions.
 
     See Also
     --------
@@ -1113,20 +1027,25 @@ class Connection(object):
     ProgrammingError = exceptions.ProgrammingError
     NotSupportedError = exceptions.NotSupportedError
 
+    #: Read-only DB-API parameter style
+    paramstyle = 'pyformat'
+
+    # Must be set by subclass
+    driver = ''
+
+    # Populated when first needed
+    _map_param_converter: Optional[sqlparams.SQLParams] = None
+    _positional_param_converter: Optional[sqlparams.SQLParams] = None
+
     def __init__(self, **kwargs: Any):
         """Call :func:`singlestoredb.connect` instead."""
-        self._conn: Optional[Any] = None
+        self.connection_params: Dict[str, Any] = kwargs
         self.errorhandler = None
-        self.connection_params: Dict[str, Any] = build_params(**kwargs)
-
-        #: Query results format ('tuple', 'namedtuple', 'dict', 'dataframe')
-        self.results_format = self.connection_params.pop(
-            'results_format',
-            get_option('results.format'),
-        )
+        self._results_type: str = kwargs.get('results_type', None) or 'tuples'
 
         #: Session encoding
-        self.encoding = self.connection_params.get('charset', 'utf-8').replace('mb4', '')
+        self.encoding = self.connection_params.get('charset', None) or 'utf-8'
+        self.encoding = self.encoding.replace('mb4', '')
 
         # Handle various authentication types
         credential_type = self.connection_params.get('credential_type', None)
@@ -1136,14 +1055,6 @@ class Connection(object):
             self.connection_params['password'] = str(info)
             self.connection_params['credential_type'] = auth.JWT
 
-        drv_name = re.sub(r'^\w+\+', r'', self.connection_params['driver']).lower()
-        self._driver = drivers.get_driver(drv_name, self.connection_params)
-
-        try:
-            self._conn = self._driver.connect()
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
-
         #: Attribute-like access to global server variables
         self.globals = VariableAccessor(self, 'global')
 
@@ -1162,41 +1073,93 @@ class Connection(object):
         #: Attribute-like access to all cluster server variables
         self.cluster_vars = VariableAccessor(self, 'cluster')
 
+        # For backwards compatibility with SQLAlchemy package
+        self._driver = Driver(self.driver)
+
+        # Output decoders
+        self.decoders: Dict[int, Callable[[Any], Any]] = {}
+
+    @classmethod
+    def _convert_params(
+        cls, oper: str,
+        params: Optional[Union[Sequence[Any], Dict[str, Any], Any]],
+    ) -> Tuple[Any, ...]:
+        """Convert query to correct parameter format."""
+        if params:
+
+            if cls._map_param_converter is None:
+                cls._map_param_converter = sqlparams.SQLParams(
+                    map_paramstyle, cls.paramstyle, escape_char=True,
+                )
+
+            if cls._positional_param_converter is None:
+                cls._positional_param_converter = sqlparams.SQLParams(
+                    positional_paramstyle, cls.paramstyle, escape_char=True,
+                )
+
+            is_sequence = isinstance(params, Sequence) \
+                and not isinstance(params, str) \
+                and not isinstance(params, bytes)
+            is_mapping = isinstance(params, Mapping)
+
+            param_converter = cls._map_param_converter \
+                if is_mapping else cls._positional_param_converter
+
+            if not is_sequence and not is_mapping:
+                params = [params]
+
+            return param_converter.format(oper, params)
+
+        return (oper, None)
+
     def autocommit(self, value: bool = True) -> None:
         """Set autocommit mode."""
-        if self._conn is None:
-            raise exceptions.InterfaceError(2048, 'Connection is closed.')
         self.locals.autocommit = bool(value)
 
+    @abc.abstractmethod
+    def connect(self) -> 'Connection':
+        """Connect to the server."""
+        raise NotImplementedError
+
+    def _iquery(
+        self, oper: str,
+        params: Optional[Union[Sequence[Any], Dict[str, Any]]] = None,
+        fix_names: bool = True,
+    ) -> List[Dict[str, Any]]:
+        """Return the results of a query as a list of dicts (for internal use)."""
+        with self.cursor() as cur:
+            cur.execute(oper, params)
+            if not re.match(r'^\s*(select|show|call|echo)\s+', oper, flags=re.I):
+                return []
+            out = list(cur.fetchall())
+            if not out:
+                return []
+            if isinstance(out, DataFrame):
+                out = out.to_dict(orient='records')
+            elif isinstance(out[0], (tuple, list)):
+                if cur.description:
+                    names = [x[0] for x in cur.description]
+                    if fix_names:
+                        names = [under2camel(str(x).replace(' ', '')) for x in names]
+                    out = [{k: v for k, v in zip(names, row)} for row in out]
+            return out
+
+    @abc.abstractmethod
     def close(self) -> None:
         """Close the database connection."""
-        if self._conn is None:
-            return None
-        try:
-            self._conn.close()
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
-        finally:
-            self._conn = None
+        raise NotImplementedError
 
+    @abc.abstractmethod
     def commit(self) -> None:
         """Commit the pending transaction."""
-        if self._conn is None:
-            raise exceptions.InterfaceError(2048, 'Connection is closed.')
-        try:
-            self._conn.commit()
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
+        raise NotImplementedError
 
+    @abc.abstractmethod
     def rollback(self) -> None:
         """Rollback the pending transaction."""
-        if self._conn is None:
-            raise exceptions.InterfaceError(2048, 'Connection is closed.')
-        try:
-            self._conn.rollback()
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
+        raise NotImplementedError
 
+    @abc.abstractmethod
     def cursor(self) -> Cursor:
         """
         Create a new cursor object.
@@ -1210,48 +1173,14 @@ class Connection(object):
         :class:`Cursor`
 
         """
-        if self._conn is None:
-            raise exceptions.InterfaceError(2048, 'Connection is closed.')
-        try:
-            cur = self._conn.cursor()
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
-        return Cursor(self, cur, self._driver)
-
-    def _i_cursor(self) -> Cursor:
-        """
-        Create a cursor for internal use.
-
-        Internal cursors always return tuples in results.
-        These are used to ensure that methods that query the database
-        have a consistent results structure regardless of the
-        `results.format` option.
-
-        Returns
-        -------
-        Cursor
-
-        """
-        out = self.cursor()
-        out._results_format = 'tuple'
-        return out
-
-    @property
-    def messages(self) -> Sequence[tuple[int, str]]:
-        """
-        Return messages generated by the connection.
-
-        Returns
-        -------
-        list of tuples
-            Each tuple contains an int code and a message
+        raise NotImplementedError
 
-        """
-        if self._conn is None:
-            raise exceptions.InterfaceError(2048, 'Connection is closed.')
-        return self._conn.messages
+    @abc.abstractproperty
+    def messages(self) -> List[Tuple[int, str]]:
+        """Messages generated during the connection."""
+        raise NotImplementedError
 
-    def __enter__(self) -> Connection:
+    def __enter__(self) -> 'Connection':
         """Enter a context."""
         return self
 
@@ -1262,6 +1191,7 @@ class Connection(object):
         """Exit a context."""
         self.close()
 
+    @abc.abstractmethod
     def is_connected(self) -> bool:
         """
         Determine if the database is still connected.
@@ -1271,12 +1201,7 @@ class Connection(object):
         bool
 
         """
-        if self._conn is None:
-            return False
-        try:
-            return self._driver.is_connected(self._conn)
-        except Exception as exc:
-            raise self._driver.convert_exception(exc)
+        raise NotImplementedError
 
     def enable_data_api(self, port: Optional[int] = None) -> int:
         """
@@ -1302,14 +1227,11 @@ class Connection(object):
             port number of the HTTP server
 
         """
-        if self._conn is None:
-            raise exceptions.InterfaceError(2048, 'Connection is closed.')
-        with self._i_cursor() as cur:
-            if port is not None:
-                self.globals.http_proxy_port = int(port)
-            self.globals.http_api = True
-            cur.execute('restart proxy')
-            return int(self.globals.http_proxy_port)
+        if port is not None:
+            self.globals.http_proxy_port = int(port)
+        self.globals.http_api = True
+        self._iquery('restart proxy')
+        return int(self.globals.http_proxy_port)
 
     enable_http_api = enable_data_api
 
@@ -1322,11 +1244,8 @@ class Connection(object):
         :meth:`enable_data_api`
 
         """
-        if self._conn is None:
-            raise exceptions.InterfaceError(2048, 'Connection is closed.')
-        with self._i_cursor() as cur:
-            self.globals.http_api = False
-            cur.execute('restart proxy')
+        self.globals.http_api = False
+        self._iquery('restart proxy')
 
     disable_http_api = disable_data_api
 
@@ -1347,14 +1266,25 @@ def connect(
     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,
-    odbc_driver: Optional[str] = None, charset: Optional[str] = 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,
-    converters: Optional[Dict[int, Callable[..., Any]]] = None,
-    results_format: Optional[str] = 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:
     """
     Return a SingleStoreDB connection.
@@ -1364,7 +1294,7 @@ def connect(
     host : str, optional
         Hostname, IP address, or URL that describes the connection.
         The scheme or protocol defines which database connector to use.
-        By default, the ``pymysql`` scheme is used. To connect to the
+        By default, the ``mysql`` scheme is used. To connect to the
         HTTP API, the scheme can be set to ``http`` or ``https``. The username,
         password, host, and port are specified as in a standard URL. The path
         indicates the database name. The overall form of the URL is:
@@ -1384,8 +1314,6 @@ def connect(
         Use the connector in pure Python mode
     local_infile : bool, optional
         Allow local file uploads
-    odbc_driver : str, optional
-        Name of the ODBC driver to use for ODBC connections
     charset : str, optional
         Character set for string values
     ssl_key : str, optional
@@ -1398,14 +1326,41 @@ def connect(
         Sets the SSL cipher list
     ssl_disabled : bool, optional
         Disable SSL usage
-    converters : dict[int, Callable], optional
+    ssl_verify_cert : bool, optional
+        Verify the server's certificate. This is automatically enabled if
+        ``ssl_ca`` is also specified.
+    ssl_verify_identity : bool, optional
+        Verify the server's identity
+    conv : dict[int, Callable], optional
         Dictionary of data conversion functions
-    results_format : str, optional
-        Format of query results: tuple, namedtuple, dict, or dataframe
     credential_type : str, optional
         Type of authentication to use: auth.PASSWORD, auth.JWT, or auth.BROWSER_SSO
     autocommit : bool, optional
         Enable autocommits
+    results_type : str, optional
+        The form of the query results: tuples, namedtuples, dicts
+    results_format : str, optional
+        Deprecated. This option has been renamed to results_type.
+    program_name : str, optional
+        Name of the program
+    conn_attrs : dict, optional
+        Additional connection attributes for telemetry. Example:
+        {'program_version': "1.0.2", "_connector_name": "dbt connector"}
+    multi_statements: bool, optional
+        Should multiple statements be allowed within a single query?
+    connect_timeout : int, optional
+        The timeout for connecting to the database in seconds.
+        (default: 10, min: 1, max: 31536000)
+    nan_as_null : bool, optional
+        Should NaN values be treated as NULLs when used in parameter
+        substitutions including uploaded data?
+    inf_as_null : bool, optional
+        Should Inf values be treated as NULLs when used in parameter
+        substitutions including uploaded data?
+    encoding_errors : str, optional
+        The error handler name for value decoding errors
+    track_env : bool, optional
+        Should the connection track the SINGLESTOREDB_URL environment variable?
 
     Examples
     --------
@@ -1461,4 +1416,15 @@ def connect(
     :class:`Connection`
 
     """
-    return Connection(**dict(locals()))
+    params = build_params(**dict(locals()))
+    driver = params.get('driver', 'mysql')
+
+    if not driver or driver == 'mysql':
+        from .mysql.connection import Connection  # type: ignore
+        return Connection(**params)
+
+    if driver in ['http', 'https']:
+        from .http.connection import Connection
+        return Connection(**params)
+
+    raise ValueError(f'Unrecognized protocol: {driver}')