weaverstack 0.1.1__py3-none-any.whl

weaver/declaration/templates/ddl/infer_create_table.sql

@@ -0,0 +1,97 @@
+declare @weaver_create_sql nvarchar(max);
+declare @weaver_pk_sql nvarchar(max);
+
+if not exists (
+    select 1
+    from tempdb.sys.columns as c
+    where c.[object_id] = object_id($temp_object_literal)
+)
+begin
+    throw 51001, 'weaver found no temp table columns to create.', 1;
+end;
+
+$metadata_validation_sql
+
+$identity_guard_sql
+
+;with primary_key_columns as (
+$primary_key_columns_cte
+),
+not_null_columns as (
+$not_null_columns_cte
+),
+described as (
+    select
+        c.column_id as column_ordinal,
+        coalesce(nullif(c.name, ''), concat('Column', c.column_id)) as column_name,
+        t.name as system_type_name,
+        c.max_length,
+        c.precision,
+        c.scale
+    from tempdb.sys.columns as c
+    inner join tempdb.sys.types as t on t.user_type_id = c.user_type_id
+    where c.[object_id] = object_id($temp_object_literal)
+),
+mapped as (
+    select
+        d.column_ordinal,
+        quotename(d.column_name) as quoted_column_name,
+        $type_case as warehouse_type,
+        -- Nullability is a Weaver contract from the Weaver document header (primary key or
+        -- Not null), not the query's own nullability, so both engines agree.
+        case
+            when nn.column_name is not null then N' not null'
+            else N' null'
+        end as nullability
+    from described as d
+    left join not_null_columns as nn
+        on nn.column_name = d.column_name collate Latin1_General_BIN2
+    cross apply (
+        select lower(d.system_type_name) as base_type
+    ) as bt
+),
+all_columns as (
+$identity_column_sql    select
+        column_ordinal,
+        quoted_column_name + N' ' + warehouse_type + nullability as column_definition
+    from mapped
+
+    union all
+
+    select 1000001, N'[Row insert datetime] datetime2(6) not null'
+    union all
+    select 1000002, N'[Row update datetime] datetime2(6) not null'
+    union all
+    select 1000003, N'[Row delete datetime] datetime2(6) not null'
+)
+select
+    @weaver_create_sql = (
+        select
+            N'create table $target_table (' + char(10)
+            + string_agg(
+                case
+                    when column_ordinal = $first_ordinal then N'    ' + column_definition
+                    else N'  , ' + column_definition
+                end,
+                char(10)
+            ) within group (order by column_ordinal)
+            + char(10) + N');'
+        from all_columns
+    ),
+    @weaver_pk_sql = (
+        select
+            N'alter table $target_table add constraint $pk_constraint '
+            + N'primary key nonclustered ('
+            + string_agg(quotename(column_name), N', ') within group (order by column_ordinal)
+            + N') not enforced;'
+        from primary_key_columns
+    );
+
+print @weaver_create_sql;
+exec sys.sp_executesql @weaver_create_sql;
+
+if @weaver_pk_sql is not null
+begin
+    print @weaver_pk_sql;
+    exec sys.sp_executesql @weaver_pk_sql;
+end;

weaver/declaration/templates/ddl/metadata_column_validation.sql

@@ -0,0 +1,30 @@
+declare @weaver_missing_metadata_column nvarchar(2048);
+
+;with described as (
+    select
+        coalesce(nullif(c.name, ''), concat('Column', c.column_id)) as column_name
+    from tempdb.sys.columns as c
+    where c.[object_id] = object_id($temp_object_literal)$identity_available_sql
+),
+metadata_columns as (
+$metadata_columns_cte
+)
+select top (1)
+    @weaver_missing_metadata_column =
+        concat(m.metadata_kind, N' ', m.column_name, N' does not exist')
+from metadata_columns as m
+where not exists (
+    select 1
+    from described as d
+    -- Column names are exact, case-sensitive Weaver contracts, so compare under
+    -- a binary collation rather than the database's (often case-insensitive) one.
+    where d.column_name = m.column_name collate Latin1_General_BIN2
+)
+order by
+    m.metadata_kind
+  , m.column_name;
+
+if @weaver_missing_metadata_column is not null
+begin
+    throw 51004, @weaver_missing_metadata_column, 1;
+end;

weaver/declaration/templates/load/column_metadata.sql

@@ -0,0 +1,40 @@
+-- The loadable columns, read from the table the load will write to.
+--
+-- Read from sys.columns rather than from the declaration, because the physical
+-- table is what the procedure has to name. That is also what excludes the
+-- identity column for free: the Warehouse generates it, so `is_identity = 0`
+-- keeps it out of every insert list without the generator having to know which
+-- column it was.
+;with source_columns as (
+    select
+        c.name
+      , c.column_id
+      , row_number() over (order by c.column_id) as row_ordinal
+    from sys.columns as c
+    where c.[object_id] = object_id($target_table_literal)
+        and $source_column_filter
+)
+select
+    @weaver_source_columns = string_agg(
+        case when row_ordinal = 1 then quotename(name) else char(10) + N'      , ' + quotename(name) end,
+        N''
+    ) within group (order by column_id)
+  , @weaver_staging_select_columns = string_agg(
+        case when row_ordinal = 1 then N's.' + quotename(name) else char(10) + N'      , s.' + quotename(name) end,
+        N''
+    ) within group (order by column_id)
+  , @weaver_staging_except_columns = string_agg(
+        case when row_ordinal = 1 then N's.' + quotename(name) else char(10) + N'          , s.' + quotename(name) end,
+        N''
+    ) within group (order by column_id)
+  , @weaver_target_except_columns = string_agg(
+        case when row_ordinal = 1 then N't.' + quotename(name) else char(10) + N'          , t.' + quotename(name) end,
+        N''
+    ) within group (order by column_id)
+  , @weaver_upsert_select_columns = string_agg(
+        case when row_ordinal = 1 then N'u.' + quotename(name) else char(10) + N'      , u.' + quotename(name) end,
+        N''
+    ) within group (order by column_id)
+from source_columns;
+
+$update_select

weaver/declaration/templates/load/full_replace_body.sql

@@ -0,0 +1,21 @@
+-- No primary key, so no row can be matched to a target row: there is no such
+-- thing as an update here, and nothing to reject. The target's contents become
+-- the source's.
+select @weaver_target_before = count(*) from $target_table;
+
+delete from $target_table;
+
+insert into $target_table (
+    __SOURCE_COLUMNS__
+  , [Row insert datetime]
+  , [Row update datetime]
+  , [Row delete datetime]
+)
+select
+    __STAGING_SELECT_COLUMNS__
+  , @weaver_load_datetime
+  , @weaver_load_datetime
+  , @weaver_live_datetime
+from $staging_table as s;
+
+set @weaver_rows_inserted = @@rowcount;

weaver/declaration/templates/load/install_load_procedure.sql

@@ -0,0 +1,27 @@
+/* weaver generated load procedure installer. */
+set nocount on;
+
+declare @weaver_proc_sql nvarchar(max);
+declare @weaver_source_columns nvarchar(max);
+declare @weaver_staging_select_columns nvarchar(max);
+declare @weaver_staging_except_columns nvarchar(max);
+declare @weaver_target_except_columns nvarchar(max);
+declare @weaver_upsert_select_columns nvarchar(max);
+declare @weaver_update_set_columns nvarchar(max);
+
+$column_metadata_sql
+
+if @weaver_source_columns is null
+begin
+    throw 51010, 'weaver: the load target has no loadable columns. Build the table before installing its load.', 1;
+end;
+
+set @weaver_proc_sql = $procedure_template_sql_literal;
+set @weaver_proc_sql = replace(@weaver_proc_sql, N'__SOURCE_COLUMNS__', @weaver_source_columns);
+set @weaver_proc_sql = replace(@weaver_proc_sql, N'__STAGING_SELECT_COLUMNS__', @weaver_staging_select_columns);
+set @weaver_proc_sql = replace(@weaver_proc_sql, N'__STAGING_EXCEPT_COLUMNS__', @weaver_staging_except_columns);
+set @weaver_proc_sql = replace(@weaver_proc_sql, N'__TARGET_EXCEPT_COLUMNS__', @weaver_target_except_columns);
+set @weaver_proc_sql = replace(@weaver_proc_sql, N'__UPSERT_SELECT_COLUMNS__', @weaver_upsert_select_columns);
+set @weaver_proc_sql = replace(@weaver_proc_sql, N'__UPDATE_SET_COLUMNS__', @weaver_update_set_columns);
+
+exec sys.sp_executesql @weaver_proc_sql;

weaver/declaration/templates/load/load_procedure.sql

@@ -0,0 +1,48 @@
+create or alter procedure $load_procedure
+    @fault_tolerant bit = 0
+  , @ignore_stability_threshold bit = 0
+as
+begin
+    set nocount on;
+
+    declare @weaver_load_datetime datetime2(6) = sysutcdatetime();
+    declare @weaver_live_datetime datetime2(6) = convert(datetime2(6), '$live_delete_datetime');
+    declare @weaver_rows_read bigint = 0;
+    declare @weaver_rows_inserted bigint = 0;
+    declare @weaver_rows_updated bigint = 0;
+    declare @weaver_rows_deleted bigint = 0;
+    declare @weaver_rows_rejected bigint = 0;
+    declare @weaver_error varchar(4000) = null;
+    declare @weaver_target_rows bigint = 0;
+    declare @weaver_prospective_deletes bigint = 0;
+    declare @weaver_prospective_updates bigint = 0;
+    declare @weaver_target_before bigint = 0;
+
+$preprocessing_banner
+$start_artifact_cleanup
+
+$staging_sql
+
+    select @weaver_rows_read = count(*) from $staging_table;
+
+$postprocessing_banner
+$load_body
+
+$end_artifact_cleanup
+
+    -- What the target actually lost, from its own cardinality. The delete
+    -- driver says what the load intended; this says what happened, and the two
+    -- differ whenever a key named for deletion was not there to begin with.
+    select @weaver_rows_deleted =
+        @weaver_target_before + @weaver_rows_inserted - count(*)
+    from $target_table;
+
+    select
+        cast(case when @weaver_error is null then 1 else 0 end as bit) as succeeded
+      , @weaver_rows_read as rows_read
+      , @weaver_rows_inserted as rows_inserted
+      , @weaver_rows_updated as rows_updated
+      , @weaver_rows_deleted as rows_deleted
+      , @weaver_rows_rejected as rows_rejected
+      , @weaver_error as error_message;
+end;

weaver/declaration/templates/load/primary_key_body.sql

@@ -0,0 +1,113 @@
+create table $reject_table as
+select
+    __STAGING_SELECT_COLUMNS__
+  , case
+        when $staging_blank_predicate then cast('$blank_reason' as varchar(100))
+        else cast('$duplicate_reason' as varchar(100))
+    end as [$rejection_reason]
+from $staging_table as s
+where $staging_blank_predicate
+   or s.[$rank_column] > 1;
+
+select @weaver_rows_rejected = count(*) from $reject_table;
+
+delete s
+from $staging_table as s
+where $staging_blank_predicate
+   or s.[$rank_column] > 1;
+
+-- Intolerant of rejects: the target is left exactly as it was. Nothing has been
+-- written yet, so refusing here is a decision not to start rather than an
+-- unwind — and the reject table survives as the evidence.
+--
+-- Raised rather than returned, so `exec [_].[Load S.N]` fails the same way
+-- `.load()` does. A primitive that returned a quiet row where its sibling
+-- raised would make every caller special-case which one it was talking to.
+if @weaver_rows_rejected > 0 and @fault_tolerant = 0
+    throw 51020, '$intolerant_message', 1;
+
+create table $upsert_table as
+select
+    __STAGING_SELECT_COLUMNS__
+  , case when $target_missing_predicate then cast(1 as int) else cast(0 as int) end as [_Is new row]
+from $staging_table as s
+left join $target_table as t on $staging_target_join
+where
+    $target_missing_predicate
+    or exists (
+        select __STAGING_EXCEPT_COLUMNS__
+        except
+        select __TARGET_EXCEPT_COLUMNS__
+    );
+
+-- Everything this load is about to do, counted before it does any of it. A
+-- breach with @fault_tolerant = 0 leaves the target exactly as it was, so
+-- refusing is a decision not to start rather than an unwind.
+select @weaver_target_rows = count(*) from $target_table;
+set @weaver_target_before = @weaver_target_rows;
+select @weaver_prospective_updates = count(*) from $upsert_table where [_Is new row] = 0;
+$prospective_deletes
+
+if @ignore_stability_threshold = 0 and @weaver_target_rows > 0
+    and @weaver_target_rows >= $stability_rows
+begin
+    if @weaver_prospective_deletes * 100.0 / @weaver_target_rows > $delete_threshold
+        set @weaver_error = 'delete of ' + cast(@weaver_prospective_deletes as varchar(20))
+            + ' rows is over the $delete_threshold% threshold of '
+            + cast(@weaver_target_rows as varchar(20));
+    else if @weaver_prospective_updates * 100.0 / @weaver_target_rows > $update_threshold
+        set @weaver_error = 'update of ' + cast(@weaver_prospective_updates as varchar(20))
+            + ' rows is over the $update_threshold% threshold of '
+            + cast(@weaver_target_rows as varchar(20));
+
+    -- A breach never writes. Tolerating exactly the change the threshold was
+    -- declared to prevent would defeat the guard, so @fault_tolerant decides
+    -- only whether the refusal is raised or returned. Permitting it is what
+    -- @ignore_stability_threshold is for.
+    if @weaver_error is not null
+    begin
+        set @weaver_error = @weaver_error + '; the target was not modified';
+        if @fault_tolerant = 0
+            throw 51021, @weaver_error, 1;
+        select
+            cast(0 as bit) as succeeded
+          , @weaver_rows_read as rows_read
+          , cast(0 as bigint) as rows_inserted
+          , cast(0 as bigint) as rows_updated
+          , cast(0 as bigint) as rows_deleted
+          , @weaver_rows_rejected as rows_rejected
+          , @weaver_error as error_message;
+        return;
+    end;
+end;
+
+insert into $target_table (
+    __SOURCE_COLUMNS__
+  , [Row insert datetime]
+  , [Row update datetime]
+  , [Row delete datetime]
+)
+select
+    __UPSERT_SELECT_COLUMNS__
+  , @weaver_load_datetime
+  , @weaver_load_datetime
+  , @weaver_live_datetime
+from $upsert_table as u
+where u.[_Is new row] = 1;
+
+set @weaver_rows_inserted = @@rowcount;
+
+update c
+set
+    __UPDATE_SET_COLUMNS__
+from $target_table as c
+inner join $upsert_table as u on $target_upsert_join
+where u.[_Is new row] = 0;
+
+set @weaver_rows_updated = @@rowcount;
+
+$missing_reconciliation
+
+if @weaver_rows_rejected > 0 and @weaver_error is null
+    set @weaver_error = cast(@weaver_rows_rejected as varchar(20))
+        + ' $tolerated_message';