@oliphaunt/extension-pgtap-linux-arm64-gnu 0.1.0

package/runtime/share/postgresql/extension/pgtap--1.3.0--1.3.1.sql

@@ -0,0 +1,229 @@
+-- Use DO to ignore failures when the shared library doesn't exist, because it
+-- only existed for 1.3.1, and if upgrades are running from a later release it
+-- won't be there.
+DO $$
+BEGIN
+    CREATE FUNCTION parse_type(type text, OUT typid oid, OUT typmod int4)
+    RETURNS RECORD
+    AS 'pgtap'
+    LANGUAGE C STABLE STRICT;
+EXCEPTION
+    WHEN undefined_file THEN
+        RAISE NOTICE 'No pgtap shared library; skipping C parse_type()';
+END;
+$$;
+
+CREATE OR REPLACE FUNCTION format_type_string ( TEXT )
+RETURNS TEXT AS $$
+BEGIN RETURN format_type(p.typid, p.typmod) from parse_type($1) p;
+EXCEPTION WHEN OTHERS THEN RETURN NULL;
+END;
+$$ LANGUAGE PLPGSQL STABLE;
+
+-- col_type_is( schema, table, column, schema, type, description )
+CREATE OR REPLACE FUNCTION col_type_is ( NAME, NAME, NAME, NAME, TEXT, TEXT )
+RETURNS TEXT AS $$
+DECLARE
+    have_type TEXT := _get_col_ns_type($1, $2, $3);
+    want_type TEXT;
+BEGIN
+    IF have_type IS NULL THEN
+        RETURN fail( $6 ) || E'\n' || diag (
+            '   Column ' || COALESCE(quote_ident($1) || '.', '')
+            || quote_ident($2) || '.' || quote_ident($3) || ' does not exist'
+        );
+    END IF;
+
+    IF quote_ident($4) = ANY(current_schemas(true)) THEN
+        want_type := quote_ident($4) || '.' || format_type_string($5);
+    ELSE
+        want_type := format_type_string(quote_ident($4) || '.' || $5);
+    END IF;
+
+    IF want_type IS NULL THEN
+        RETURN fail( $6 ) || E'\n' || diag (
+            '    Type ' || quote_ident($4) || '.' || $5 || ' does not exist'
+        );
+    END IF;
+
+    IF have_type = want_type THEN
+        -- We're good to go.
+        RETURN ok( true, $6 );
+    END IF;
+
+    -- Wrong data type. tell 'em what we really got.
+    RETURN ok( false, $6 ) || E'\n' || diag(
+           '        have: ' || have_type ||
+        E'\n        want: ' || want_type
+    );
+END;
+$$ LANGUAGE plpgsql;
+
+-- col_type_is( schema, table, column, schema, type )
+CREATE OR REPLACE FUNCTION col_type_is ( NAME, NAME, NAME, NAME, TEXT )
+RETURNS TEXT AS $$
+    SELECT col_type_is( $1, $2, $3, $4, $5, 'Column ' || quote_ident($1) || '.' || quote_ident($2)
+        || '.' || quote_ident($3) || ' should be type ' || quote_ident($4) || '.' || $5);
+$$ LANGUAGE SQL;
+
+-- col_type_is( schema, table, column, type, description )
+CREATE OR REPLACE FUNCTION col_type_is ( NAME, NAME, NAME, TEXT, TEXT )
+RETURNS TEXT AS $$
+DECLARE
+    have_type TEXT;
+    want_type TEXT;
+BEGIN
+    -- Get the data type.
+    IF $1 IS NULL THEN
+        have_type := _get_col_type($2, $3);
+    ELSE
+        have_type := _get_col_type($1, $2, $3);
+    END IF;
+
+    IF have_type IS NULL THEN
+        RETURN fail( $5 ) || E'\n' || diag (
+            '   Column ' || COALESCE(quote_ident($1) || '.', '')
+            || quote_ident($2) || '.' || quote_ident($3) || ' does not exist'
+        );
+    END IF;
+
+    want_type := format_type_string($4);
+    IF want_type IS NULL THEN
+        RETURN fail( $5 ) || E'\n' || diag (
+            '    Type ' || $4 || ' does not exist'
+        );
+    END IF;
+
+    IF have_type = want_type THEN
+        -- We're good to go.
+        RETURN ok( true, $5 );
+    END IF;
+
+    -- Wrong data type. tell 'em what we really got.
+    RETURN ok( false, $5 ) || E'\n' || diag(
+           '        have: ' || have_type ||
+        E'\n        want: ' || want_type
+    );
+END;
+$$ LANGUAGE plpgsql;
+
+CREATE OR REPLACE FUNCTION _cmp_types(oid, name)
+RETURNS BOOLEAN AS $$
+    SELECT pg_catalog.format_type($1, NULL) = _typename($2);
+$$ LANGUAGE sql;
+
+-- domain_type_is( schema, domain, schema, type, description )
+CREATE OR REPLACE FUNCTION domain_type_is( NAME, TEXT, NAME, TEXT, TEXT )
+RETURNS TEXT AS $$
+DECLARE
+    actual_type TEXT := _get_dtype($1, $2, true);
+BEGIN
+    IF actual_type IS NULL THEN
+        RETURN fail( $5 ) || E'\n' || diag (
+            '   Domain ' || quote_ident($1) || '.' || $2
+            || ' does not exist'
+        );
+    END IF;
+
+    IF quote_ident($3) = ANY(current_schemas(true)) THEN
+        RETURN is( actual_type, quote_ident($3) || '.' || _typename($4), $5);
+    END IF;
+    RETURN is( actual_type, _typename(quote_ident($3) || '.' || $4), $5);
+END;
+$$ LANGUAGE plpgsql;
+
+-- domain_type_is( schema, domain, type, description )
+CREATE OR REPLACE FUNCTION domain_type_is( NAME, TEXT, TEXT, TEXT )
+RETURNS TEXT AS $$
+DECLARE
+    actual_type TEXT := _get_dtype($1, $2, false);
+BEGIN
+    IF actual_type IS NULL THEN
+        RETURN fail( $4 ) || E'\n' || diag (
+            '   Domain ' || quote_ident($1) || '.' || $2
+            || ' does not exist'
+        );
+    END IF;
+
+    RETURN is( actual_type, _typename($3), $4 );
+END;
+$$ LANGUAGE plpgsql;
+
+-- domain_type_is( domain, type, description )
+CREATE OR REPLACE FUNCTION domain_type_is( TEXT, TEXT, TEXT )
+RETURNS TEXT AS $$
+DECLARE
+    actual_type TEXT := _get_dtype($1);
+BEGIN
+    IF actual_type IS NULL THEN
+        RETURN fail( $3 ) || E'\n' || diag (
+            '   Domain ' ||  $1 || ' does not exist'
+        );
+    END IF;
+
+    RETURN is( actual_type, _typename($2), $3 );
+END;
+$$ LANGUAGE plpgsql;
+
+-- domain_type_isnt( schema, domain, schema, type, description )
+CREATE OR REPLACE FUNCTION domain_type_isnt( NAME, TEXT, NAME, TEXT, TEXT )
+RETURNS TEXT AS $$
+DECLARE
+    actual_type TEXT := _get_dtype($1, $2, true);
+BEGIN
+    IF actual_type IS NULL THEN
+        RETURN fail( $5 ) || E'\n' || diag (
+            '   Domain ' || quote_ident($1) || '.' || $2
+            || ' does not exist'
+        );
+    END IF;
+
+    IF quote_ident($3) = ANY(current_schemas(true)) THEN
+        RETURN isnt( actual_type, quote_ident($3) || '.' || _typename($4), $5);
+    END IF;
+    RETURN isnt( actual_type, _typename(quote_ident($3) || '.' || $4), $5);
+END;
+$$ LANGUAGE plpgsql;
+
+
+-- domain_type_isnt( schema, domain, type, description )
+CREATE OR REPLACE FUNCTION domain_type_isnt( NAME, TEXT, TEXT, TEXT )
+RETURNS TEXT AS $$
+DECLARE
+    actual_type TEXT := _get_dtype($1, $2, false);
+BEGIN
+    IF actual_type IS NULL THEN
+        RETURN fail( $4 ) || E'\n' || diag (
+            '   Domain ' || quote_ident($1) || '.' || $2
+            || ' does not exist'
+        );
+    END IF;
+
+    RETURN isnt( actual_type, _typename($3), $4 );
+END;
+$$ LANGUAGE plpgsql;
+
+
+-- domain_type_isnt( domain, type, description )
+CREATE OR REPLACE FUNCTION domain_type_isnt( TEXT, TEXT, TEXT )
+RETURNS TEXT AS $$
+DECLARE
+    actual_type TEXT := _get_dtype($1);
+BEGIN
+    IF actual_type IS NULL THEN
+        RETURN fail( $3 ) || E'\n' || diag (
+            '   Domain ' ||  $1 || ' does not exist'
+        );
+    END IF;
+
+    RETURN isnt( actual_type, _typename($2), $3 );
+END;
+$$ LANGUAGE plpgsql;
+
+DROP FUNCTION _quote_ident_like(TEXT, TEXT);
+
+-- has_pk( schema, table )
+CREATE OR REPLACE FUNCTION has_pk ( NAME, NAME )
+RETURNS TEXT AS $$
+    SELECT has_pk( $1, $2, 'Table ' || quote_ident($1) || '.' || quote_ident($2) || ' should have a primary key' );
+$$ LANGUAGE sql;

package/runtime/share/postgresql/extension/pgtap--1.3.1--1.3.2.sql

@@ -0,0 +1,34 @@
+DROP FUNCTION IF EXISTS parse_type(type text, OUT typid oid, OUT typmod int4);
+
+CREATE OR REPLACE FUNCTION format_type_string ( TEXT )
+RETURNS TEXT AS $$
+DECLARE
+    want_type TEXT := $1;
+    typmodin_arg cstring[];
+    typmodin_func regproc;
+    typmod int;
+BEGIN
+    IF want_type::regtype = 'interval'::regtype THEN
+        -- RAISE NOTICE 'cannot resolve: %', want_type;  -- TODO
+        RETURN want_type;
+    END IF;
+
+    -- Extract type modifier from type declaration and format as cstring[] literal.
+    typmodin_arg := translate(substring(want_type FROM '[(][^")]+[)]'), '()', '{}');
+
+    -- Find typmodin function for want_type.
+    SELECT typmodin INTO typmodin_func
+      FROM pg_catalog.pg_type
+     WHERE oid = want_type::regtype;
+
+    IF typmodin_func = 0 THEN
+        -- Easy: types without typemods.
+        RETURN format_type(want_type::regtype, null);
+    END IF;
+
+    -- Get typemod via type-specific typmodin function.
+    EXECUTE format('SELECT %I(%L)', typmodin_func, typmodin_arg) INTO typmod;
+    RETURN format_type(want_type::regtype, typmod);
+EXCEPTION WHEN OTHERS THEN RETURN NULL;
+END;
+$$ LANGUAGE PLPGSQL STABLE;

package/runtime/share/postgresql/extension/pgtap--1.3.2--1.3.3.sql

@@ -0,0 +1,42 @@
+CREATE OR REPLACE FUNCTION format_type_string ( TEXT )
+RETURNS TEXT AS $$
+DECLARE
+    want_type TEXT := $1;
+BEGIN
+    IF pg_version_num() >= 170000 THEN
+        -- to_regtypemod() in 17 allows easy and corret normalization.
+        RETURN format_type(to_regtype(want_type), to_regtypemod(want_type));
+    END IF;
+
+    IF want_type::regtype = 'interval'::regtype THEN
+        -- We cannot normlize interval types without to_regtypemod(), So
+        -- just return it as is.
+        RETURN want_type;
+    END IF;
+
+    -- Use the typmodin functions to correctly normalize types.
+    DECLARE
+        typmodin_arg cstring[];
+        typmodin_func regproc;
+        typmod int;
+    BEGIN
+        -- Extract type modifier from type declaration and format as cstring[] literal.
+        typmodin_arg := translate(substring(want_type FROM '[(][^")]+[)]'), '()', '{}');
+
+        -- Find typmodin function for want_type.
+        SELECT typmodin INTO typmodin_func
+        FROM pg_catalog.pg_type
+        WHERE oid = want_type::regtype;
+
+        IF typmodin_func = 0 THEN
+            -- Easy: types without typemods.
+            RETURN format_type(want_type::regtype, null);
+        END IF;
+
+        -- Get typemod via type-specific typmodin function.
+        EXECUTE format('SELECT %s(%L)', typmodin_func, typmodin_arg) INTO typmod;
+        RETURN format_type(want_type::regtype, typmod);
+    END;
+    EXCEPTION WHEN OTHERS THEN RETURN NULL;
+END;
+$$ LANGUAGE PLPGSQL STABLE;

package/runtime/share/postgresql/extension/pgtap--1.3.3--1.3.4.sql

@@ -0,0 +1,89 @@
+-- has_composite( schema, type )
+CREATE OR REPLACE FUNCTION has_composite ( NAME, NAME )
+RETURNS TEXT AS $$
+    SELECT has_composite(
+        $1, $2,
+        'Composite type ' || quote_ident($1) || '.' || quote_ident($2) || ' should exist'
+    );
+$$ LANGUAGE SQL;
+
+-- hasnt_composite( schema, type )
+CREATE OR REPLACE FUNCTION hasnt_composite ( NAME, NAME )
+RETURNS TEXT AS $$
+    SELECT hasnt_composite(
+        $1, $2,
+        'Composite type ' || quote_ident($1) || '.' || quote_ident($2) || ' should not exist'
+    );
+$$ LANGUAGE SQL;
+
+-- index_is_partial( schema, table, index, description )
+CREATE OR REPLACE FUNCTION index_is_partial ( NAME, NAME, NAME, text )
+RETURNS TEXT AS $$
+DECLARE
+    res boolean;
+BEGIN
+    SELECT x.indpred IS NOT NULL
+      FROM pg_catalog.pg_index x
+      JOIN pg_catalog.pg_class ct    ON ct.oid = x.indrelid
+      JOIN pg_catalog.pg_class ci    ON ci.oid = x.indexrelid
+      JOIN pg_catalog.pg_namespace n ON n.oid = ct.relnamespace
+     WHERE ct.relname = $2
+       AND ci.relname = $3
+       AND n.nspname  = $1
+      INTO res;
+
+      RETURN ok( COALESCE(res, false), $4 );
+END;
+$$ LANGUAGE plpgsql;
+
+-- index_is_partial( schema, table, index )
+CREATE OR REPLACE FUNCTION index_is_partial ( NAME, NAME, NAME )
+RETURNS TEXT AS $$
+    SELECT index_is_partial(
+        $1, $2, $3,
+        'Index ' || quote_ident($3) || ' should be partial'
+    );
+$$ LANGUAGE sql;
+
+-- index_is_partial( table, index )
+CREATE OR REPLACE FUNCTION index_is_partial ( NAME, NAME )
+RETURNS TEXT AS $$
+DECLARE
+    res boolean;
+BEGIN
+    SELECT x.indpred IS NOT NULL
+      FROM pg_catalog.pg_index x
+      JOIN pg_catalog.pg_class ct ON ct.oid = x.indrelid
+      JOIN pg_catalog.pg_class ci ON ci.oid = x.indexrelid
+     WHERE ct.relname = $1
+       AND ci.relname = $2
+       AND pg_catalog.pg_table_is_visible(ct.oid)
+     INTO res;
+
+      RETURN ok(
+          COALESCE(res, false),
+          'Index ' || quote_ident($2) || ' should be partial'
+      );
+END;
+$$ LANGUAGE plpgsql;
+
+-- index_is_partial( index )
+CREATE OR REPLACE FUNCTION index_is_partial ( NAME )
+RETURNS TEXT AS $$
+DECLARE
+    res boolean;
+BEGIN
+    SELECT x.indpred IS NOT NULL
+      FROM pg_catalog.pg_index x
+      JOIN pg_catalog.pg_class ci ON ci.oid = x.indexrelid
+      JOIN pg_catalog.pg_class ct ON ct.oid = x.indrelid
+     WHERE ci.relname = $1
+       AND pg_catalog.pg_table_is_visible(ct.oid)
+      INTO res;
+
+      RETURN ok(
+          COALESCE(res, false),
+          'Index ' || quote_ident($1) || ' should be partial'
+      );
+END;
+$$ LANGUAGE plpgsql;

package/runtime/share/postgresql/extension/pgtap--1.3.4--1.3.5.sql

@@ -0,0 +1 @@
+-- Changes between pgTAP v1.3.4 and v1.3.5.