duckrun 0.3.17.dev4__tar.gz → 0.3.17.dev6__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duckrun
-Version: 0.3.17.dev4
+Version: 0.3.17.dev6
 Summary: A dbt adapter that runs SQL in DuckDB and materializes to Delta Lake (delta_rs).
 Author: mim
 License: MIT
@@ -12,7 +12,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: dbt-duckdb>=1.8
 Requires-Dist: dbt-core<2.0,>=1.8
-Requires-Dist: duckdb==1.5.4.dev18
+Requires-Dist: duckdb>=1.5.4
 Requires-Dist: deltalake<1.5.1,>=1.5.0
 Requires-Dist: requests
 Provides-Extra: local

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

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

{duckrun-0.3.17.dev4 → duckrun-0.3.17.dev6}/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.dev6}/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.dev6/duckrun.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: duckrun
-Version: 0.3.17.dev4
+Version: 0.3.17.dev6
 Summary: A dbt adapter that runs SQL in DuckDB and materializes to Delta Lake (delta_rs).
 Author: mim
 License: MIT
@@ -12,7 +12,7 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: dbt-duckdb>=1.8
 Requires-Dist: dbt-core<2.0,>=1.8
-Requires-Dist: duckdb==1.5.4.dev18
+Requires-Dist: duckdb>=1.5.4
 Requires-Dist: deltalake<1.5.1,>=1.5.0
 Requires-Dist: requests
 Provides-Extra: local

{duckrun-0.3.17.dev4 → duckrun-0.3.17.dev6}/duckrun.egg-info/requires.txt

@@ -1,6 +1,6 @@
 dbt-duckdb>=1.8
 dbt-core<2.0,>=1.8
-duckdb==1.5.4.dev18
+duckdb>=1.5.4
 deltalake<1.5.1,>=1.5.0
 requests
 

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "duckrun"
-version = "0.3.17.dev4"
+version = "0.3.17.dev6"
 description = "A dbt adapter that runs SQL in DuckDB and materializes to Delta Lake (delta_rs)."
 readme = "README.md"
 license = {text = "MIT"}
@@ -21,8 +21,7 @@ dependencies = [
     # fails at `from dbt.cli.main import dbtRunner`. Declared directly because we only depend on
     # dbt-core transitively, so the ceiling has to live here to bite.
     "dbt-core>=1.8,<2.0",
-    # TEMPORARY pin to a duckdb dev build — TODO: move to "==1.5.4" (or a range) once stable
-    # 1.5.4 ships (~end of month). 1.5.4.dev18 is the first build whose bundled duckdb-delta
+    # Floor at the 1.5.4 stable release. 1.5.4 is the first stable build whose bundled duckdb-delta
     # extension supports `delta_scan('...', version => N)` (duckdb-delta #312) — the version-pinned
     # read this project now relies on to make the incremental read and the write commit resolve at
     # ONE Delta snapshot (Spark single-snapshot MERGE parity; see the staging-read pin in
@@ -33,7 +32,7 @@ dependencies = [
     # disk-spill config (max_spill_size), which engine.merge_delta relies on to cap the merge's RAM
     # and avoid OOM on large upserts; the matching <1.5.1 ceiling avoids the deltalake delta-log
     # write-side regression, pinning exactly 1.5.0.
-    "duckdb==1.5.4.dev18",
+    "duckdb>=1.5.4",
     "deltalake>=1.5.0,<1.5.1",
     # The top-level connection API (duckrun.connect) discovers OneLake tables via the DFS REST
     # API directly; requests is otherwise only a transitive dbt dependency.

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

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