feat(dtype): support compiling dtypes to sql

Author: NickCrews

ibis/backends/sql/compilers/base.py

@@ -577,14 +577,17 @@ def _prepare_params(self, params):
 
     def to_sqlglot(
         self,
-        expr: ir.Expr,
+        x: ir.Expr | dt.DataType,
         *,
         limit: str | None = None,
         params: Mapping[ir.Expr, Any] | None = None,
-    ):
+    ) -> sge.Expression:
         import ibis
 
-        table_expr = expr.as_table()
+        if isinstance(x, dt.DataType):
+            return self.type_mapper.from_ibis(x)
+
+        table_expr = x.as_table()
 
         if limit == "default":
             limit = ibis.options.sql.default_limit

ibis/backends/sql/compilers/bigquery/__init__.py

@@ -206,7 +206,7 @@ class BigQueryCompiler(SQLGlotCompiler):
 
     def to_sqlglot(
         self,
-        expr: ir.Expr,
+        x: ir.Expr | dt.DataType,
         *,
         limit: str | None = None,
         params: Mapping[ir.Expr, Any] | None = None,
@@ -217,8 +217,8 @@ def to_sqlglot(
 
         Parameters
         ----------
-        expr
-            Ibis expression
+        x
+            Ibis expression or data type.
         limit
             For expressions yielding result sets; retrieve at most this number
             of values/rows. Overrides any limit already set on the expression.
@@ -236,9 +236,11 @@ def to_sqlglot(
             backend.
 
         """
-        sql = super().to_sqlglot(expr, limit=limit, params=params)
+        sql = super().to_sqlglot(x, limit=limit, params=params)
+        if isinstance(x, dt.DataType):
+            return sql
 
-        table_expr = expr.as_table()
+        table_expr = x.as_table()
 
         memtable_names = frozenset(
             op.name for op in table_expr.op().find(ops.InMemoryTable)

ibis/backends/sql/compilers/duckdb.py

@@ -109,14 +109,16 @@ class DuckDBCompiler(SQLGlotCompiler):
 
     def to_sqlglot(
         self,
-        expr: ir.Expr,
+        x: ir.Expr | dt.DataType,
         *,
         limit: str | None = None,
         params: Mapping[ir.Expr, Any] | None = None,
-    ):
-        sql = super().to_sqlglot(expr, limit=limit, params=params)
+    ) -> sge.Expression:
+        sql = super().to_sqlglot(x, limit=limit, params=params)
+        if isinstance(x, dt.DataType):
+            return sql
 
-        table_expr = expr.as_table()
+        table_expr = x.as_table()
         geocols = table_expr.schema().geospatial
 
         if not geocols:

ibis/backends/sql/compilers/mssql.py

@@ -158,15 +158,17 @@ def _minimize_spec(op, spec):
 
     def to_sqlglot(
         self,
-        expr: ir.Expr,
+        x: ir.Expr | dt.DataType,
         *,
         limit: str | None = None,
         params: Mapping[ir.Expr, Any] | None = None,
-    ):
-        """Compile an Ibis expression to a sqlglot object."""
+    ) -> sge.Expression:
         import ibis
 
-        table_expr = expr.as_table()
+        if isinstance(x, dt.DataType):
+            return super().to_sqlglot(x)
+
+        table_expr = x.as_table()
         conversions = {
             name: ibis.ifelse(table_expr[name], 1, 0).cast(dt.boolean)
             for name, typ in table_expr.schema().items()

ibis/backends/sql/compilers/postgres.py

@@ -124,12 +124,15 @@ class PostgresCompiler(SQLGlotCompiler):
 
     def to_sqlglot(
         self,
-        expr: ir.Expr,
+        x: ir.Expr | dt.DataType,
         *,
         limit: str | None = None,
         params: Mapping[ir.Expr, Any] | None = None,
-    ):
-        table_expr = expr.as_table()
+    ) -> sg.Expression:
+        if isinstance(x, dt.DataType):
+            return super().to_sqlglot(x)
+
+        table_expr = x.as_table()
         geocols = table_expr.schema().geospatial
         conversions = {name: table_expr[name].as_ewkb() for name in geocols}
 

ibis/backends/sql/datatypes.py

@@ -769,8 +769,14 @@ def _from_sqlglot_DECIMAL(
 
     @classmethod
     def _from_ibis_String(cls, dtype: dt.String) -> sge.DataType:
-        nullable = " NOT NULL" if not dtype.nullable else ""
-        return "VARCHAR2(4000)" + nullable
+        return sge.DataType(
+            this=typecode.VARCHAR,
+            expressions=[
+                sge.DataTypeParam(
+                    this=sge.convert(dtype.length if dtype.length is not None else 4000)
+                )
+            ],
+        )
 
 
 class SnowflakeType(SqlglotType):

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/athena/to_sql_dtype.sql

@@ -0,0 +1 @@
+VARCHAR

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/bigquery/to_sql_dtype.sql

@@ -0,0 +1 @@
+STRING

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/clickhouse/to_sql_dtype.sql

@@ -0,0 +1 @@
+Nullable(String)

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/databricks/to_sql_dtype.sql

@@ -0,0 +1 @@
+STRING

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/datafusion/to_sql_dtype.sql

@@ -0,0 +1 @@
+VARCHAR

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/druid/to_sql_dtype.sql

@@ -0,0 +1 @@
+VARCHAR

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/duckdb/to_sql_dtype.sql

@@ -0,0 +1 @@
+TEXT

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/exasol/to_sql_dtype.sql

@@ -0,0 +1 @@
+VARCHAR(2000000)

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/flink/to_sql_dtype.sql

@@ -0,0 +1 @@
+STRING

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/impala/to_sql_dtype.sql

@@ -0,0 +1 @@
+STRING

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/mssql/to_sql_dtype.sql

@@ -0,0 +1 @@
+VARCHAR(max)

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/mysql/to_sql_dtype.sql

@@ -0,0 +1 @@
+TEXT

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/oracle/to_sql_dtype.sql

@@ -0,0 +1 @@
+VARCHAR2(4000)

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/postgres/to_sql_dtype.sql

@@ -0,0 +1 @@
+VARCHAR

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/pyspark/to_sql_dtype.sql

@@ -0,0 +1 @@
+STRING

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/risingwave/to_sql_dtype.sql

@@ -0,0 +1 @@
+VARCHAR

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/snowflake/to_sql_dtype.sql

@@ -0,0 +1 @@
+VARCHAR

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/sqlite/to_sql_dtype.sql

@@ -0,0 +1 @@
+TEXT

ibis/backends/tests/snapshots/test_sql/test_to_sql_dtype/trino/to_sql_dtype.sql

@@ -0,0 +1 @@
+VARCHAR

ibis/backends/tests/test_sql.py

@@ -197,6 +197,33 @@ def test_to_sql_default_backend(con, snapshot, monkeypatch):
     snapshot.assert_match(ibis.to_sql(expr), "to_sql.sql")
 
 
+@pytest.mark.parametrize(
+    "dialect",
+    [
+        # Just check these two to make sure that everything is plumbed through
+        pytest.param("sqlite", marks=pytest.mark.xfail(reason="arrays not supported")),
+        "duckdb",
+    ],
+)
+def test_to_sql_dtype_default_backend(dialect):
+    dt = ibis.dtype("array<int64>")
+    original_backend = ibis.get_backend()
+    try:
+        ibis.set_backend(dialect)
+        sql = ibis.to_sql(dt)
+    except:
+        ibis.set_backend(original_backend)
+        raise
+    assert "BIGINT[]" == sql
+
+
+@pytest.mark.parametrize("backend_name", _get_backends_to_test(discard=("polars",)))
+def test_to_sql_dtype(backend_name, snapshot):
+    dt = ibis.dtype("string")
+    sql = ibis.to_sql(dt, dialect=backend_name)
+    snapshot.assert_match(sql, "to_sql_dtype.sql")
+
+
 @pytest.mark.notimpl(["polars"], raises=ValueError, reason="not a SQL backend")
 def test_many_subqueries(backend_name, snapshot):
     def query(t, group_cols):

ibis/expr/sql.py

@@ -3,6 +3,7 @@
 import contextlib
 import operator
 from functools import singledispatch
+from typing import TYPE_CHECKING
 
 import sqlglot as sg
 import sqlglot.expressions as sge
@@ -18,6 +19,9 @@
 from ibis.backends.sql.datatypes import SqlglotType
 from ibis.util import experimental
 
+if TYPE_CHECKING:
+    from ibis.backends.sql.compilers.base import SQLGlotCompiler
+
 
 class Catalog(dict[str, sch.Schema]):
     """A catalog of tables and their schemas."""
@@ -445,14 +449,18 @@ def _repr_pretty_(self, p, cycle) -> str:
 
 @public
 def to_sql(
-    expr: ir.Expr, dialect: str | None = None, pretty: bool = True, **kwargs
+    x: ir.Expr | dt.DataType,
+    dialect: str | None = None,
+    *,
+    pretty: bool = True,
+    **kwargs,
 ) -> SQLString:
-    """Return the formatted SQL string for an expression.
+    """Return the formatted SQL string for an expression or data type.
 
     Parameters
     ----------
-    expr
-        Ibis expression.
+    x
+        Ibis expression or data type.
     dialect
         SQL dialect to use for compilation.
     pretty
@@ -484,6 +492,8 @@ def to_sql(
       `t0`.`b`,
       `t0`.`a` + `t0`.`b` AS `c`
     FROM `t` AS `t0`
+    >>> ibis.to_sql(ibis.dtype("array<int64>"), dialect="duckdb")
+    'BIGINT[]'
 
     See Also
     --------
@@ -495,23 +505,31 @@ def to_sql(
     # try to infer from a non-str expression or if not possible fallback to
     # the default pretty dialect for expressions
     if dialect is None:
-        try:
-            compiler_provider = expr._find_backend(use_default=True)
-        except com.IbisError:
-            # default to duckdb for SQL compilation because it supports the
-            # widest array of ibis features for SQL backends
-            compiler_provider = sc.duckdb
+        if isinstance(x, dt.DataType):
+            compiler_provider = ibis.get_backend()
+        else:
+            try:
+                compiler_provider = x._find_backend(use_default=True)
+            except com.IbisError:
+                # default to duckdb for SQL compilation because it supports the
+                # widest array of ibis features for SQL backends
+                compiler_provider = sc.duckdb
     else:
         try:
             compiler_provider = getattr(sc, dialect)
         except AttributeError as e:
             raise ValueError(f"Unknown dialect {dialect}") from e
 
+    compiler: SQLGlotCompiler
     if (compiler := getattr(compiler_provider, "compiler", None)) is None:
         raise NotImplementedError(f"{compiler_provider} is not a SQL backend")
 
-    out = compiler.to_sqlglot(expr.unbind(), **kwargs)
-    queries = out if isinstance(out, list) else [out]
     dialect = compiler.dialect
+    if isinstance(x, dt.DataType):
+        # kwargs are ignored. Perhaps we should raise an error here if they are passed?
+        return compiler.to_sqlglot(x).sql(dialect=dialect, pretty=pretty)
+
+    out = compiler.to_sqlglot(x.unbind(), **kwargs)
+    queries = out if isinstance(out, list) else [out]
     sql = ";\n".join(query.sql(dialect=dialect, pretty=pretty) for query in queries)
     return SQLString(sql)