duckrun 0.3.17.dev4__tar.gz → 0.3.17.dev5__tar.gz

{duckrun-0.3.17.dev4/duckrun.egg-info → duckrun-0.3.17.dev5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duckrun
-Version: 0.3.17.dev4
+Version: 0.3.17.dev5
 Summary: A dbt adapter that runs SQL in DuckDB and materializes to Delta Lake (delta_rs).
 Author: mim
 License: MIT

duckrun-0.3.17.dev5/dbt/adapters/duckrun/__version__.py

@@ -0,0 +1 @@
+version = "0.3.17.dev5"

{duckrun-0.3.17.dev4 → duckrun-0.3.17.dev5}/dbt/adapters/duckrun/delta_dml.py

@@ -30,8 +30,11 @@ view`` (not ``table``), so they pass through too.
 
 Supported / unsupported (what reaches delta_rs):
 
-    create [or replace] table x [if not exists] as <query>   Delta overwrite (query: select/with/(…))
-    create table x (<col defs>)                               empty Delta table (connection API only)
+    create [or replace] table x [if not exists] as <query>   Delta CTAS (query: select/with/(…)); a
+                                                              plain create errors if x is live, `or
+                                                              replace` overwrites, `if not exists` no-ops
+    create [or replace] table x [if not exists] (<col defs>)  empty Delta table (connection API only);
+                                                              logs a CREATE TABLE op, same exists rules
     create temp/temporary table …                            native DuckDB (pass through)  ── invariant:
     create view …                                            native DuckDB (pass through)  ── only TEMP
                                                                                             and VIEW are
@@ -91,7 +94,7 @@ _CREATE_AS = re.compile(
 # `create [or replace] table [if not exists] <rel> (<col defs>)` — no `as`. Connection-API only
 # (see _create_coldefs): materializes an EMPTY Delta table so `CREATE TABLE` is always Delta-backed.
 _CREATE_COLDEFS = re.compile(
-    r"\s*create\s+(?:or\s+replace\s+)?table\s+(?:if\s+not\s+exists\s+)?"
+    r"\s*create\s+(?P<orrep>or\s+replace\s+)?table\s+(?P<ine>if\s+not\s+exists\s+)?"
     r"(?P<rel>.+?)\s*\((?P<defs>.+)\)\s*;?\s*",
     re.I | re.S,
 )
@@ -293,10 +296,18 @@ class _DeltaDML:
             m.group("orrep") or not re.match(r"select\b", m.group("body").lstrip(), re.I)
         ):
             return False
+        live = self._exists(loc) and not is_dropped(self.cursor, loc, self.so)
         # `if not exists` over a live (non-tombstone) table is a no-op — just (re)surface the view.
-        if m.group("ine") and self._exists(loc) and not is_dropped(self.cursor, loc, self.so):
+        if m.group("ine") and live:
             self._refresh_view(rel, schema, loc)
             return True
+        # Connection API: a plain `create table` must NOT silently clobber a live table — that's what
+        # `or replace` is for. (The dbt/cursor path keeps overwriting: dbt owns idempotent re-runs.)
+        if self.default_schema is not None and live and not m.group("orrep"):
+            raise ValueError(
+                f"table {schema}.{identifier} already exists — "
+                f"use CREATE OR REPLACE TABLE to replace it"
+            )
         data = self.cursor.sql(m.group("body"))
         # overwrite_schema so this replaces a prior table (or a drop-tombstone) wholesale — a live
         # table is recreated with the real schema, clearing any tombstone marker.
@@ -316,15 +327,27 @@ class _DeltaDML:
         schema, identifier, loc = self._resolve(rel)
         if not loc:
             return False
+        live = self._exists(loc) and not is_dropped(self.cursor, loc, self.so)
+        if m.group("ine") and live:                       # IF NOT EXISTS over a live table → no-op
+            self._refresh_view(rel, schema, loc)
+            return True
+        if live and not m.group("orrep"):                 # plain CREATE over a live table → error
+            raise ValueError(
+                f"table {schema}.{identifier} already exists — "
+                f"use CREATE OR REPLACE TABLE to replace it"
+            )
         # Let DuckDB parse the column defs (types, constraints, nested parens) by building the table
-        # as a TEMP, then take a 0-row typed relation from it and write that as an empty Delta table.
+        # as a TEMP, then take its Arrow schema and create an EMPTY Delta table from it. DeltaTable.create
+        # logs a CREATE TABLE operation (not a WRITE/Overwrite). A live table or a drop-tombstone already
+        # has files at ``loc``, so it must be replaced (overwrite); otherwise create-if-absent (error).
         tmp = f"__duckrun_empty_{abs(hash((schema, identifier))) & 0xFFFFFFFF}"
         self.cursor.execute(f'create or replace temp table "{tmp}" ({m.group("defs")})')
         try:
-            empty = self.cursor.sql(f'select * from "{tmp}" limit 0')
-            engine.write_delta(loc, empty, "overwrite", overwrite_schema=True, storage_options=self.so)
+            arrow_schema = self.cursor.sql(f'select * from "{tmp}" limit 0').arrow().schema
         finally:
             self.cursor.execute(f'drop table if exists "{tmp}"')
+        mode = "overwrite" if self._exists(loc) else "error"
+        engine.create_empty_delta(loc, arrow_schema, mode=mode, storage_options=self.so)
         self._refresh_view(rel, schema, loc)
         return True
 

{duckrun-0.3.17.dev4 → duckrun-0.3.17.dev5}/dbt/adapters/duckrun/engine.py

@@ -732,6 +732,23 @@ def write_delta(
         _maintain(dt, compaction_threshold)
 
 
+def create_empty_delta(
+    path: str,
+    schema,
+    *,
+    mode: str = "error",
+    storage_options: Optional[Dict[str, str]] = None,
+) -> None:
+    """Create an EMPTY Delta table at ``path`` from an Arrow ``schema`` (no data files).
+
+    Used by the connection API's bare ``CREATE TABLE (col defs)``: it logs a ``CREATE TABLE``
+    operation rather than a ``WRITE``/``Overwrite``, which is what a create — not an overwrite —
+    should record. ``mode`` follows delta-rs: ``error`` (fail if the table exists), ``overwrite``
+    (replace an existing table or drop-tombstone), or ``ignore`` (no-op if it exists).
+    """
+    DeltaTable.create(path, schema, mode=mode, storage_options=storage_options)
+
+
 def append_if_unchanged(
     path: str,
     data,

{duckrun-0.3.17.dev4 → duckrun-0.3.17.dev5/duckrun.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duckrun
-Version: 0.3.17.dev4
+Version: 0.3.17.dev5
 Summary: A dbt adapter that runs SQL in DuckDB and materializes to Delta Lake (delta_rs).
 Author: mim
 License: MIT

{duckrun-0.3.17.dev4 → duckrun-0.3.17.dev5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "duckrun"
-version = "0.3.17.dev4"
+version = "0.3.17.dev5"
 description = "A dbt adapter that runs SQL in DuckDB and materializes to Delta Lake (delta_rs)."
 readme = "README.md"
 license = {text = "MIT"}

duckrun-0.3.17.dev4/dbt/adapters/duckrun/__version__.py

@@ -1 +0,0 @@
-version = "0.3.17.dev4"