databricks-sql-connector 0.9.1__py3-none-any.whl

databricks/sql/common.py

@@ -0,0 +1,240 @@
+"""Package private common utilities. Do not use directly.
+
+Many docstrings in this file are based on PEP-249, which is in the public domain.
+"""
+
+from __future__ import absolute_import
+from __future__ import unicode_literals
+from builtins import bytes
+from builtins import int
+from builtins import object
+from builtins import str
+from past.builtins import basestring
+from databricks.sql import exc
+import abc
+import collections
+import time
+import datetime
+from future.utils import with_metaclass
+from itertools import islice
+
+
+class DBAPICursor(with_metaclass(abc.ABCMeta, object)):
+    """Base class for some common DB-API logic"""
+
+    _STATE_NONE = 0
+    _STATE_RUNNING = 1
+    _STATE_FINISHED = 2
+
+    def __init__(self, poll_interval=1):
+        self._poll_interval = poll_interval
+        self._reset_state()
+        self.lastrowid = None
+
+    def _reset_state(self):
+        """Reset state about the previous query in preparation for running another query"""
+        # State to return as part of DB-API
+        self._rownumber = 0
+
+        # Internal helper state
+        self._state = self._STATE_NONE
+        self._data = collections.deque()
+        self._columns = None
+
+    def _fetch_while(self, fn):
+        while fn():
+            self._fetch_more()
+            if fn():
+                time.sleep(self._poll_interval)
+
+    @abc.abstractproperty
+    def description(self):
+        raise NotImplementedError  # pragma: no cover
+
+    def close(self):
+        """By default, do nothing"""
+        pass
+
+    @abc.abstractmethod
+    def _fetch_more(self):
+        """Get more results, append it to ``self._data``, and update ``self._state``."""
+        raise NotImplementedError  # pragma: no cover
+
+    @property
+    def rowcount(self):
+        """By default, return -1 to indicate that this is not supported."""
+        return -1
+
+    @abc.abstractmethod
+    def execute(self, operation, parameters=None):
+        """Prepare and execute a database operation (query or command).
+
+        Parameters may be provided as sequence or mapping and will be bound to variables in the
+        operation. Variables are specified in a database-specific notation (see the module's
+        ``paramstyle`` attribute for details).
+
+        Return values are not defined.
+        """
+        raise NotImplementedError  # pragma: no cover
+
+    def executemany(self, operation, seq_of_parameters):
+        """Prepare a database operation (query or command) and then execute it against all parameter
+        sequences or mappings found in the sequence ``seq_of_parameters``.
+
+        Only the final result set is retained.
+
+        Return values are not defined.
+        """
+        for parameters in seq_of_parameters[:-1]:
+            self.execute(operation, parameters)
+            while self._state != self._STATE_FINISHED:
+                self._fetch_more()
+        if seq_of_parameters:
+            self.execute(operation, seq_of_parameters[-1])
+
+    def fetchone(self):
+        """Fetch the next row of a query result set, returning a single sequence, or ``None`` when
+        no more data is available.
+
+        An :py:class:`~databricks.sql.exc.Error` (or subclass) exception is raised if the previous call to
+        :py:meth:`execute` did not produce any result set or no call was issued yet.
+        """
+        if self._state == self._STATE_NONE:
+            raise exc.ProgrammingError("No query yet")
+
+        # Sleep until we're done or we have some data to return
+        self._fetch_while(lambda: not self._data and self._state != self._STATE_FINISHED)
+
+        if not self._data:
+            return None
+        else:
+            self._rownumber += 1
+            return self._data.popleft()
+
+    def fetchmany(self, size=None):
+        """Fetch the next set of rows of a query result, returning a sequence of sequences (e.g. a
+        list of tuples). An empty sequence is returned when no more rows are available.
+
+        The number of rows to fetch per call is specified by the parameter. If it is not given, the
+        cursor's arraysize determines the number of rows to be fetched. The method should try to
+        fetch as many rows as indicated by the size parameter. If this is not possible due to the
+        specified number of rows not being available, fewer rows may be returned.
+
+        An :py:class:`~databricks.exc.Error` (or subclass) exception is raised if the previous call to
+        :py:meth:`execute` did not produce any result set or no call was issued yet.
+        """
+        if size is None:
+            size = self.arraysize
+        return list(islice(iter(self.fetchone, None), size))
+
+    def fetchall(self):
+        """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences
+        (e.g. a list of tuples).
+
+        An :py:class:`~databricks.exc.Error` (or subclass) exception is raised if the previous call to
+        :py:meth:`execute` did not produce any result set or no call was issued yet.
+        """
+        return list(iter(self.fetchone, None))
+
+    @property
+    def arraysize(self):
+        """This read/write attribute specifies the number of rows to fetch at a time with
+        :py:meth:`fetchmany`. It defaults to 1 meaning to fetch a single row at a time.
+        """
+        return self._arraysize
+
+    @arraysize.setter
+    def arraysize(self, value):
+        self._arraysize = value
+
+    def setinputsizes(self, sizes):
+        """Does nothing by default"""
+        pass
+
+    def setoutputsize(self, size, column=None):
+        """Does nothing by default"""
+        pass
+
+    #
+    # Optional DB API Extensions
+    #
+
+    @property
+    def rownumber(self):
+        """This read-only attribute should provide the current 0-based index of the cursor in the
+        result set.
+
+        The index can be seen as index of the cursor in a sequence (the result set). The next fetch
+        operation will fetch the row indexed by ``rownumber`` in that sequence.
+        """
+        return self._rownumber
+
+    def __next__(self):
+        """Return the next row from the currently executing SQL statement using the same semantics
+        as :py:meth:`fetchone`. A ``StopIteration`` exception is raised when the result set is
+        exhausted.
+        """
+        one = self.fetchone()
+        if one is None:
+            raise StopIteration
+        else:
+            return one
+
+    next = __next__
+
+    def __iter__(self):
+        """Return self to make cursors compatible to the iteration protocol."""
+        return self
+
+class ParamEscaper(object):
+    _DATE_FORMAT = "%Y-%m-%d"
+    _TIME_FORMAT = "%H:%M:%S.%f"
+    _DATETIME_FORMAT = "{} {}".format(_DATE_FORMAT, _TIME_FORMAT)
+
+    def escape_args(self, parameters):
+        if isinstance(parameters, dict):
+            return {k: self.escape_item(v) for k, v in parameters.items()}
+        elif isinstance(parameters, (list, tuple)):
+            return tuple(self.escape_item(x) for x in parameters)
+        else:
+            raise exc.ProgrammingError("Unsupported param format: {}".format(parameters))
+
+    def escape_number(self, item):
+        return item
+
+    def escape_string(self, item):
+        # Need to decode UTF-8 because of old sqlalchemy.
+        # Newer SQLAlchemy checks dialect.supports_unicode_binds before encoding Unicode strings
+        # as byte strings. The old version always encodes Unicode as byte strings, which breaks
+        # string formatting here.
+        if isinstance(item, bytes):
+            item = item.decode('utf-8')
+        # This is good enough when backslashes are literal, newlines are just followed, and the way
+        # to escape a single quote is to put two single quotes.
+        # (i.e. only special character is single quote)
+        return "'{}'".format(item.replace("'", "''"))
+
+    def escape_sequence(self, item):
+        l = map(str, map(self.escape_item, item))
+        return '(' + ','.join(l) + ')'
+
+    def escape_datetime(self, item, format, cutoff=0):
+        dt_str = item.strftime(format)
+        formatted = dt_str[:-cutoff] if cutoff and format.endswith(".%f") else dt_str
+        return "'{}'".format(formatted)
+
+    def escape_item(self, item):
+        if item is None:
+            return 'NULL'
+        elif isinstance(item, (int, float)):
+            return self.escape_number(item)
+        elif isinstance(item, basestring):
+            return self.escape_string(item)
+        elif isinstance(item, collections.Iterable):
+            return self.escape_sequence(item)
+        elif isinstance(item, datetime.datetime):
+            return self.escape_datetime(item, self._DATETIME_FORMAT)
+        elif isinstance(item, datetime.date):
+            return self.escape_datetime(item, self._DATE_FORMAT)
+        else:
+            raise exc.ProgrammingError("Unsupported object {}".format(item))

databricks/sql/dbapi.py

@@ -0,0 +1,36 @@
+import datetime
+
+#
+# PEP 249 module globals
+#
+apilevel = '2.0'
+threadsafety = 1  # Threads may share the module, but not connections.
+paramstyle = 'pyformat'  # Python extended format codes, e.g. ...WHERE name=%(name)s
+
+#
+# Type Objects and Constructors
+#
+
+class DBAPITypeObject(object):
+    def __init__(self, *values):
+        self.values = values
+
+    def __eq__(self, other):
+        return other in self.values
+
+STRING = DBAPITypeObject('string')
+BINARY = DBAPITypeObject('binary')
+NUMBER = DBAPITypeObject('boolean', 'tinyint', 'smallint', 'int', 'bigint',
+                         'float', 'double', 'decimal')
+DATETIME = DBAPITypeObject('timestamp')
+DATE = DBAPITypeObject('date')
+ROWID = DBAPITypeObject()
+
+Date = datetime.date
+Timestamp = datetime.datetime
+
+def DateFromTicks(ticks):
+    return Date(*time.localtime(ticks)[:3])
+
+def TimestampFromTicks(ticks):
+    return Timestamp(*time.localtime(ticks)[:6])

databricks/sql/exc.py

@@ -0,0 +1,72 @@
+"""
+Package private common utilities. Do not use directly.
+"""
+from __future__ import absolute_import
+from __future__ import unicode_literals
+
+__all__ = [
+    'Error', 'Warning', 'InterfaceError', 'DatabaseError', 'InternalError', 'OperationalError',
+    'ProgrammingError', 'DataError', 'NotSupportedError',
+]
+
+
+class Error(Exception):
+    """Exception that is the base class of all other error exceptions.
+
+    You can use this to catch all errors with one single except statement.
+    """
+    pass
+
+
+class Warning(Exception):
+    """Exception raised for important warnings like data truncations while inserting, etc."""
+    pass
+
+
+class InterfaceError(Error):
+    """Exception raised for errors that are related to the database interface rather than the
+    database itself.
+    """
+    pass
+
+
+class DatabaseError(Error):
+    """Exception raised for errors that are related to the database."""
+    pass
+
+
+class InternalError(DatabaseError):
+    """Exception raised when the database encounters an internal error, e.g. the cursor is not valid
+    anymore, the transaction is out of sync, etc."""
+    pass
+
+
+class OperationalError(DatabaseError):
+    """Exception raised for errors that are related to the database's operation and not necessarily
+    under the control of the programmer, e.g. an unexpected disconnect occurs, the data source name
+    is not found, a transaction could not be processed, a memory allocation error occurred during
+    processing, etc.
+    """
+    pass
+
+
+class ProgrammingError(DatabaseError):
+    """Exception raised for programming errors, e.g. table not found or already exists, syntax error
+    in the SQL statement, wrong number of parameters specified, etc.
+    """
+    pass
+
+
+class DataError(DatabaseError):
+    """Exception raised for errors that are due to problems with the processed data like division by
+    zero, numeric value out of range, etc.
+    """
+    pass
+
+
+class NotSupportedError(DatabaseError):
+    """Exception raised in case a method or database API was used which is not supported by the
+    database, e.g. requesting a ``.rollback()`` on a connection that does not support transaction or
+    has transactions turned off.
+    """
+    pass

databricks_sql_connector-0.9.1.dist-info/LICENSE

@@ -0,0 +1,13 @@
+Copyright 2021-present Databricks Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.

databricks_sql_connector-0.9.1.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: databricks-sql-connector
+Version: 0.9.1
+Summary: Databricks SQL Connector for Python
+Home-page: https://databricks.com
+Author: Databricks
+Author-email: feedback@databricks.com
+License: http://www.apache.org/licenses/LICENSE-2.0
+Platform: UNKNOWN
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Database :: Front-Ends
+Description-Content-Type: text/markdown
+License-File: LICENSE
+License-File: NOTICE
+Requires-Dist: future
+Requires-Dist: python-dateutil
+Requires-Dist: thrift (>=0.10.0)
+
+# Databricks SQL Connector for Python
+
+**Status: Public Preview**
+
+This library is currently shared as [Public Preview](https://docs.databricks.com/release-notes/release-types.html). Documentation can be found here: [Databricks SQL Connector for Python
+](https://docs.databricks.com/dev-tools/python-sql-connector.html).
+
+## About
+
+The Databricks SQL Connector is a Python library that allows you to use Python code to run
+SQL commands on Databricks clusters and Databricks SQL endpoints.
+This library follows [PEP 249 -- Python Database API Specification v2.0](https://www.python.org/dev/peps/pep-0249/).
+
+## Quickstart
+
+Install the library with `pip install databricks-sql-connector`
+
+Example usage:
+
+```
+from databricks import sql
+
+connection = sql.connect(
+  server_hostname='<server-hostname>',
+  http_path='<http-path>',
+  access_token='<personal-access-token>')
+
+cursor = connection.cursor()
+
+cursor.execute('SELECT * FROM RANGE(10)')
+result = cursor.fetchall()
+for row in result:
+  print(row)
+
+connection.close()
+```
+
+Where:
+- `<server-hostname>` is the Databricks instance host name.
+- `<http-path>` is the HTTP Path either to a Databricks SQL endpoint (e.g. /sql/1.0/endpoints/1234567890abcdef),
+   or to a Databricks Runtime interactive cluster (e.g. /sql/protocolv1/o/1234567890123456/1234-123456-slid123)
+- `<personal-access-token>` is a HTTP Bearer access token, e.g. a Databricks Personal Access Token.
+
+For more information, see [Databricks documentation](https://docs.databricks.com/dev-tools/python-sql-connector.html).
+
+

databricks_sql_connector-0.9.1.dist-info/NOTICE

@@ -0,0 +1,23 @@
+databricks-sql-connector
+Copyright 2021-present Databricks, Inc.
+All Rights Reserved
+
+This product is subject to the included LICENSE file and 
+includes source code derived from software mentioned below.
+
+---
+https://github.com/dropbox/PyHive
+Copyright (c) 2014 Dropbox, Inc.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.LICENSE file containing the Databricks license
+---

databricks_sql_connector-0.9.1.dist-info/RECORD

@@ -0,0 +1,16 @@
+databricks/__init__.py,sha256=jv2YF__bseklT3OWEzlqJ5qE24c4aWd5F4r0TTjOrWQ,65
+databricks/sql/__init__.py,sha256=RFKD6i1HXjCPPeYXXxjCIO8IrP_A4a2D3WMML2beRM8,1037
+databricks/sql/client.py,sha256=BFpeTRB-m8UE-vFwm-xuGlDP49FQ1RMsooWxH7CJz70,17719
+databricks/sql/common.py,sha256=u5NY2miRwr1fkYNM7CeXM7wo8VB_8x0silDm96OCIXo,8803
+databricks/sql/dbapi.py,sha256=bGKQnKo0TM2Eo7EoU3V-ihn2BtN5MGkcjFq5uj6FMyY,919
+databricks/sql/exc.py,sha256=syjd3bTnNW9gSIX9XA0xrc23mpB97XKXHE7SV2witIY,2196
+databricks/sql/TCLIService/TCLIService.py,sha256=dSW76LC_0GILt2lUjjqpOtq4jTLi7C4qg-Dc9fVo-vY,131364
+databricks/sql/TCLIService/__init__.py,sha256=XERxa3ZbrWjXGs8DuVmNGw8jth4LsnQPJnAGCG3PacU,49
+databricks/sql/TCLIService/constants.py,sha256=iTFnQWnw4GDxZycJRLDGKGCvfjT3CiuCfhnU4Bynvws,1087
+databricks/sql/TCLIService/ttypes.py,sha256=iMrIfTL_wPCrcoNEwguUvISiz3ZWDC4nDZ1NLWoZzvU,263044
+databricks_sql_connector-0.9.1.dist-info/LICENSE,sha256=vu00SutTcQDyMHQv91CyBo28hp7PuGqZvVmdyclqEbE,562
+databricks_sql_connector-0.9.1.dist-info/METADATA,sha256=B2NUGRkCrX12v-4s7cqDQWgYjWAsO8YdRm3o5n_DR_U,2182
+databricks_sql_connector-0.9.1.dist-info/NOTICE,sha256=i-8Gh88vPGOFP7FF7yVo4bOXJeaMbCZZ6qZJ7EXXhqI,851
+databricks_sql_connector-0.9.1.dist-info/WHEEL,sha256=ewwEueio1C2XeHTvT17n8dZUJgOvyCWCt0WVNLClP9o,92
+databricks_sql_connector-0.9.1.dist-info/top_level.txt,sha256=7kRdatoSgU0EUurRQJ_3F1Nv4EOSHWAr6ng25tJOJKU,11
+databricks_sql_connector-0.9.1.dist-info/RECORD,,

databricks_sql_connector-0.9.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.37.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

databricks_sql_connector-0.9.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+databricks