Fixes: #4950

gjarzab · gjarzab · commit a18f0532426e · 2025-09-12T14:47:15.000-05:00
add CreateTableAs for default dialect and SqLite.
add Select.into constructor for CreateTableAs.
diff --git a/lib/sqlalchemy/dialects/sqlite/base.py b/lib/sqlalchemy/dialects/sqlite/base.py
@@ -1735,6 +1735,23 @@ def get_column_specification(self, column, **kwargs):
 
         return colspec
 
+    def visit_create_table_as(self, element, **kw):
+        prep = self.preparer
+        select_sql = self.sql_compiler.process(
+            element.selectable, literal_binds=True
+        )
+
+        parts = [
+            "CREATE",
+            "TEMPORARY" if element.temporary else None,
+            "TABLE",
+            "IF NOT EXISTS" if element.if_not_exists else None,
+            prep.format_table(element.table),
+            "AS",
+            select_sql,
+        ]
+        return " ".join(p for p in parts if p)
+
     def visit_primary_key_constraint(self, constraint, **kw):
         # for columns with sqlite_autoincrement=True,
         # the PRIMARY KEY constraint can only be inline
diff --git a/lib/sqlalchemy/sql/compiler.py b/lib/sqlalchemy/sql/compiler.py
@@ -6828,6 +6828,25 @@ def visit_create_table(self, create, **kw):
         text += "\n)%s\n\n" % self.post_create_table(table)
         return text
 
+    def visit_create_table_as(self, element, **kw):
+        """Default CTAS emission.
+
+        Render a generic CREATE TABLE AS form and let dialects override to
+        add features (TEMPORARY, IF NOT EXISTS, SELECT INTO on MSSQL, etc.).
+
+        Keep **bind parameters** in the inner SELECT (no literal_binds)
+        """
+        # target identifier (schema-qualified if present)
+        qualified = self.preparer.format_table(element.table)
+
+        # inner SELECT — keep binds so DDL vs DML
+        # differences are handled by backends
+        inner_kw = dict(kw)
+        inner_kw.pop("literal_binds", None)
+        select_sql = self.sql_compiler.process(element.selectable, **inner_kw)
+
+        return f"CREATE TABLE {qualified} AS {select_sql}"
+
     def visit_create_column(self, create, first_pk=False, **kw):
         column = create.element
 
diff --git a/lib/sqlalchemy/sql/ddl.py b/lib/sqlalchemy/sql/ddl.py
@@ -32,6 +32,9 @@
 from .base import Executable
 from .base import SchemaVisitor
 from .elements import ClauseElement
+from .schema import Table
+from .selectable import Selectable
+from .selectable import TableClause
 from .. import exc
 from .. import util
 from ..util import topological
@@ -47,8 +50,6 @@
     from .schema import Index
     from .schema import SchemaItem
     from .schema import Sequence as Sequence  # noqa: F401
-    from .schema import Table
-    from .selectable import TableClause
     from ..engine.base import Connection
     from ..engine.interfaces import CacheStats
     from ..engine.interfaces import CompiledCacheType
@@ -544,6 +545,93 @@ def __init__(
         self.include_foreign_key_constraints = include_foreign_key_constraints
 
 
+class CreateTableAs(ExecutableDDLElement):
+    """Represent a CREATE TABLE ... AS (CTAS) statement.
+
+    This creates a new table directly from the output of a SELECT.
+    The set of columns in the new table is derived from the
+    SELECT list; constraints, indexes, and defaults are not copied.
+
+    :param selectable: :class:`_sql.Selectable`
+        The SELECT (or other selectable) providing the columns and rows.
+
+    :param target: str | :class:`_sql.TableClause`
+        Table name or object. If passed as a string, it must be
+        unqualified; use the ``schema`` argument for qualification.
+
+    :param schema: str, optional
+        Schema or owner name.  If both ``schema`` and the target object
+        specify a schema, they must match.
+
+    :param temporary: bool, default False.
+        If True, render ``TEMPORARY`` (PostgreSQL, MySQL, SQLite), or
+        a ``#<name>`` temporary table on SQL Server.  Dialects that do
+        not support this option will raise :class:`.CompileError`.
+
+    :param if_not_exists: bool, default False.
+        If True, render ``IF NOT EXISTS`` where supported
+        (PostgreSQL, MySQL, SQLite).  Dialects that do not support this
+        option will raise :class:`.CompileError`.
+    """
+
+    __visit_name__ = "create_table_as"
+    inherit_cache = False
+
+    def __init__(
+        self,
+        selectable: Selectable,
+        target: Union[str, TableClause],
+        *,
+        schema: Optional[str] = None,
+        temporary: bool = False,
+        if_not_exists: bool = False,
+    ):
+        if isinstance(target, TableClause):
+            t_name = target.name
+            t_schema = target.schema
+
+            if not t_name or not str(t_name).strip():
+                raise exc.ArgumentError("Table name must be non-empty")
+
+            if (
+                schema is not None
+                and t_schema is not None
+                and schema != t_schema
+            ):
+                raise exc.ArgumentError(
+                    f"Conflicting schema: target={t_schema!r}, "
+                    f"schema={schema!r}"
+                )
+            final_schema = (
+                schema
+                if (schema is not None and t_schema is None)
+                else t_schema
+            )
+        elif isinstance(target, str):
+            if not target.strip():
+                raise exc.ArgumentError("Table name must be non-empty")
+            if "." in target:
+                raise exc.ArgumentError(
+                    "Target string must be unqualified (use schema=)."
+                )
+            t_name = target
+            final_schema = schema
+        else:
+            raise exc.ArgumentError("target must be a string, TableClause")
+
+        self.table = TableClause(t_name, schema=final_schema)
+
+        self.target = target
+        self.schema = final_schema
+        self.selectable = selectable
+        self.temporary = bool(temporary)
+        self.if_not_exists = bool(if_not_exists)
+
+    @property
+    def generated_table(self) -> TableClause:
+        return self.table
+
+
 class _DropView(_DropBase["Table"]):
     """Semi-public 'DROP VIEW' construct.
 
diff --git a/lib/sqlalchemy/sql/selectable.py b/lib/sqlalchemy/sql/selectable.py
@@ -138,6 +138,7 @@
     from .base import ReadOnlyColumnCollection
     from .cache_key import _CacheKeyTraversalType
     from .compiler import SQLCompiler
+    from .ddl import CreateTableAs
     from .dml import Delete
     from .dml import Update
     from .elements import BinaryExpression
@@ -148,6 +149,7 @@
     from .functions import Function
     from .schema import ForeignKey
     from .schema import ForeignKeyConstraint
+    from .schema import Table
     from .sqltypes import TableValueType
     from .type_api import TypeEngine
     from .visitors import _CloneCallableType
@@ -6813,6 +6815,24 @@ def intersect_all(
         """
         return CompoundSelect._create_intersect_all(self, *other)
 
+    def into(
+        self,
+        target: Union[str, TableClause, Table],
+        *,
+        schema: Optional[str] = None,
+        temporary: bool = False,
+        if_not_exists: bool = False,
+    ) -> "CreateTableAs":
+        from .ddl import CreateTableAs
+
+        return CreateTableAs(
+            self,
+            target,
+            schema=schema,
+            temporary=temporary,
+            if_not_exists=if_not_exists,
+        )
+
 
 class ScalarSelect(
     roles.InElementRole, Generative, GroupedElement, ColumnElement[_T]
diff --git a/test/dialect/test_sqlite.py b/test/dialect/test_sqlite.py
diff --git a/test/sql/test_create_table_as.py b/test/sql/test_create_table_as.py
