databend-sqlalchemy 0.3.2__tar.gz → 0.4.0__tar.gz

{databend_sqlalchemy-0.3.2 → databend_sqlalchemy-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: databend_sqlalchemy
-Version: 0.3.2
+Version: 0.4.0
 Summary: Sqlalchemy adapter for Databend
 Home-page: https://github.com/datafuselabs/databend-sqlalchemy
 Author: Databend Cloud
@@ -19,7 +19,7 @@ Classifier: Programming Language :: Python :: 3.10
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: databend_py>=0.4.9
+Requires-Dist: databend_py>=0.5.0
 Requires-Dist: sqlalchemy<2.0,>1.3.21
 Provides-Extra: dev
 Requires-Dist: devtools==0.7.0; extra == "dev"
@@ -51,14 +51,14 @@ The DSN format is similar to that of regular Postgres::
         from sqlalchemy import create_engine, text
         from sqlalchemy.engine.base import Connection, Engine
         engine = create_engine(
-            f"databend://{username}:{password}@{host_port_name}/{database_name}?secure=false"
+            f"databend://{username}:{password}@{host_port_name}/{database_name}?sslmode=disable"
         )
         connection = engine.connect()
         result = connection.execute(text("SELECT 1"))
         assert len(result.fetchall()) == 1
 
         import connector
-        cursor = connector.connect('http://root:@localhost:8081').cursor()
+        cursor = connector.connect('databend://root:@localhost:8000?sslmode=disable').cursor()
         cursor.execute('SELECT * FROM test')
         # print(cursor.fetchone())
         # print(cursor.fetchall())

{databend_sqlalchemy-0.3.2 → databend_sqlalchemy-0.4.0}/README.rst

@@ -18,14 +18,14 @@ The DSN format is similar to that of regular Postgres::
         from sqlalchemy import create_engine, text
         from sqlalchemy.engine.base import Connection, Engine
         engine = create_engine(
-            f"databend://{username}:{password}@{host_port_name}/{database_name}?secure=false"
+            f"databend://{username}:{password}@{host_port_name}/{database_name}?sslmode=disable"
         )
         connection = engine.connect()
         result = connection.execute(text("SELECT 1"))
         assert len(result.fetchall()) == 1
 
         import connector
-        cursor = connector.connect('http://root:@localhost:8081').cursor()
+        cursor = connector.connect('databend://root:@localhost:8000?sslmode=disable').cursor()
         cursor.execute('SELECT * FROM test')
         # print(cursor.fetchone())
         # print(cursor.fetchall())

databend_sqlalchemy-0.4.0/databend_sqlalchemy/__init__.py

@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+
+
+VERSION = (0, 4, 0)
+__version__ = ".".join(str(x) for x in VERSION)

{databend_sqlalchemy-0.3.2 → databend_sqlalchemy-0.4.0}/databend_sqlalchemy/connector.py

@@ -4,14 +4,12 @@
 #
 # Many docstrings in this file are based on the PEP, which is in the public domain.
 
-from __future__ import absolute_import
-from __future__ import unicode_literals
 import re
 import uuid
 from datetime import datetime
 from databend_sqlalchemy.errors import ServerException, NotSupportedError
 
-from databend_py import Client
+from databend_py import BlockingDatabendClient
 
 # PEP 249 module globals
 apilevel = "2.0"
@@ -96,24 +94,22 @@ def connect(*args, **kwargs):
     return Connection(*args, **kwargs)
 
 
-class Connection(Client):
+class Connection:
     """
     These objects are small stateless factories for cursors, which do all the real work.
     """
 
-    def __init__(self, db_url="http://root:@localhost:8081"):
-        super(Connection, self).__init__(db_url)
-        self.db_url = db_url
-        self.client = Client.from_url(db_url)
+    def __init__(self, dsn="databend://root:@localhost:8000/?sslmode=disable"):
+        self.client = BlockingDatabendClient(dsn)
 
     def close(self):
-        self.client.disconnect()
+        pass
 
     def commit(self):
         pass
 
     def cursor(self):
-        return Cursor(self)
+        return Cursor(self.client.get_conn())
 
     def rollback(self):
         raise NotSupportedError("Transactions are not supported")  # pragma: no cover
@@ -131,8 +127,8 @@ class Cursor(object):
     _STATE_RUNNING = "Running"
     _STATE_SUCCEEDED = "Succeeded"
 
-    def __init__(self, connector):
-        self._db = connector.client
+    def __init__(self, conn):
+        self._db = conn
         self._reset_state()
 
     def _reset_state(self):
@@ -141,7 +137,7 @@ class Cursor(object):
         self._rownumber = 0
         # Internal helper state
         self._state = self._STATE_NONE
-        self._data = None
+        self._rows = None
         self._columns = None
 
     @property
@@ -183,10 +179,16 @@ class Cursor(object):
         self._uuid = uuid.uuid1()
 
         if is_response:
-            column_types, response = self._db.execute(
-                operation, parameters, with_column_types=True
-            )
-            self._process_response(column_types, response)
+            rows = self._db.query_iter(operation)
+            schema = rows.schema()
+            columns = []
+            for field in schema.fields():
+                columns.append((field.name, field.data_type))
+            if self._state != self._STATE_RUNNING:
+                raise Exception("Should be running if processing response")
+            self._rows = rows
+            self._columns = columns
+            self._state = self._STATE_SUCCEEDED
 
     def executemany(self, operation, seq_of_parameters):
         """Prepare a database operation (query or command) and then execute it against all parameter
@@ -221,11 +223,15 @@ class Cursor(object):
         no more data is available."""
         if self._state == self._STATE_NONE:
             raise Exception("No query yet")
-        if not self._data:
-            return None
+        if not self._rows:
+            raise Exception("No rows yet")
         else:
             self._rownumber += 1
-            return self._data.pop(0)
+            try:
+                row = self._rows.__next__()
+            except StopIteration:
+                return None
+            return row.values()
 
     def fetchmany(self, size=None):
         """Fetch the next set of rows of a query result, returning a sequence of sequences (e.g. a
@@ -242,15 +248,14 @@ class Cursor(object):
         if size is None:
             size = 1
 
-        if not self._data:
-            return []
-        else:
-            if len(self._data) > size:
-                result, self._data = self._data[:size], self._data[size:]
-            else:
-                result, self._data = self._data, []
-            self._rownumber += len(result)
-            return result
+        data = []
+        if self._rows:
+            for row in self._rows:
+                self._rownumber += 1
+                data.append(row.values())
+                if len(data) == size:
+                    break
+        return data
 
     def fetchall(self):
         """Fetch all (remaining) rows of a query result, returning them as a sequence of sequences
@@ -259,23 +264,19 @@ class Cursor(object):
         if self._state == self._STATE_NONE:
             raise Exception("No query yet")
 
-        if not self._data:
-            return []
-        else:
-            result, self._data = self._data, []
-            self._rownumber += len(result)
-            return result
+        data = []
+        if self._rows:
+            for row in self._rows:
+                self._rownumber += 1
+                data.append(row.values())
+        return data
 
     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
+        return self.fetchone()
 
     next = __next__
 
@@ -287,23 +288,14 @@ class Cursor(object):
         if self._state == self._STATE_NONE:
             raise ServerException("No query yet")
         if self._uuid is None:
-            assert self._state == self._STATE_SUCCEEDED, "Query should be finished"
+            if self._state != self._STATE_RUNNING:
+                raise ServerException("Query should be running")
             return
         # Replace current running query to cancel it
         self._db.execute("SELECT 1")
         self._state = self._STATE_SUCCEEDED
         self._uuid = None
-        self._data = None
+        self._rows = None
 
     def poll(self):
         pass
-
-    def _process_response(self, column_types, response):
-        """Update the internal state with the data from the response"""
-        assert (
-            self._state == self._STATE_RUNNING
-        ), "Should be running if processing response"
-
-        self._data = response
-        self._columns = column_types
-        self._state = self._STATE_SUCCEEDED

{databend_sqlalchemy-0.3.2 → databend_sqlalchemy-0.4.0}/databend_sqlalchemy/databend_dialect.py

@@ -158,7 +158,7 @@ class DatabendCompiler(PGCompiler):
         )
 
     def visit_column(
-            self, column, add_to_result_map=None, include_table=True, **kwargs
+        self, column, add_to_result_map=None, include_table=True, **kwargs
     ):
         # Columns prefixed with table name are not supported
         return super(DatabendCompiler, self).visit_column(
@@ -233,7 +233,7 @@ class DatabendDialect(default.DefaultDialect):
     _backslash_escapes = True
 
     def __init__(
-            self, context: Optional[ExecutionContext] = None, *args: Any, **kwargs: Any
+        self, context: Optional[ExecutionContext] = None, *args: Any, **kwargs: Any
     ):
         super(DatabendDialect, self).__init__(*args, **kwargs)
         self.context: Union[ExecutionContext, Dict] = context or {}
@@ -242,7 +242,7 @@ class DatabendDialect(default.DefaultDialect):
     def dbapi(cls):
         try:
             import databend_sqlalchemy.connector as connector
-        except:
+        except Exception:
             import connector
         return connector
 
@@ -256,11 +256,11 @@ class DatabendDialect(default.DefaultDialect):
     def create_connect_args(self, url):
         parameters = dict(url.query)
         kwargs = {
-            "db_url": "databend://%s:%s@%s:%d/%s"
-                      % (url.username, url.password, url.host, url.port or 8000, url.database),
+            "dsn": "databend://%s:%s@%s:%d/%s"
+            % (url.username, url.password, url.host, url.port or 8000, url.database),
         }
         for k, v in parameters.items():
-            kwargs["db_url"] = kwargs["db_url"] + "?" + k + "=" + v
+            kwargs["dsn"] = kwargs["dsn"] + "?" + k + "=" + v
 
         return ([], kwargs)
 
@@ -318,7 +318,7 @@ class DatabendDialect(default.DefaultDialect):
 
     def extract_nullable_string(self, target):
         if "Nullable" in target:
-            match = re.match(r'Nullable\(([^)]+)\)', target)
+            match = re.match(r"Nullable\(([^)]+)\)", target)
             if match:
                 return match.group(1)
             else:

{databend_sqlalchemy-0.3.2 → databend_sqlalchemy-0.4.0}/databend_sqlalchemy/test.py

@@ -2,7 +2,9 @@ from databend_sqlalchemy import connector
 
 
 def test():
-    conn = connector.connect("http://databend:databend@localhost:8000/default?secure=false")
+    conn = connector.connect(
+        "databend://databend:databend@localhost:8000/default?sslmode=disable"
+    )
     cursor = conn.cursor()
     cursor.execute(
         "select null as db, name as name, database as schema, if(engine = 'VIEW', 'view', 'table') "

{databend_sqlalchemy-0.3.2 → databend_sqlalchemy-0.4.0}/databend_sqlalchemy.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: databend-sqlalchemy
-Version: 0.3.2
+Version: 0.4.0
 Summary: Sqlalchemy adapter for Databend
 Home-page: https://github.com/datafuselabs/databend-sqlalchemy
 Author: Databend Cloud
@@ -19,7 +19,7 @@ Classifier: Programming Language :: Python :: 3.10
 Requires-Python: >=3.7
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: databend_py>=0.4.9
+Requires-Dist: databend_py>=0.5.0
 Requires-Dist: sqlalchemy<2.0,>1.3.21
 Provides-Extra: dev
 Requires-Dist: devtools==0.7.0; extra == "dev"
@@ -51,14 +51,14 @@ The DSN format is similar to that of regular Postgres::
         from sqlalchemy import create_engine, text
         from sqlalchemy.engine.base import Connection, Engine
         engine = create_engine(
-            f"databend://{username}:{password}@{host_port_name}/{database_name}?secure=false"
+            f"databend://{username}:{password}@{host_port_name}/{database_name}?sslmode=disable"
         )
         connection = engine.connect()
         result = connection.execute(text("SELECT 1"))
         assert len(result.fetchall()) == 1
 
         import connector
-        cursor = connector.connect('http://root:@localhost:8081').cursor()
+        cursor = connector.connect('databend://root:@localhost:8000?sslmode=disable').cursor()
         cursor.execute('SELECT * FROM test')
         # print(cursor.fetchone())
         # print(cursor.fetchall())

{databend_sqlalchemy-0.3.2 → databend_sqlalchemy-0.4.0}/databend_sqlalchemy.egg-info/SOURCES.txt

@@ -7,10 +7,8 @@ setup.cfg
 ./databend_sqlalchemy/__init__.py
 ./databend_sqlalchemy/connector.py
 ./databend_sqlalchemy/databend_dialect.py
-./databend_sqlalchemy/entry_points.py
 ./databend_sqlalchemy/errors.py
 ./databend_sqlalchemy/test.py
-./tests/__init__.py
 databend_sqlalchemy.egg-info/PKG-INFO
 databend_sqlalchemy.egg-info/SOURCES.txt
 databend_sqlalchemy.egg-info/dependency_links.txt

{databend_sqlalchemy-0.3.2 → databend_sqlalchemy-0.4.0}/databend_sqlalchemy.egg-info/requires.txt

@@ -1,4 +1,4 @@
-databend_py>=0.4.9
+databend_py>=0.5.0
 sqlalchemy<2.0,>1.3.21
 
 [dev]

{databend_sqlalchemy-0.3.2 → databend_sqlalchemy-0.4.0}/databend_sqlalchemy.egg-info/top_level.txt

@@ -1,3 +1,2 @@
 cc_superset
 databend_sqlalchemy
-tests

{databend_sqlalchemy-0.3.2 → databend_sqlalchemy-0.4.0}/pyproject.toml

@@ -1,8 +1,5 @@
 [build-system]
-requires = [
-    "setuptools>=42",
-    "wheel"
-]
+requires = ["setuptools>=42", "wheel"]
 build-backend = "setuptools.build_meta"
 
 # configure isort to be compatible with black
@@ -21,4 +18,4 @@ exclude = '''
   | \.venv
   | dist
 )/
-'''
+'''

{databend_sqlalchemy-0.3.2 → databend_sqlalchemy-0.4.0}/setup.cfg

@@ -25,7 +25,7 @@ project_urls =
 [options]
 packages = find:
 install_requires = 
-	databend_py>=0.4.9
+	databend_py>=0.5.0
 	sqlalchemy>1.3.21,<2.0
 python_requires = >=3.7
 package_dir = 

databend_sqlalchemy-0.3.2/databend_sqlalchemy/__init__.py

@@ -1,7 +0,0 @@
-#!/usr/bin/env python
-
-
-from databend_sqlalchemy.entry_points import validate_entrypoints  # noqa
-
-VERSION = (0, 3, 2)
-__version__ = ".".join(str(x) for x in VERSION)

databend_sqlalchemy-0.3.2/databend_sqlalchemy/entry_points.py

@@ -1,40 +0,0 @@
-#!/usr/bin/env python3
-
-import sys
-import pkg_resources
-
-EXPECTED_EPS = {"sqlalchemy.dialects:databend", "superset.db_engine_specs:databend"}
-
-
-def validate_entrypoints():
-    expected_eps = EXPECTED_EPS.copy()
-    try:
-        dist = pkg_resources.get_distribution("databend-sqlalchemy")
-    except pkg_resources.DistributionNotFound:
-        print("\nDatabend Sqlalchemy package not found in this Python installation")
-        return -1
-    entry_map = dist.get_entry_map()
-    print()
-    for ep_group, entry_points in entry_map.items():
-        print(ep_group)
-        for entry_point in entry_points.values():
-            print(
-                f'    {entry_point.name}={entry_point.module_name}.{", ".join(entry_point.attrs)}'
-            )
-            name = f"{ep_group}:{entry_point.name}"
-            try:
-                expected_eps.remove(name)
-            except KeyError:
-                print(f"\nUnexpected entry point {name} found")
-                return -1
-    if expected_eps:
-        print()
-        for name in expected_eps:
-            print(f"Did not find expected ep {name}")
-        return -1
-    print("\nEntrypoints correctly installed")
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(validate_entrypoints())