dataops-testgen 2.2.0__py3-none-any.whl

testgen/template/execution/ex_finalize_test_run_results.sql

@@ -0,0 +1,37 @@
+UPDATE test_results
+   SET test_description = COALESCE(r.test_description, d.test_description, tt.test_description),
+       severity = COALESCE(d.severity, s.severity, tt.default_severity),
+       threshold_value = COALESCE(r.threshold_value, d.threshold_value),
+       result_status = CASE
+                         WHEN r.result_code = 1 THEN 'Passed'
+                         WHEN r.result_code = 0
+                          AND COALESCE(d.severity, s.severity, tt.default_severity) = 'Warning' THEN 'Warning'
+                         WHEN r.result_code = 0
+                          AND COALESCE(d.severity, s.severity, tt.default_severity) = 'Fail' THEN 'Failed'
+                         WHEN r.result_code = 0 THEN 'Warning'
+                       END,
+       observability_status = CASE
+                                WHEN r.observability_status = 'Sent' THEN 'Sent'
+                                WHEN COALESCE(d.export_to_observability, s.export_to_observability) = 'Y' THEN 'Queued'
+                                WHEN COALESCE(d.export_to_observability, s.export_to_observability) = 'N' THEN 'Ignore'
+                              END,
+       result_message = COALESCE(r.result_message,
+                                 tt.measure_uom || ': ' || r.result_measure::VARCHAR
+                                  || ', Threshold: ' || d.threshold_value::VARCHAR
+                                  || CASE
+                                       WHEN r.skip_errors > 0 THEN 'Errors Ignored: ' || r.skip_errors::VARCHAR
+                                       ELSE ''
+                                     END),
+      table_groups_id = d.table_groups_id,
+      test_suite_id = s.id,
+      auto_gen = d.last_auto_gen_date IS NOT NULL
+  FROM test_results r
+INNER JOIN test_suites s
+   ON (r.project_code = s.project_code
+  AND  r.test_suite = s.test_suite)
+INNER JOIN test_definitions d
+   ON (r.test_definition_id = d.id)
+INNER JOIN test_types tt
+   ON (r.test_type = tt.test_type)
+WHERE r.test_run_id = '{TEST_RUN_ID}'
+  AND test_results.id = r.id;

testgen/template/execution/ex_get_tests_non_cat.sql

@@ -0,0 +1,47 @@
+SELECT tt.test_type,
+       s.id::VARCHAR as test_definition_id,
+       COALESCE(s.test_description, tt.test_description) as test_description,
+       COALESCE(s.test_action, g.test_action, '')      as test_action,
+       schema_name,
+       table_name,
+       column_name,
+       cast(coalesce(skip_errors, 0) as varchar(50))   as skip_errors,
+       coalesce(baseline_ct, '')                       as baseline_ct,
+       coalesce(baseline_unique_ct, '')                as baseline_unique_ct,
+       coalesce(baseline_value, '')                    as baseline_value,
+       coalesce(baseline_value_ct, '')                 as baseline_value_ct,
+       coalesce(threshold_value, '')                   as threshold_value,
+       coalesce(baseline_sum, '')                      as baseline_sum,
+       coalesce(baseline_avg, '')                      as baseline_avg,
+       coalesce(baseline_sd, '')                       as baseline_sd,
+       case
+           when nullif(subset_condition, '') is null then '1=1'
+           else subset_condition end                   as subset_condition,
+       coalesce(groupby_names, '')                     as groupby_names,
+       case
+           when having_condition is null then ''
+           else concat('WHERE ', having_condition) end as having_condition,
+       coalesce(window_date_column, '')                as window_date_column,
+       cast(coalesce(window_days, '0') as varchar(50)) as window_days,
+       coalesce(match_schema_name, '')                 as match_schema_name,
+       coalesce(match_table_name, '')                  as match_table_name,
+       coalesce(match_column_names, '')                as match_column_names,
+       case
+           when nullif(match_subset_condition, '') is null then '1=1'
+           else match_subset_condition end             as match_subset_condition,
+       coalesce(match_groupby_names, '')               as match_groupby_names,
+       coalesce(match_having_condition, '')            as match_having_condition,
+       coalesce(custom_query, '')                      as custom_query,
+       coalesce(tm.template_name, '')                  as template_name
+FROM test_definitions s
+         INNER JOIN test_suites g
+                    ON (s.test_suite = g.test_suite)
+         INNER JOIN test_types tt
+                    ON (s.test_type = tt.test_type)
+         LEFT JOIN test_templates tm
+                    ON (s.test_type = tm.test_type
+                   AND  '{SQL_FLAVOR}' = tm.sql_flavor)
+WHERE s.project_code = '{PROJECT_CODE}'
+  AND s.test_suite = '{TEST_SUITE}'
+  AND tt.run_type = 'QUERY'
+  AND s.test_active = 'Y';

testgen/template/execution/ex_update_test_record_in_testrun_table.sql

@@ -0,0 +1,27 @@
+WITH stats
+   AS ( SELECT r.id as test_run_id,
+               COALESCE(COUNT(tr.id)                      , 0)                     AS test_ct,
+               SUM(result_code)                                                    AS passed_ct,
+               COALESCE(SUM(CASE WHEN tr.result_status = 'Failed' THEN 1 END), 0)  AS failed_ct,
+               COALESCE(SUM(CASE WHEN tr.result_status = 'Warning' THEN 1 END), 0) AS warning_ct,
+               COALESCE(SUM(CASE WHEN tr.result_message ILIKE 'ERROR%' THEN 1 ELSE 0 END), 0) AS error_ct
+          FROM test_runs r
+        INNER JOIN test_results tr
+                ON r.id = tr.test_run_id
+         WHERE r.id = '{TEST_RUN_ID}'::UUID
+        GROUP BY r.id )
+UPDATE test_runs
+   SET status = CASE WHEN length('{EXCEPTION_MESSAGE}') = 0 then 'Complete' else 'Error' end,
+       test_endtime = '{NOW}',
+       log_message = '{EXCEPTION_MESSAGE}',
+       duration = TO_CHAR('{NOW}' - r.test_starttime, 'HH24:MI:SS'),
+       test_ct = s.test_ct,
+       passed_ct = s.passed_ct,
+       failed_ct = s.failed_ct,
+       warning_ct = s.warning_ct,
+       error_ct = s.error_ct
+  FROM test_runs r
+LEFT JOIN stats s
+   ON r.id = s.test_run_id
+WHERE r.id = '{TEST_RUN_ID}'::UUID
+  AND r.id = test_runs.id;

testgen/template/execution/ex_write_test_record_to_testrun_table.sql

@@ -0,0 +1,6 @@
+INSERT INTO test_runs (id, project_code, test_suite, test_starttime, process_id)
+(SELECT '{TEST_RUN_ID}' :: UUID  as id,
+        '{PROJECT_CODE}' as project_code,
+        '{TEST_SUITE}' as test_suite,
+        '{RUN_DATE}' as test_starttime,
+        '{PROCESS_ID}'as process_id);

testgen/template/flavors/generic/exec_query_tests/ex_aggregate_match_no_drops_generic.sql

@@ -0,0 +1,48 @@
+SELECT '{PROJECT_CODE}' as project_code, '{TEST_TYPE}' as test_type,
+       '{TEST_DEFINITION_ID}' as test_definition_id,
+       '{TEST_SUITE}' as test_suite,
+       '{TEST_RUN_ID}' as test_run_id,
+       '{RUN_DATE}'    as test_time,
+       '{START_TIME}'  as starttime,
+       CURRENT_TIMESTAMP       as endtime,
+       '{SCHEMA_NAME}' as schema_name,
+       '{TABLE_NAME}'  as table_name,
+       '{COLUMN_NAME_NO_QUOTES}' as column_names,
+       '{SKIP_ERRORS}' as threshold_value,
+       {SKIP_ERRORS} as skip_errors,
+       '{INPUT_PARAMETERS}' as input_parameters,
+    CASE WHEN COUNT (*) > {SKIP_ERRORS} THEN 0 ELSE 1 END as result_code,
+       CASE
+        WHEN COUNT(*) > 0 THEN
+               CONCAT(
+                      CONCAT( CAST(COUNT(*) AS VARCHAR), ' error(s) identified, ' ),
+       CONCAT(
+                             CASE
+                               WHEN COUNT(*) > {SKIP_ERRORS} THEN 'exceeding limit of '
+                                                                        ELSE 'within limit of '
+                             END,
+                             '{SKIP_ERRORS}.'
+                    )
+                      )
+        ELSE 'No errors found.'
+       END AS result_message,
+       COUNT(*) as result_measure,
+       '{SUBSET_DISPLAY}' as subset_condition,
+       NULL as result_query
+FROM ( SELECT {GROUPBY_NAMES}, SUM(TOTAL) as total, SUM(MATCH_TOTAL) as MATCH_TOTAL
+         FROM
+              ( SELECT {GROUPBY_NAMES}, {COLUMN_NAME_NO_QUOTES} as total, NULL as match_total
+       FROM {SCHEMA_NAME}.{TABLE_NAME}
+       WHERE {SUBSET_CONDITION}
+       GROUP BY {GROUPBY_NAMES}
+       {HAVING_CONDITION}
+              UNION ALL
+                SELECT {MATCH_GROUPBY_NAMES}, NULL as total, {MATCH_COLUMN_NAMES} as match_total
+                  FROM {MATCH_SCHEMA_NAME}.{MATCH_TABLE_NAME}
+                WHERE {MATCH_SUBSET_CONDITION}
+                GROUP BY {MATCH_GROUPBY_NAMES}
+                {MATCH_HAVING_CONDITION} ) a
+         GROUP BY {GROUPBY_NAMES} ) s
+         WHERE total < match_total
+--             OR (total IS NOT NULL AND match_total IS NULL)   -- New categories
+             OR (total IS NULL AND match_total IS NOT NULL);    -- Dropped categories

testgen/template/flavors/generic/exec_query_tests/ex_aggregate_match_num_incr_generic.sql

@@ -0,0 +1,34 @@
+SELECT '{PROJECT_CODE}' as project_code, '{TEST_TYPE}' as test_type,
+       '{TEST_DEFINITION_ID}' as test_definition_id,
+       '{TEST_SUITE}' as test_suite,
+       '{RUN_DATE}' as test_time, '{START_TIME}' as starttime, CURRENT_TIMESTAMP as endtime,
+       '{SCHEMA_NAME}' as schema_name, '{TABLE_NAME}' as table_name, '{GROUPBY_NAMES}' as column_name,
+       {SKIP_ERRORS} as skip_errors,
+       'match_schema_name = {MATCH_SCHEMA_NAME}, match_table_name = {MATCH_TABLE_NAME}, match_groupby_names = {MATCH_GROUPBY_NAMES} ,match_column_names = {MATCH_COLUMN_NAMES}, match_subset_condition = {MATCH_SUBSET_CONDITION}, match_having_condition = {MATCH_HAVING_CONDITION}, mode = {MODE}'
+         as input_parameters,
+       CASE WHEN COUNT(*) > COALESCE(skip_errors, 0) THEN 0 ELSE 1 END as result_code,
+       CONCAT(
+             CONCAT( 'Mismatched measures: ', CAST( COALESCE(COUNT(*), 0) AS VARCHAR) ),
+             CONCAT( ', Threshold: ',
+                     CONCAT( CAST(COALESCE(skip_errors, 0) AS VARCHAR), '.')
+                    )
+              )  AS result_message,
+       COUNT(*) as result_measure,
+       '{TEST_ACTION}' as test_action,
+       '{SUBSET_CONDITION}' as subset_condition,
+       NULL as result_query,
+       '{TEST_DESCRIPTION}' as test_description
+FROM (
+      SELECT {GROUPBY_NAMES}, {SUM_COLUMNS}
+       FROM {SCHEMA_NAME}.{TABLE_NAME}
+       WHERE {SUBSET_CONDITION}
+       GROUP BY {GROUPBY_NAMES}
+       {HAVING_CONDITION}
+           UNION ALL
+       SELECT {MATCH_GROUPBY_NAMES}, {MATCH_SUM_COLUMNS}
+       FROM {MATCH_SCHEMA_NAME}.{MATCH_TABLE_NAME}
+       WHERE {MATCH_SUBSET_CONDITION}
+       GROUP BY {MATCH_GROUPBY_NAMES}
+       {MATCH_HAVING_CONDITION}
+          )
+     ) a ;

testgen/template/flavors/generic/exec_query_tests/ex_aggregate_match_percent_above_generic.sql

@@ -0,0 +1,49 @@
+SELECT '{PROJECT_CODE}'   as project_code,
+       '{TEST_TYPE}'   as test_type,
+       '{TEST_DEFINITION_ID}' as test_definition_id,
+       '{TEST_SUITE}'  as test_suite,
+       '{TEST_RUN_ID}' as test_run_id,
+       '{RUN_DATE}'    as test_time,
+       '{START_TIME}'  as starttime,
+       CURRENT_TIMESTAMP       as endtime,
+       '{SCHEMA_NAME}' as schema_name,
+       '{TABLE_NAME}'  as table_name,
+       '{COLUMN_NAME_NO_QUOTES}' as column_names,
+       '{THRESHOLD_VALUE}' as threshold_value,
+       {SKIP_ERRORS} as skip_errors,
+       '{INPUT_PARAMETERS}' as input_parameters,
+    CASE WHEN COUNT (*) > {SKIP_ERRORS} THEN 0 ELSE 1 END as result_code,
+       CASE
+        WHEN COUNT(*) > 0 THEN
+               CONCAT(
+                      CONCAT( CAST(COUNT(*) AS VARCHAR), ' error(s) identified, ' ),
+                      CONCAT(
+                             CASE
+                               WHEN COUNT(*) > {SKIP_ERRORS} THEN 'exceeding limit of '
+                                                                        ELSE 'within limit of '
+                             END,
+                             '{SKIP_ERRORS}.'
+                             )
+                      )
+        ELSE 'No errors found.'
+       END AS result_message,
+       COUNT(*) as result_measure,
+       '{SUBSET_DISPLAY}' as subset_condition,
+       NULL as result_query
+FROM ( SELECT {GROUPBY_NAMES}, SUM(TOTAL) as total, SUM(MATCH_TOTAL) as MATCH_TOTAL
+         FROM
+              ( SELECT {GROUPBY_NAMES}, {COLUMN_NAME_NO_QUOTES} as total, NULL as match_total
+                  FROM {SCHEMA_NAME}.{TABLE_NAME}
+                WHERE {SUBSET_CONDITION}
+                GROUP BY {GROUPBY_NAMES}
+                {HAVING_CONDITION}
+              UNION ALL
+                SELECT {MATCH_GROUPBY_NAMES}, NULL as total, {MATCH_COLUMN_NAMES} as match_total
+                  FROM {MATCH_SCHEMA_NAME}.{MATCH_TABLE_NAME}
+                WHERE {MATCH_SUBSET_CONDITION}
+                GROUP BY {MATCH_GROUPBY_NAMES}
+                {MATCH_HAVING_CONDITION} ) a
+         GROUP BY {GROUPBY_NAMES} ) s
+         WHERE NOT total BETWEEN match_total AND match_total * (1 + {BASELINE_VALUE}::FLOAT/100.0)
+            OR (total IS NOT NULL AND match_total IS NULL)
+            OR (total IS NULL AND match_total IS NOT NULL);

testgen/template/flavors/generic/exec_query_tests/ex_aggregate_match_percent_within_generic.sql

@@ -0,0 +1,49 @@
+SELECT '{PROJECT_CODE}'   as project_code,
+       '{TEST_TYPE}'   as test_type,
+       '{TEST_DEFINITION_ID}' as test_definition_id,
+       '{TEST_SUITE}'  as test_suite,
+       '{TEST_RUN_ID}' as test_run_id,
+       '{RUN_DATE}'    as test_time,
+       '{START_TIME}'  as starttime,
+       CURRENT_TIMESTAMP       as endtime,
+       '{SCHEMA_NAME}' as schema_name,
+       '{TABLE_NAME}'  as table_name,
+       '{COLUMN_NAME_NO_QUOTES}' as column_names,
+       '{THRESHOLD_VALUE}' as threshold_value,
+       {SKIP_ERRORS} as skip_errors,
+       '{INPUT_PARAMETERS}' as input_parameters,
+    CASE WHEN COUNT (*) > {SKIP_ERRORS} THEN 0 ELSE 1 END as result_code,
+       CASE
+        WHEN COUNT(*) > 0 THEN
+               CONCAT(
+                      CONCAT( CAST(COUNT(*) AS VARCHAR), ' error(s) identified, ' ),
+                      CONCAT(
+                             CASE
+                               WHEN COUNT(*) > {SKIP_ERRORS} THEN 'exceeding limit of '
+                                                                        ELSE 'within limit of '
+                             END,
+                             '{SKIP_ERRORS}.'
+                             )
+                      )
+        ELSE 'No errors found.'
+       END AS result_message,
+       COUNT(*) as result_measure,
+       '{SUBSET_DISPLAY}' as subset_condition,
+       NULL as result_query
+FROM ( SELECT {GROUPBY_NAMES}, SUM(TOTAL) as total, SUM(MATCH_TOTAL) as MATCH_TOTAL
+         FROM
+              ( SELECT {GROUPBY_NAMES}, {COLUMN_NAME_NO_QUOTES} as total, NULL as match_total
+                  FROM {SCHEMA_NAME}.{TABLE_NAME}
+                WHERE {SUBSET_CONDITION}
+                GROUP BY {GROUPBY_NAMES}
+                {HAVING_CONDITION}
+              UNION ALL
+                SELECT {MATCH_GROUPBY_NAMES}, NULL as total, {MATCH_COLUMN_NAMES} as match_total
+                  FROM {MATCH_SCHEMA_NAME}.{MATCH_TABLE_NAME}
+                WHERE {MATCH_SUBSET_CONDITION}
+                GROUP BY {MATCH_GROUPBY_NAMES}
+                {MATCH_HAVING_CONDITION} ) a
+         GROUP BY {GROUPBY_NAMES} ) s
+         WHERE NOT total BETWEEN match_total * (1 - {BASELINE_VALUE}::FLOAT/100.0) AND match_total * (1 + {BASELINE_VALUE}::FLOAT/100.0)
+            OR (total IS NOT NULL AND match_total IS NULL)
+            OR (total IS NULL AND match_total IS NOT NULL);

testgen/template/flavors/generic/exec_query_tests/ex_aggregate_match_same_generic.sql

@@ -0,0 +1,49 @@
+SELECT '{PROJECT_CODE}'   as project_code,
+       '{TEST_TYPE}'   as test_type,
+       '{TEST_DEFINITION_ID}' as test_definition_id,
+       '{TEST_SUITE}'  as test_suite,
+       '{TEST_RUN_ID}' as test_run_id,
+       '{RUN_DATE}'    as test_time,
+       '{START_TIME}'  as starttime,
+       CURRENT_TIMESTAMP       as endtime,
+       '{SCHEMA_NAME}' as schema_name,
+       '{TABLE_NAME}'  as table_name,
+       '{COLUMN_NAME_NO_QUOTES}' as column_names,
+       '{SKIP_ERRORS}' as threshold_value,
+       {SKIP_ERRORS} as skip_errors,
+       '{INPUT_PARAMETERS}' as input_parameters,
+       CASE WHEN COUNT (*) > {SKIP_ERRORS} THEN 0 ELSE 1 END as result_code,
+       CASE
+        WHEN COUNT(*) > 0 THEN
+               CONCAT(
+                      CONCAT( CAST(COUNT(*) AS VARCHAR), ' error(s) identified, ' ),
+                      CONCAT(
+                             CASE
+                               WHEN COUNT(*) > {SKIP_ERRORS} THEN 'exceeding limit of '
+                                                                        ELSE 'within limit of '
+                             END,
+                             '{SKIP_ERRORS}.'
+                             )
+                      )
+        ELSE 'No errors found.'
+       END AS result_message,
+       COUNT(*) as result_measure,
+       '{SUBSET_DISPLAY}' as subset_condition,
+       NULL as result_query
+FROM ( SELECT {GROUPBY_NAMES}, SUM(TOTAL) as total, SUM(MATCH_TOTAL) as MATCH_TOTAL
+         FROM
+              ( SELECT {GROUPBY_NAMES}, {COLUMN_NAME_NO_QUOTES} as total, NULL as match_total
+       FROM {SCHEMA_NAME}.{TABLE_NAME}
+       WHERE {SUBSET_CONDITION}
+       GROUP BY {GROUPBY_NAMES}
+       {HAVING_CONDITION}
+              UNION ALL
+                SELECT {MATCH_GROUPBY_NAMES}, NULL as total, {MATCH_COLUMN_NAMES} as match_total
+       FROM {MATCH_SCHEMA_NAME}.{MATCH_TABLE_NAME}
+       WHERE {MATCH_SUBSET_CONDITION}
+       GROUP BY {MATCH_GROUPBY_NAMES}
+                {MATCH_HAVING_CONDITION} ) a
+         GROUP BY {GROUPBY_NAMES} ) s
+         WHERE total <> match_total
+             OR (total IS NOT NULL AND match_total IS NULL)
+             OR (total IS NULL AND match_total IS NOT NULL);

testgen/template/flavors/generic/exec_query_tests/ex_custom_query_generic.sql

@@ -0,0 +1,39 @@
+SELECT '{PROJECT_CODE}'   as project_code,
+       '{TEST_TYPE}'   as test_type,
+       '{TEST_DEFINITION_ID}' as test_definition_id,
+       '{TEST_SUITE}'  as test_suite,
+       '{TEST_RUN_ID}' as test_run_id,
+       '{RUN_DATE}'    as test_time,
+       '{START_TIME}'  as starttime,
+       CURRENT_TIMESTAMP       as endtime,
+       '{SCHEMA_NAME}' as schema_name,
+       '{TABLE_NAME}'  as table_name,
+       CASE
+         WHEN '{COLUMN_NAME_NO_QUOTES}' = '' OR '{COLUMN_NAME_NO_QUOTES}' IS NULL THEN 'N/A'
+         ELSE '{COLUMN_NAME_NO_QUOTES}'
+       END as column_names,
+    '{SKIP_ERRORS}' as threshold_value,
+    {SKIP_ERRORS} as skip_errors,
+    /*  TODO:  'custom_query= {CUSTOM_QUERY_ESCAPED}' as input_parameters,  */
+    'Skip_Errors={SKIP_ERRORS}' as input_parameters,
+    CASE WHEN COUNT (*) > {SKIP_ERRORS} THEN 0 ELSE 1 END as result_code,
+       CASE
+        WHEN COUNT(*) > 0 THEN
+               CONCAT(
+                      CONCAT( CAST(COUNT(*) AS VARCHAR), ' error(s) identified, ' ),
+                      CONCAT(
+                             CASE
+                               WHEN COUNT(*) > {SKIP_ERRORS} THEN 'exceeding limit of '
+                                                                        ELSE 'within limit of '
+                             END,
+                             '{SKIP_ERRORS}.'
+                             )
+                      )
+        ELSE 'No errors found.'
+       END AS result_message,
+       COUNT(*) as result_measure,
+       NULL as subset_condition,
+       NULL as result_query
+  FROM (
+        {CUSTOM_QUERY}
+       ) TEST;

testgen/template/flavors/generic/exec_query_tests/ex_data_match_2way_generic.sql

@@ -0,0 +1,58 @@
+SELECT '{PROJECT_CODE}'   as project_code,
+       '{TEST_TYPE}'   as test_type,
+       '{TEST_DEFINITION_ID}' as test_definition_id,
+       '{TEST_SUITE}'  as test_suite,
+       '{TEST_RUN_ID}' as test_run_id,
+       '{RUN_DATE}'    as test_time,
+       '{START_TIME}'  as starttime,
+       CURRENT_TIMESTAMP       as endtime,
+       '{SCHEMA_NAME}' as schema_name,
+       '{TABLE_NAME}'  as table_name,
+       '{COLUMN_NAME_NO_QUOTES}' as column_names,
+       '{SKIP_ERRORS}' as threshold_value,
+       {SKIP_ERRORS} as skip_errors,
+       '{INPUT_PARAMETERS}' as input_parameters,
+       CASE WHEN COUNT (*) > {SKIP_ERRORS} THEN 0 ELSE 1 END as result_code,
+       CASE
+        WHEN COUNT(*) > 0 THEN
+               CONCAT(
+                      CONCAT( CAST(COUNT(*) AS VARCHAR), ' error(s) identified, ' ),
+                      CONCAT(
+                             CASE
+                               WHEN COUNT(*) > {SKIP_ERRORS} THEN 'exceeding limit of '
+                                                                        ELSE 'within limit of '
+                             END,
+                             '{SKIP_ERRORS}.'
+                             )
+                      )
+        ELSE 'No errors found.'
+       END AS result_message,
+       COUNT(*) as result_measure,
+       '{SUBSET_DISPLAY}' as subset_condition,
+       NULL as result_query
+  FROM (
+         ( SELECT {GROUPBY_NAMES}
+             FROM {SCHEMA_NAME}.{TABLE_NAME}
+             WHERE {SUBSET_CONDITION}
+           GROUP BY {GROUPBY_NAMES}
+           {HAVING_CONDITION}
+            EXCEPT
+           SELECT {MATCH_COLUMN_NAMES}
+             FROM {MATCH_SCHEMA_NAME}.{MATCH_TABLE_NAME}
+            WHERE {MATCH_SUBSET_CONDITION}
+           GROUP BY {MATCH_GROUPBY_NAMES}
+           {MATCH_HAVING_CONDITION}  )
+          UNION
+         ( SELECT {MATCH_COLUMN_NAMES}
+             FROM {MATCH_SCHEMA_NAME}.{MATCH_TABLE_NAME}
+            WHERE {MATCH_SUBSET_CONDITION}
+           GROUP BY {MATCH_GROUPBY_NAMES}
+           {MATCH_HAVING_CONDITION}
+            EXCEPT
+           SELECT {GROUPBY_NAMES}
+             FROM {SCHEMA_NAME}.{TABLE_NAME}
+            WHERE {SUBSET_CONDITION}
+           GROUP BY {GROUPBY_NAMES}
+           {HAVING_CONDITION}
+            )
+       ) test;

testgen/template/flavors/generic/exec_query_tests/ex_data_match_generic.sql

@@ -0,0 +1,44 @@
+SELECT '{PROJECT_CODE}'   as project_code,
+       '{TEST_TYPE}'   as test_type,
+       '{TEST_DEFINITION_ID}' as test_definition_id,
+       '{TEST_SUITE}'  as test_suite,
+       '{TEST_RUN_ID}' as test_run_id,
+       '{RUN_DATE}'    as test_time,
+       '{START_TIME}'  as starttime,
+       CURRENT_TIMESTAMP       as endtime,
+       '{SCHEMA_NAME}' as schema_name,
+       '{TABLE_NAME}'  as table_name,
+       '{COLUMN_NAME_NO_QUOTES}' as column_names,
+       '{SKIP_ERRORS}' as threshold_value,
+       {SKIP_ERRORS} as skip_errors,
+       '{INPUT_PARAMETERS}' as input_parameters,
+       CASE WHEN COUNT (*) > {SKIP_ERRORS} THEN 0 ELSE 1 END as result_code,
+       CASE
+        WHEN COUNT(*) > 0 THEN
+               CONCAT(
+                      CONCAT( CAST(COUNT(*) AS VARCHAR), ' error(s) identified, ' ),
+                      CONCAT(
+                             CASE
+                               WHEN COUNT(*) > {SKIP_ERRORS} THEN 'exceeding limit of '
+                                                                        ELSE 'within limit of '
+                             END,
+                             '{SKIP_ERRORS}.'
+                             )
+                      )
+        ELSE 'No errors found.'
+       END AS result_message,
+       COUNT(*) as result_measure,
+       '{SUBSET_DISPLAY}' as subset_condition,
+       NULL as result_query
+  FROM ( SELECT {COLUMN_NAME_NO_QUOTES}
+           FROM {SCHEMA_NAME}.{TABLE_NAME}
+           WHERE {SUBSET_CONDITION}
+         GROUP BY {COLUMN_NAME_NO_QUOTES}
+         {HAVING_CONDITION}
+          EXCEPT
+         SELECT {MATCH_GROUPBY_NAMES}
+           FROM {MATCH_SCHEMA_NAME}.{MATCH_TABLE_NAME}
+          WHERE {MATCH_SUBSET_CONDITION}
+         GROUP BY {MATCH_GROUPBY_NAMES}
+         {MATCH_HAVING_CONDITION}
+       ) test;

testgen/template/flavors/generic/exec_query_tests/ex_prior_match_generic.sql

@@ -0,0 +1,37 @@
+SELECT '{PROJECT_CODE}' as project_code, '{TEST_TYPE}' as test_type,
+       '{TEST_DEFINITION_ID}' as test_definition_id,
+       '{TEST_SUITE}' as test_suite,
+       '{RUN_DATE}' as test_time, '{START_TIME}' as starttime,CURRENT_TIMESTAMP as endtime,
+       '{SCHEMA_NAME}' as schema_name, '{TABLE_NAME}' as table_name, '{COLUMN_NAME}' as column_names,
+       {SKIP_ERRORS} as skip_errors,
+       'schema_name = {SCHEMA_NAME}, prior_schema = {MATCH_SCHEMA_NAME}, table_name = {TABLE_NAME}, column_name = {COLUMN_NAME}, subset_condition = {SUBSET_CONDITION}, mode = {MODE}'
+         as input_parameters,
+       CASE WHEN COUNT(*) > COALESCE(skip_errors, 0) THEN 0 ELSE 1 END as result_code,
+       CONCAT(
+             CONCAT( 'Mismatched measures: ', CAST( COALESCE(COUNT(*), 0) AS VARCHAR) ),
+             CONCAT( ', Threshold: ',
+                     CONCAT( CAST(COALESCE(skip_errors, 0) AS VARCHAR), '.')
+                    )
+              )  AS result_message,
+       COUNT(*) as result_measure,
+       '{TEST_ACTION}' as test_action,
+       '{SUBSET_CONDITION}' as subset_condition,
+       NULL as result_query,
+       '{TEST_DESCRIPTION}' as test_description
+  FROM (
+	( SELECT {COLUMN_NAME}
+    FROM {SCHEMA_NAME}.{TABLE_NAME}
+    WHERE {SUBSET_CONDITION}
+   EXCEPT
+  SELECT {COLUMN_NAME}
+    FROM {MATCH_SCHEMA_NAME}.{TABLE_NAME}
+    WHERE {SUBSET_CONDITION} )
+ UNION
+( SELECT {COLUMN_NAME}
+    FROM {MATCH_SCHEMA_NAME}.{TABLE_NAME}
+    WHERE {SUBSET_CONDITION}
+   EXCEPT
+  SELECT {COLUMN_NAME}
+    FROM {SCHEMA_NAME}.{TABLE_NAME}
+    WHERE {SUBSET_CONDITION} )
+);

testgen/template/flavors/generic/exec_query_tests/ex_relative_entropy_generic.sql

@@ -0,0 +1,53 @@
+-- Relative Entropy:  measured by Jensen-Shannon Divergence
+--   Smoothed and normalized version of KL divergence,
+--   with scores between 0 (identical) and 1 (maximally different),
+--   when using the base-2 logarithm.   Formula is:
+--   0.5 * kl_divergence(p, m) + 0.5 * kl_divergence(q, m)
+--   Log base 2 of x = LN(x)/LN(2)
+WITH latest_ver
+   AS ( SELECT {CONCAT_COLUMNS} as category,
+               COUNT(*)::FLOAT / SUM(COUNT(*)) OVER ()::FLOAT AS pct_of_total
+          FROM {SCHEMA_NAME}.{TABLE_NAME} v1
+         WHERE {SUBSET_CONDITION}
+         GROUP BY {COLUMN_NAME_NO_QUOTES} ),
+older_ver
+   AS ( SELECT {CONCAT_MATCH_GROUPBY} as category,
+               COUNT(*)::FLOAT / SUM(COUNT(*)) OVER ()::FLOAT AS pct_of_total
+          FROM {MATCH_SCHEMA_NAME}.{TABLE_NAME} v2
+         WHERE {MATCH_SUBSET_CONDITION}
+         GROUP BY {MATCH_GROUPBY_NAMES} ),
+dataset
+   AS ( SELECT COALESCE(l.category, o.category) AS category,
+               COALESCE(o.pct_of_total, 0.0000001)        AS old_pct,
+               COALESCE(l.pct_of_total, 0.0000001)        AS new_pct,
+               (COALESCE(o.pct_of_total, 0.0000001)
+                + COALESCE(l.pct_of_total, 0.0000001))/2.0 AS avg_pct
+          FROM latest_ver l
+          FULL JOIN older_ver o
+            ON (l.category = o.category) )
+SELECT '{PROJECT_CODE}' as project_code,
+       '{TEST_TYPE}' as test_type,
+       '{TEST_DEFINITION_ID}' as test_definition_id,
+       '{TEST_SUITE}' as test_suite,
+       '{TEST_RUN_ID}' as test_run_id,
+       '{RUN_DATE}' as test_time,
+       '{START_TIME}' as starttime,
+       CURRENT_TIMESTAMP as endtime,
+       '{SCHEMA_NAME}' as schema_name,
+       '{TABLE_NAME}' as table_name,
+       '{COLUMN_NAME_NO_QUOTES}' as column_names,
+--        '{GROUPBY_NAMES}' as column_names,
+       '{THRESHOLD_VALUE}' as threshold_value,
+       NULL as skip_errors,
+       '{INPUT_PARAMETERS}' as input_parameters,
+       CASE WHEN js_divergence > {THRESHOLD_VALUE} THEN 0 ELSE 1 END as result_code,
+       CONCAT('Divergence Level: ',
+              CONCAT(CAST(js_divergence AS VARCHAR),
+                     ', Threshold: {THRESHOLD_VALUE}.')) as result_message,
+       js_divergence as result_measure,
+       '{SUBSET_DISPLAY}' as subset_condition,
+       NULL as result_query
+  FROM (
+         SELECT 0.5 * ABS(SUM(new_pct * LN(new_pct/avg_pct)/LN(2)))
+                 + 0.5 * ABS(SUM(old_pct * LN(old_pct/avg_pct)/LN(2))) as js_divergence
+           FROM dataset ) rslt;

testgen/template/flavors/generic/exec_query_tests/ex_window_match_no_drops_generic.sql

@@ -0,0 +1,46 @@
+SELECT '{PROJECT_CODE}'   as project_code,
+       '{TEST_TYPE}'   as test_type,
+       '{TEST_DEFINITION_ID}' as test_definition_id,
+       '{TEST_SUITE}'  as test_suite,
+       '{TEST_RUN_ID}' as test_run_id,
+       '{RUN_DATE}'    as test_time,
+       '{START_TIME}'  as starttime,
+       CURRENT_TIMESTAMP       as endtime,
+       '{SCHEMA_NAME}' as schema_name,
+       '{TABLE_NAME}'  as table_name,
+       '{COLUMN_NAME_NO_QUOTES}' as column_names,
+       '{SKIP_ERRORS}' as threshold_value,
+       {SKIP_ERRORS} as skip_errors,
+       '{INPUT_PARAMETERS}' as input_parameters,
+       CASE WHEN COUNT (*) > {SKIP_ERRORS} THEN 0 ELSE 1 END as result_code,
+       CASE
+        WHEN COUNT(*) > 0 THEN
+               CONCAT(
+                      CONCAT( CAST(COUNT(*) AS VARCHAR), ' error(s) identified, ' ),
+                      CONCAT(
+                             CASE
+                               WHEN COUNT(*) > {SKIP_ERRORS} THEN 'exceeding limit of '
+                                                                        ELSE 'within limit of '
+                             END,
+                             '{SKIP_ERRORS}.'
+                             )
+                      )
+        ELSE 'No errors found.'
+       END AS result_message,
+       COUNT(*) as result_measure,
+       '{SUBSET_DISPLAY}' as subset_condition,
+       NULL as result_query
+FROM (
+      SELECT {COLUMN_NAME_NO_QUOTES}
+        FROM {SCHEMA_NAME}.{TABLE_NAME}
+       WHERE {SUBSET_CONDITION}
+         AND {WINDOW_DATE_COLUMN} >= DATEADD("day",  - 2 * {WINDOW_DAYS}, (SELECT MAX({WINDOW_DATE_COLUMN}) FROM {SCHEMA_NAME}.{TABLE_NAME}))
+         AND {WINDOW_DATE_COLUMN} <  DATEADD("day", - {WINDOW_DAYS}, (SELECT MAX({WINDOW_DATE_COLUMN}) FROM {SCHEMA_NAME}.{TABLE_NAME}))
+      GROUP BY {COLUMN_NAME_NO_QUOTES}
+       EXCEPT
+      SELECT {COLUMN_NAME_NO_QUOTES}
+        FROM {SCHEMA_NAME}.{TABLE_NAME}
+       WHERE {SUBSET_CONDITION}
+         AND {WINDOW_DATE_COLUMN} >= DATEADD("day", - {WINDOW_DAYS}, (SELECT MAX({WINDOW_DATE_COLUMN}) FROM {SCHEMA_NAME}.{TABLE_NAME}))
+      GROUP BY {COLUMN_NAME_NO_QUOTES}
+     ) test;