Initial publish of dbt_f2dq (f2dq) package v0.12.1.

Clean package repo for Gitea installs via packages.yml git URL.

Co-authored-by: Cursor <cursoragent@cursor.com>

macros/metrics/base/build_in/column_default.sql

@@ -0,0 +1,91 @@
+
+{% macro f2dq_metric_max(context) %}
+    max({{context.column_name}})
+{% endmacro %}
+
+{% macro f2dq_metric_min(context) %}
+    min({{context.column_name}})
+{% endmacro %}
+
+{% macro f2dq_metric_avg(context) %}
+    avg(cast ({{context.column_name}} as {{ numeric_type() }}))
+{% endmacro %}
+
+{% macro f2dq_metric_stddev(context) %}
+    stddev(cast ( {{context.column_name}} as {{ numeric_type() }}))
+{% endmacro %}
+
+{% macro f2dq_metric_variance(context) %}
+    variance(cast ( {{context.column_name}} as {{ numeric_type() }}))
+{% endmacro %}
+
+{% macro f2dq_metric_max_length(context) %}
+    max(length({{context.column_name}}))
+{% endmacro %}
+
+{% macro f2dq_metric_min_length(context) %}
+    min(length({{context.column_name}}))
+{% endmacro %}
+
+{% macro f2dq_metric_avg_length(context) %}
+    avg(cast (length( {{context.column_name}} ) as {{ numeric_type() }}))
+{% endmacro %}
+
+{% macro f2dq_metric_nulls_count(context) %}
+    coalesce(
+        sum(
+            case when {{context.column_name}} is null
+                then 1
+            else 0
+            end
+        ), 0
+    )
+{% endmacro %}
+
+{% macro f2dq_metric_missing_count(context) %}
+    coalesce(
+        sum(
+            case 
+            when {{context.column_name}} is null
+                then 1
+            when {{context.column_name}} = ''
+                then 1
+            else 0
+            end
+        ), 0
+    )
+{% endmacro %}
+
+{% macro f2dq_metric_nulls_percent(context) %}
+    {{ percentage_formula(f2dq_metric_nulls_count(context), f2dq_metric_row_count()) }}
+{% endmacro %}
+
+{% macro f2dq_metric_missing_percent(context) %}
+    {{ percentage_formula(f2dq_metric_missing_count(context), f2dq_metric_row_count()) }}
+{% endmacro %}
+
+{% macro f2dq_metric_count_true(context) %}
+    COALESCE(
+        SUM(
+            CASE
+                WHEN {{ context.column_name }} IS TRUE THEN 1
+                ELSE 0
+            END
+        ),
+        0
+    )
+{% endmacro %}
+
+{% macro f2dq_metric_count_false(context) %}
+    COALESCE(
+        SUM(
+            CASE
+                WHEN {{ context.column_name }} IS FALSE THEN 1
+                ELSE 0
+            END
+        ),
+        0
+    )
+{% endmacro %}
+
+

macros/metrics/base/build_in/optional_column_metrics.sql

@@ -0,0 +1,104 @@
+{% macro f2dq_metric_regex_count(column_name, pattern) %}
+    coalesce(
+        sum(
+            case when {{ regex_match_expression(column_name, pattern) }}
+                then 1
+            else 0
+            end
+        ), 0
+    )
+{% endmacro %}
+
+{% macro f2dq_metric_match_regex(context) %}
+    {{ f2dq_metric_regex_count(context.column_name, context.config.regex) }}
+{% endmacro %}
+
+{% macro f2dq_metric_match_regex_percent(context) %}
+    {{ percentage_formula(f2dq_metric_match_regex(context), f2dq_metric_row_count()) }}
+{% endmacro %}
+
+{% macro f2dq_metric_not_match_regex(context) %}
+    {{ f2dq_metric_row_count() }} - {{ f2dq_metric_regex_count(context.column_name, context.config.regex) }}
+{% endmacro %}
+
+{% macro f2dq_metric_not_match_regex_percent(context) %}
+    {{ percentage_formula(f2dq_metric_not_match_regex(context), f2dq_metric_row_count()) }}
+{% endmacro %}
+
+{% macro f2dq_metric_distinct_values(context) %}
+    {{ distinct_values(context) }}
+{% endmacro %}
+
+{% macro distinct_values(context) %}
+    {{ adapter.dispatch('distinct_values', 'f2dq')(context) }}
+{% endmacro %}
+
+{% macro default__distinct_values(context) %}
+    coalesce(
+        count(distinct {{ context.column_name }} )
+    , 0)
+{% endmacro %}
+
+{% macro postgres__distinct_values(context) %}
+    {# /* In postgres, its faster to count distinct values in a column by selecting then counting in separate steps */ #}
+    with temp_table as (
+            select distinct {{ context.column_name }} from {{ context.table_name }}
+            where {{ in_time_window(context.time_filter) }}
+        )
+    select coalesce(count(*), 0) from temp_table
+{% endmacro %}
+
+{% macro f2dq_metric_approx_distinct_values(context) %}
+    {{ approx_distinct_values(context) }}
+{% endmacro %}
+
+{% macro approx_distinct_values(context) %}
+    {{ adapter.dispatch('approx_distinct_values', 'f2dq')(context) }}
+{% endmacro %}
+
+{% macro default__approx_distinct_values(context) %}
+    {# /* No approximate distinct count in postgres so we default to using a distinct count */ #}
+    {{ f2dq_metric_distinct_values(context) }}
+{% endmacro %}
+
+{% macro redshift__approx_distinct_values(context) %}
+    approximate {{ f2dq_metric_distinct_values(context.column_name) }}
+{% endmacro %}
+
+{% macro bigquery__approx_distinct_values(context) %}
+    approx_count_distinct({{ context.column_name }})
+{% endmacro %}
+
+{% macro snowflake__approx_distinct_values(context) %}
+    approx_count_distinct({{ context.column_name }})
+{% endmacro %}
+
+{% macro f2dq_metric_duplicate_values(context) %}
+        with temp_table as (
+            select {{ context.column_name }} from {{ context.table_name }}
+            where {{ in_time_window(context.time_filter) }}
+            group by {{ context.column_name }}
+            having count(1) > 1
+        )
+        select coalesce(count(*), 0) from temp_table
+{% endmacro %}
+
+{% macro f2dq_metric_duplicate_rows(context) %}
+        with temp_table as (
+            select {{ context.column_name }}, count(1) as row_count from {{ context.table_name }}
+            where {{ in_time_window(context.time_filter) }}
+            group by {{ context.column_name }}
+            having count(1) > 1
+        )
+        select coalesce(sum(row_count), 0) from temp_table
+{% endmacro %}
+
+{% macro f2dq_metric_unique_rows(context) %}
+        with temp_table as (
+            select {{ context.column_name }}, count(1) as row_count from {{ context.table_name }}
+            where {{ in_time_window(context.time_filter) }}
+            group by {{ context.column_name }}
+            having count(1) = 1
+        )
+        select coalesce(sum(row_count), 0) from temp_table
+{% endmacro %}

macros/metrics/base/build_in/optional_table_metrics.sql

@@ -0,0 +1,7 @@
+{% macro f2dq_metric_distinct_table_rows(context) %}
+    with temp_table AS (
+            select distinct * from {{ context.table_name }}
+            where {{ in_time_window(context.time_filter) }}
+        )
+    select coalesce(count(*), 0) FROM temp_table
+{% endmacro %}

macros/metrics/base/build_in/table_default.sql

@@ -0,0 +1,33 @@
+
+{% macro f2dq_metric_row_count(context) %}
+    count(1)
+{% endmacro %}
+
+{% macro f2dq_metric_freshness(context) %}
+    {{ freshness_expression(context.time_filter) }}
+{% endmacro %}
+
+{% macro freshness_expression(time_filter) %}
+    {# /* If time_filter is none, we are computing the metric globally. we set the value as null since a table without use of a time filter doesn't really have a freshness metric */ #}
+    {% if time_filter is none %}
+        cast(null as {{ numeric_type() }})
+    {% else %}
+        {{ adapter.dispatch('freshness_expression', 'f2dq')(time_filter) }}
+    {% endif %}
+{% endmacro %}
+
+{% macro default__freshness_expression(time_filter) %}
+    EXTRACT(EPOCH FROM ({{time_window_end()}} - max({{time_filter}})))
+{% endmacro %}
+
+{% macro bigquery__freshness_expression(time_filter) %}
+    TIMESTAMP_DIFF ( timestamp({{ time_window_end()}}), timestamp(max({{time_filter}})), SECOND)
+{% endmacro %}
+
+{% macro snowflake__freshness_expression(time_filter) %}
+    timediff(second, max({{time_filter}}), {{- time_window_end() -}})
+{% endmacro %}
+
+{% macro redshift__freshness_expression(time_filter) %}
+    DATEDIFF(second, max({{time_filter}}), {{- time_window_end() -}})
+{% endmacro %}