Merge pull request #7 from datafuselabs/fix/get-indexs

fix: get_indexs bug

Author: hantmac

Diff for: databend_sqlalchemy/__init__.py

@@ -3,5 +3,5 @@
 
 from databend_sqlalchemy.entry_points import validate_entrypoints  # noqa
 
-VERSION = (0, 3, 1)
+VERSION = (0, 3, 2)
 __version__ = ".".join(str(x) for x in VERSION)

Diff for: databend_sqlalchemy/databend_dialect.py

@@ -338,27 +338,7 @@ def get_pk_constraint(self, connection, table_name, schema=None, **kw):
 
     @reflection.cache
     def get_indexes(self, connection, table_name, schema=None, **kw):
-        full_table = table_name
-        if schema:
-            full_table = schema + "." + table_name
-        # We must get the full table creation STMT to parse engine and partitions
-        rows = [
-            r for r in connection.execute("SHOW CREATE TABLE {}".format(full_table))
-        ]
-        if len(rows) < 1:
-            return []
-        # VIEWs are not going to have ENGINE associated, there is no good way how to
-        # determine partitioning columns (or indexes)
-        engine_spec = re.search(r"ENGINE = (\w+)\((.+)\)", rows[0].statement)
-        if not engine_spec:
-            return []
-        engine, params = engine_spec.group(1, 2)
-        # Handle partition columns
-        cols = re.search(r"\((.+)\)", params)
-        if not cols:
-            return []
-        col_names = [c.strip() for c in cols.group(1).split(",")]
-        return [{"name": "partition", "column_names": col_names, "unique": False}]
+        return []
 
     # @reflection.cache
     def get_table_names(self, connection, schema=None, **kw):

Diff for: tests/unit/test_databend_dialect.py

@@ -41,15 +41,15 @@ def test_create_dialect(self, dialect: DatabendDialect):
     #     assert result_dict["username"] == "user"
 
     def test_do_execute(
-        self, dialect: DatabendDialect, cursor: mock.Mock(spec=MockCursor)
+            self, dialect: DatabendDialect, cursor: mock.Mock(spec=MockCursor)
     ):
         dialect.do_execute(cursor, "SELECT *", None)
         cursor.execute.assert_called_once_with("SELECT *", None)
         cursor.execute.reset_mock()
         dialect.do_execute(cursor, "SELECT *", (1, 22), None)
 
     def test_table_names(
-        self, dialect: DatabendDialect, connection: mock.Mock(spec=MockDBApi)
+            self, dialect: DatabendDialect, connection: mock.Mock(spec=MockDBApi)
     ):
         connection.execute.return_value = [
             ("table1",),
@@ -74,13 +74,18 @@ def test_table_names(
         )
 
     def test_view_names(
-        self, dialect: DatabendDialect, connection: mock.Mock(spec=MockDBApi)
+            self, dialect: DatabendDialect, connection: mock.Mock(spec=MockDBApi)
     ):
         connection.execute.return_value = []
         assert dialect.get_view_names(connection) == []
 
+    def test_indexes(
+            self, dialect: DatabendDialect, connection: mock.Mock(spec=MockDBApi)
+    ):
+        assert dialect.get_indexes(connection, "table") == []
+
     def test_columns(
-        self, dialect: DatabendDialect, connection: mock.Mock(spec=MockDBApi)
+            self, dialect: DatabendDialect, connection: mock.Mock(spec=MockDBApi)
     ):
         def multi_column_row(columns):
             def getitem(self, idx):
@@ -104,11 +109,11 @@ def getitem(self, idx):
         expected_query_schema = expected_query + " and table_schema = 'schema'"
 
         for call, expected_query in (
-            (lambda: dialect.get_columns(connection, "table"), expected_query),
-            (
-                lambda: dialect.get_columns(connection, "table", "schema"),
-                expected_query_schema,
-            ),
+                (lambda: dialect.get_columns(connection, "table"), expected_query),
+                (
+                        lambda: dialect.get_columns(connection, "table", "schema"),
+                        expected_query_schema,
+                ),
         ):
             assert call() == [
                 {
@@ -140,22 +145,22 @@ def test_types():
     assert databend_sqlalchemy.databend_dialect.CHAR is sqlalchemy.sql.sqltypes.CHAR
     assert databend_sqlalchemy.databend_dialect.DATE is sqlalchemy.sql.sqltypes.DATE
     assert (
-        databend_sqlalchemy.databend_dialect.DATETIME
-        is sqlalchemy.sql.sqltypes.DATETIME
+            databend_sqlalchemy.databend_dialect.DATETIME
+            is sqlalchemy.sql.sqltypes.DATETIME
     )
     assert (
-        databend_sqlalchemy.databend_dialect.INTEGER is sqlalchemy.sql.sqltypes.INTEGER
+            databend_sqlalchemy.databend_dialect.INTEGER is sqlalchemy.sql.sqltypes.INTEGER
     )
     assert databend_sqlalchemy.databend_dialect.BIGINT is sqlalchemy.sql.sqltypes.BIGINT
     assert (
-        databend_sqlalchemy.databend_dialect.TIMESTAMP
-        is sqlalchemy.sql.sqltypes.TIMESTAMP
+            databend_sqlalchemy.databend_dialect.TIMESTAMP
+            is sqlalchemy.sql.sqltypes.TIMESTAMP
     )
     assert (
-        databend_sqlalchemy.databend_dialect.VARCHAR is sqlalchemy.sql.sqltypes.VARCHAR
+            databend_sqlalchemy.databend_dialect.VARCHAR is sqlalchemy.sql.sqltypes.VARCHAR
     )
     assert (
-        databend_sqlalchemy.databend_dialect.BOOLEAN is sqlalchemy.sql.sqltypes.BOOLEAN
+            databend_sqlalchemy.databend_dialect.BOOLEAN is sqlalchemy.sql.sqltypes.BOOLEAN
     )
     assert databend_sqlalchemy.databend_dialect.FLOAT is sqlalchemy.sql.sqltypes.FLOAT
     assert issubclass(