diff --git a/cmd/regenerate/main.go b/cmd/regenerate/main.go index b26039d..dc515c4 100644 --- a/cmd/regenerate/main.go +++ b/cmd/regenerate/main.go @@ -14,6 +14,8 @@ // (inputs transcribed mechanically; expectations always from the oracle) // - pg_query_go testdata/fingerprint.json → fingerprint suite (includes the // 1.1 MB stress insert) +// - cmd/regenerate/regressions/*.sql → parse, scan, deparse suites +// (oliphant's own inputs for grammar the corpora above miss) // // Output must be byte-identical across runs — that reproducibility is // milestone 2's acceptance gate and is enforced weekly in CI. @@ -126,6 +128,20 @@ func main() { emitSQLSuites(oracle, *out, "deparse_depesz", base, stmts, []string{"parse", "scan", "deparse"}) } + // Tier: oliphant's own regression inputs (cmd/regenerate/regressions), + // for grammar the upstream corpora above never reach. Inputs only; the + // oracle writes every expectation, as for every other tier. + regressionDir := filepath.Join("cmd", "regenerate", "regressions") + regressionFiles := sqlFiles(regressionDir) + fmt.Fprintf(os.Stderr, "regenerate: regressions: %d files\n", len(regressionFiles)) + for _, f := range regressionFiles { + src, err := os.ReadFile(filepath.Join(regressionDir, f)) + check(err) + stmts := splitStatements(oracle, string(src)) + base := strings.TrimSuffix(f, ".sql") + emitSQLSuites(oracle, *out, "regressions", base, stmts, []string{"parse", "scan", "deparse"}) + } + // Tier: libpg_query inline test tables. Inputs are the even-indexed (or // all, for input-only tables) entries; expectations come from the oracle. inline := []struct { diff --git a/cmd/regenerate/regressions/func_arg_types.sql b/cmd/regenerate/regressions/func_arg_types.sql new file mode 100644 index 0000000..dbc94aa --- /dev/null +++ b/cmd/regenerate/regressions/func_arg_types.sql @@ -0,0 +1,43 @@ +-- func_arg: a param_name is followed by an arg_class or a func_type, so a +-- type_function_name followed by anything else (PRECISION, ARRAY, '[', ...) +-- is the argument's type. pg_dump names functions by unnamed argument +-- types, as pgvector's ACL entries do. +GRANT ALL ON FUNCTION extensions.vector_avg(double precision[]) TO postgres WITH GRANT OPTION; +GRANT ALL ON FUNCTION extensions.vector_combine(double precision[], double precision[]) TO postgres WITH GRANT OPTION; +GRANT ALL ON FUNCTION extensions.array_to_vector(double precision[], integer, boolean) TO postgres WITH GRANT OPTION; +GRANT ALL ON FUNCTION f(double precision) TO x; +GRANT ALL ON FUNCTION f(int, double precision) TO x; +REVOKE ALL ON FUNCTION f(double precision) FROM PUBLIC; +GRANT ALL ON PROCEDURE p(double precision) TO x; +GRANT ALL ON ROUTINE f(double precision) TO x; +DROP FUNCTION f(double precision); +DROP ROUTINE f(double precision), g(double precision[]); +ALTER FUNCTION f(double precision) OWNER TO x; +COMMENT ON FUNCTION f(double precision) IS 'c'; +COMMENT ON AGGREGATE f(double precision) IS 'c'; +COMMENT ON AGGREGATE f(double precision ORDER BY double precision) IS 'c'; +CREATE AGGREGATE f(double precision) (sfunc = g, stype = int); +CREATE FUNCTION f(double precision) RETURNS int LANGUAGE sql AS 'select 1'; +CREATE FUNCTION f(IN double precision) RETURNS int LANGUAGE sql AS 'select 1'; +CREATE FUNCTION f(VARIADIC double precision[]) RETURNS int LANGUAGE sql AS 'select 1'; +CREATE FUNCTION f(double precision DEFAULT 1) RETURNS int LANGUAGE sql AS 'select 1'; +CREATE FUNCTION f(double precision = 1) RETURNS int LANGUAGE sql AS 'select 1'; +CREATE FUNCTION f(a double precision) RETURNS int LANGUAGE sql AS 'select 1'; +CREATE FUNCTION f(double double precision) RETURNS int LANGUAGE sql AS 'select 1'; +CREATE FUNCTION f(double int) RETURNS int LANGUAGE sql AS 'select 1'; +CREATE FUNCTION f(double) RETURNS int LANGUAGE sql AS 'select 1'; +CREATE FUNCTION f(precision double precision) RETURNS int LANGUAGE sql AS 'select 1'; +CREATE FUNCTION f(a precision) RETURNS int LANGUAGE sql AS 'select 1'; +ALTER EXTENSION e ADD FUNCTION f(double precision); +SECURITY LABEL ON FUNCTION f(double precision) IS 'x'; +CREATE CAST (double precision AS int) WITH FUNCTION f(double precision); +GRANT ALL ON FUNCTION f(int4 ARRAY) TO x; +GRANT ALL ON FUNCTION f(int4 ARRAY[3]) TO x; +GRANT ALL ON FUNCTION f(public.t ARRAY) TO x; +CREATE FUNCTION f(a int4 ARRAY) RETURNS int LANGUAGE sql AS 'select 1'; +CREATE FUNCTION f(a ARRAY) RETURNS int LANGUAGE sql AS 'select 1'; +GRANT ALL ON FUNCTION f(character varying, bit varying, national character varying) TO x; +GRANT ALL ON FUNCTION f(timestamp with time zone, time without time zone, interval) TO x; +CREATE FUNCTION f(a OUT double precision, b INOUT int, c IN OUT int, d VARIADIC int[]) RETURNS record LANGUAGE sql AS 'select 1'; +CREATE FUNCTION f(a SETOF int) RETURNS int LANGUAGE sql AS 'select 1'; +CREATE FUNCTION f(json json, a b.c, d e.f%TYPE, g h(1)) RETURNS int LANGUAGE sql AS 'select 1'; diff --git a/internal/parse/ddl_object.go b/internal/parse/ddl_object.go index f8f0df5..3f9c359 100644 --- a/internal/parse/ddl_object.go +++ b/internal/parse/ddl_object.go @@ -119,15 +119,26 @@ func (p *parser) parseArgClass() (ast.FunctionParameterMode, bool) { // argNameFollowedByType reports whether the token after the current one // continues a func_arg (so the current token is a param_name rather than -// the argument's type). +// the argument's type). gram.y's func_arg follows a param_name with an +// arg_class or a func_type, so it is a param_name exactly when the next +// token can begin one of those: an arg_class keyword, SETOF, a +// type_function_name, or a keyword heading one of SimpleTypename's +// keyword families. Any other token -- PRECISION after DOUBLE_P, ARRAY, +// '[', ')', DEFAULT -- makes the current token the start of the type. func (p *parser) argNameFollowedByType() bool { - switch p.kindN(1) { - case ast.Token(','), ast.Token(')'), ast.Token('.'), ast.Token('%'), - ast.Token('('), ast.Token('['), ast.Token_DEFAULT, ast.Token('='), - ast.Token_ORDER, 0: - return false + next := p.peekN(1) + switch next.Kind { + case ast.Token_IN_P, ast.Token_OUT_P, ast.Token_INOUT, ast.Token_VARIADIC, + ast.Token_SETOF, + ast.Token_INT_P, ast.Token_INTEGER, ast.Token_SMALLINT, ast.Token_BIGINT, + ast.Token_REAL, ast.Token_FLOAT_P, ast.Token_DOUBLE_P, ast.Token_DECIMAL_P, + ast.Token_DEC, ast.Token_NUMERIC, ast.Token_BOOLEAN_P, ast.Token_BIT, + ast.Token_CHARACTER, ast.Token_CHAR_P, ast.Token_VARCHAR, ast.Token_NCHAR, + ast.Token_NATIONAL, ast.Token_TIMESTAMP, ast.Token_TIME, ast.Token_INTERVAL, + ast.Token_JSON: + return true } - return true + return isTypeFunctionNameToken(next) } // extractArgTypes is gram.y's extractArgTypes. diff --git a/parser/testdata/deparse/regressions/func_arg_types.metadata.json b/parser/testdata/deparse/regressions/func_arg_types.metadata.json new file mode 100644 index 0000000..737fd31 --- /dev/null +++ b/parser/testdata/deparse/regressions/func_arg_types.metadata.json @@ -0,0 +1,3 @@ +{ + "todo": [] +} diff --git a/parser/testdata/deparse/regressions/func_arg_types.test b/parser/testdata/deparse/regressions/func_arg_types.test new file mode 100644 index 0000000..e2918b0 --- /dev/null +++ b/parser/testdata/deparse/regressions/func_arg_types.test @@ -0,0 +1,169 @@ +== 001 +-- func_arg: a param_name is followed by an arg_class or a func_type, so a +-- type_function_name followed by anything else (PRECISION, ARRAY, '[', ...) +-- is the argument's type. pg_dump names functions by unnamed argument +-- types, as pgvector's ACL entries do. +GRANT ALL ON FUNCTION extensions.vector_avg(double precision[]) TO postgres WITH GRANT OPTION +-- +GRANT ALL ON FUNCTION extensions.vector_avg(double precision[]) TO postgres WITH GRANT OPTION +== 002 +GRANT ALL ON FUNCTION extensions.vector_combine(double precision[], double precision[]) TO postgres WITH GRANT OPTION +-- +GRANT ALL ON FUNCTION extensions.vector_combine(double precision[], double precision[]) TO postgres WITH GRANT OPTION +== 003 +GRANT ALL ON FUNCTION extensions.array_to_vector(double precision[], integer, boolean) TO postgres WITH GRANT OPTION +-- +GRANT ALL ON FUNCTION extensions.array_to_vector(double precision[], int, boolean) TO postgres WITH GRANT OPTION +== 004 +GRANT ALL ON FUNCTION f(double precision) TO x +-- +GRANT ALL ON FUNCTION f(double precision) TO x +== 005 +GRANT ALL ON FUNCTION f(int, double precision) TO x +-- +GRANT ALL ON FUNCTION f(int, double precision) TO x +== 006 +REVOKE ALL ON FUNCTION f(double precision) FROM PUBLIC +-- +REVOKE ALL ON FUNCTION f(double precision) FROM public +== 007 +GRANT ALL ON PROCEDURE p(double precision) TO x +-- +GRANT ALL ON PROCEDURE p(double precision) TO x +== 008 +GRANT ALL ON ROUTINE f(double precision) TO x +-- +GRANT ALL ON ROUTINE f(double precision) TO x +== 009 +DROP FUNCTION f(double precision) +-- +DROP FUNCTION f(double precision) +== 010 +DROP ROUTINE f(double precision), g(double precision[]) +-- +DROP ROUTINE f(double precision), g(double precision[]) +== 011 +ALTER FUNCTION f(double precision) OWNER TO x +-- +ALTER FUNCTION f(double precision) OWNER TO x +== 012 +COMMENT ON FUNCTION f(double precision) IS 'c' +-- +COMMENT ON FUNCTION f(double precision) IS 'c' +== 013 +COMMENT ON AGGREGATE f(double precision) IS 'c' +-- +COMMENT ON AGGREGATE f(double precision) IS 'c' +== 014 +COMMENT ON AGGREGATE f(double precision ORDER BY double precision) IS 'c' +-- +COMMENT ON AGGREGATE f(double precision, double precision) IS 'c' +== 015 +CREATE AGGREGATE f(double precision) (sfunc = g, stype = int) +-- +CREATE AGGREGATE f (double precision) (sfunc = g, stype = int) +== 016 +CREATE FUNCTION f(double precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +CREATE FUNCTION f(double precision) RETURNS int LANGUAGE sql AS $$select 1$$ +== 017 +CREATE FUNCTION f(IN double precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +CREATE FUNCTION f(IN double precision) RETURNS int LANGUAGE sql AS $$select 1$$ +== 018 +CREATE FUNCTION f(VARIADIC double precision[]) RETURNS int LANGUAGE sql AS 'select 1' +-- +CREATE FUNCTION f(VARIADIC double precision[]) RETURNS int LANGUAGE sql AS $$select 1$$ +== 019 +CREATE FUNCTION f(double precision DEFAULT 1) RETURNS int LANGUAGE sql AS 'select 1' +-- +CREATE FUNCTION f(double precision = 1) RETURNS int LANGUAGE sql AS $$select 1$$ +== 020 +CREATE FUNCTION f(double precision = 1) RETURNS int LANGUAGE sql AS 'select 1' +-- +CREATE FUNCTION f(double precision = 1) RETURNS int LANGUAGE sql AS $$select 1$$ +== 021 +CREATE FUNCTION f(a double precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +CREATE FUNCTION f(a double precision) RETURNS int LANGUAGE sql AS $$select 1$$ +== 022 +CREATE FUNCTION f(double double precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +CREATE FUNCTION f(double double precision) RETURNS int LANGUAGE sql AS $$select 1$$ +== 023 +CREATE FUNCTION f(double int) RETURNS int LANGUAGE sql AS 'select 1' +-- +CREATE FUNCTION f(double int) RETURNS int LANGUAGE sql AS $$select 1$$ +== 024 +CREATE FUNCTION f(double) RETURNS int LANGUAGE sql AS 'select 1' +-- +CREATE FUNCTION f(double) RETURNS int LANGUAGE sql AS $$select 1$$ +== 025 +CREATE FUNCTION f(precision double precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +ERROR: syntax error at or near "precision" +CURSORPOS: 19 +FILENAME: scan.l +FUNCNAME: scanner_yyerror +== 026 +CREATE FUNCTION f(a precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +ERROR: syntax error at or near "precision" +CURSORPOS: 21 +FILENAME: scan.l +FUNCNAME: scanner_yyerror +== 027 +ALTER EXTENSION e ADD FUNCTION f(double precision) +-- +ALTER EXTENSION e ADD FUNCTION f(double precision) +== 028 +SECURITY LABEL ON FUNCTION f(double precision) IS 'x' +-- +SECURITY LABEL ON FUNCTION f(double precision) IS 'x' +== 029 +CREATE CAST (double precision AS int) WITH FUNCTION f(double precision) +-- +CREATE CAST (double precision AS int) WITH FUNCTION f(double precision) +== 030 +GRANT ALL ON FUNCTION f(int4 ARRAY) TO x +-- +GRANT ALL ON FUNCTION f(int4[]) TO x +== 031 +GRANT ALL ON FUNCTION f(int4 ARRAY[3]) TO x +-- +GRANT ALL ON FUNCTION f(int4[3]) TO x +== 032 +GRANT ALL ON FUNCTION f(public.t ARRAY) TO x +-- +GRANT ALL ON FUNCTION f(public.t[]) TO x +== 033 +CREATE FUNCTION f(a int4 ARRAY) RETURNS int LANGUAGE sql AS 'select 1' +-- +CREATE FUNCTION f(a int4[]) RETURNS int LANGUAGE sql AS $$select 1$$ +== 034 +CREATE FUNCTION f(a ARRAY) RETURNS int LANGUAGE sql AS 'select 1' +-- +CREATE FUNCTION f(a[]) RETURNS int LANGUAGE sql AS $$select 1$$ +== 035 +GRANT ALL ON FUNCTION f(character varying, bit varying, national character varying) TO x +-- +GRANT ALL ON FUNCTION f(varchar, pg_catalog.varbit, varchar) TO x +== 036 +GRANT ALL ON FUNCTION f(timestamp with time zone, time without time zone, interval) TO x +-- +GRANT ALL ON FUNCTION f(timestamp with time zone, time, interval) TO x +== 037 +CREATE FUNCTION f(a OUT double precision, b INOUT int, c IN OUT int, d VARIADIC int[]) RETURNS record LANGUAGE sql AS 'select 1' +-- +CREATE FUNCTION f(OUT a double precision, INOUT b int, INOUT c int, VARIADIC d int[]) RETURNS record LANGUAGE sql AS $$select 1$$ +== 038 +CREATE FUNCTION f(a SETOF int) RETURNS int LANGUAGE sql AS 'select 1' +-- +CREATE FUNCTION f(a SETOF int) RETURNS int LANGUAGE sql AS $$select 1$$ +== 039 +CREATE FUNCTION f(json json, a b.c, d e.f%TYPE, g h(1)) RETURNS int LANGUAGE sql AS 'select 1' +-- +ERROR: syntax error at or near "json" +CURSORPOS: 24 +FILENAME: scan.l +FUNCNAME: scanner_yyerror diff --git a/parser/testdata/parse/regressions/func_arg_types.metadata.json b/parser/testdata/parse/regressions/func_arg_types.metadata.json new file mode 100644 index 0000000..737fd31 --- /dev/null +++ b/parser/testdata/parse/regressions/func_arg_types.metadata.json @@ -0,0 +1,3 @@ +{ + "todo": [] +} diff --git a/parser/testdata/parse/regressions/func_arg_types.test b/parser/testdata/parse/regressions/func_arg_types.test new file mode 100644 index 0000000..acdb61f --- /dev/null +++ b/parser/testdata/parse/regressions/func_arg_types.test @@ -0,0 +1,169 @@ +== 001 +-- func_arg: a param_name is followed by an arg_class or a func_type, so a +-- type_function_name followed by anything else (PRECISION, ARRAY, '[', ...) +-- is the argument's type. pg_dump names functions by unnamed argument +-- types, as pgvector's ACL entries do. +GRANT ALL ON FUNCTION extensions.vector_avg(double precision[]) TO postgres WITH GRANT OPTION +-- +{"version":180004,"stmts":[{"stmt":{"GrantStmt":{"is_grant":true,"targtype":"ACL_TARGET_OBJECT","objtype":"OBJECT_FUNCTION","objects":[{"ObjectWithArgs":{"objname":[{"String":{"sval":"extensions"}},{"String":{"sval":"vector_avg"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":307}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":307},"mode":"FUNC_PARAM_DEFAULT","location":307}}]}}],"grantees":[{"RoleSpec":{"roletype":"ROLESPEC_CSTRING","rolename":"postgres","location":330}}],"grant_option":true,"behavior":"DROP_RESTRICT"}},"stmt_location":263}]} +== 002 +GRANT ALL ON FUNCTION extensions.vector_combine(double precision[], double precision[]) TO postgres WITH GRANT OPTION +-- +{"version":180004,"stmts":[{"stmt":{"GrantStmt":{"is_grant":true,"targtype":"ACL_TARGET_OBJECT","objtype":"OBJECT_FUNCTION","objects":[{"ObjectWithArgs":{"objname":[{"String":{"sval":"extensions"}},{"String":{"sval":"vector_combine"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":48}},{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":68}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":48},"mode":"FUNC_PARAM_DEFAULT","location":48}},{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":68},"mode":"FUNC_PARAM_DEFAULT","location":68}}]}}],"grantees":[{"RoleSpec":{"roletype":"ROLESPEC_CSTRING","rolename":"postgres","location":91}}],"grant_option":true,"behavior":"DROP_RESTRICT"}}}]} +== 003 +GRANT ALL ON FUNCTION extensions.array_to_vector(double precision[], integer, boolean) TO postgres WITH GRANT OPTION +-- +{"version":180004,"stmts":[{"stmt":{"GrantStmt":{"is_grant":true,"targtype":"ACL_TARGET_OBJECT","objtype":"OBJECT_FUNCTION","objects":[{"ObjectWithArgs":{"objname":[{"String":{"sval":"extensions"}},{"String":{"sval":"array_to_vector"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":49}},{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":69}},{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"bool"}}],"typemod":-1,"location":78}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":49},"mode":"FUNC_PARAM_DEFAULT","location":49}},{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":69},"mode":"FUNC_PARAM_DEFAULT","location":69}},{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"bool"}}],"typemod":-1,"location":78},"mode":"FUNC_PARAM_DEFAULT","location":78}}]}}],"grantees":[{"RoleSpec":{"roletype":"ROLESPEC_CSTRING","rolename":"postgres","location":90}}],"grant_option":true,"behavior":"DROP_RESTRICT"}}}]} +== 004 +GRANT ALL ON FUNCTION f(double precision) TO x +-- +{"version":180004,"stmts":[{"stmt":{"GrantStmt":{"is_grant":true,"targtype":"ACL_TARGET_OBJECT","objtype":"OBJECT_FUNCTION","objects":[{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":24}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":24},"mode":"FUNC_PARAM_DEFAULT","location":24}}]}}],"grantees":[{"RoleSpec":{"roletype":"ROLESPEC_CSTRING","rolename":"x","location":45}}],"behavior":"DROP_RESTRICT"}}}]} +== 005 +GRANT ALL ON FUNCTION f(int, double precision) TO x +-- +{"version":180004,"stmts":[{"stmt":{"GrantStmt":{"is_grant":true,"targtype":"ACL_TARGET_OBJECT","objtype":"OBJECT_FUNCTION","objects":[{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":24}},{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":29}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":24},"mode":"FUNC_PARAM_DEFAULT","location":24}},{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":29},"mode":"FUNC_PARAM_DEFAULT","location":29}}]}}],"grantees":[{"RoleSpec":{"roletype":"ROLESPEC_CSTRING","rolename":"x","location":50}}],"behavior":"DROP_RESTRICT"}}}]} +== 006 +REVOKE ALL ON FUNCTION f(double precision) FROM PUBLIC +-- +{"version":180004,"stmts":[{"stmt":{"GrantStmt":{"targtype":"ACL_TARGET_OBJECT","objtype":"OBJECT_FUNCTION","objects":[{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":25}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":25},"mode":"FUNC_PARAM_DEFAULT","location":25}}]}}],"grantees":[{"RoleSpec":{"roletype":"ROLESPEC_PUBLIC","location":48}}],"behavior":"DROP_RESTRICT"}}}]} +== 007 +GRANT ALL ON PROCEDURE p(double precision) TO x +-- +{"version":180004,"stmts":[{"stmt":{"GrantStmt":{"is_grant":true,"targtype":"ACL_TARGET_OBJECT","objtype":"OBJECT_PROCEDURE","objects":[{"ObjectWithArgs":{"objname":[{"String":{"sval":"p"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":25}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":25},"mode":"FUNC_PARAM_DEFAULT","location":25}}]}}],"grantees":[{"RoleSpec":{"roletype":"ROLESPEC_CSTRING","rolename":"x","location":46}}],"behavior":"DROP_RESTRICT"}}}]} +== 008 +GRANT ALL ON ROUTINE f(double precision) TO x +-- +{"version":180004,"stmts":[{"stmt":{"GrantStmt":{"is_grant":true,"targtype":"ACL_TARGET_OBJECT","objtype":"OBJECT_ROUTINE","objects":[{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":23}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":23},"mode":"FUNC_PARAM_DEFAULT","location":23}}]}}],"grantees":[{"RoleSpec":{"roletype":"ROLESPEC_CSTRING","rolename":"x","location":44}}],"behavior":"DROP_RESTRICT"}}}]} +== 009 +DROP FUNCTION f(double precision) +-- +{"version":180004,"stmts":[{"stmt":{"DropStmt":{"objects":[{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":16}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":16},"mode":"FUNC_PARAM_DEFAULT","location":16}}]}}],"removeType":"OBJECT_FUNCTION","behavior":"DROP_RESTRICT"}}}]} +== 010 +DROP ROUTINE f(double precision), g(double precision[]) +-- +{"version":180004,"stmts":[{"stmt":{"DropStmt":{"objects":[{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":15}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":15},"mode":"FUNC_PARAM_DEFAULT","location":15}}]}},{"ObjectWithArgs":{"objname":[{"String":{"sval":"g"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":36}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":36},"mode":"FUNC_PARAM_DEFAULT","location":36}}]}}],"removeType":"OBJECT_ROUTINE","behavior":"DROP_RESTRICT"}}}]} +== 011 +ALTER FUNCTION f(double precision) OWNER TO x +-- +{"version":180004,"stmts":[{"stmt":{"AlterOwnerStmt":{"objectType":"OBJECT_FUNCTION","object":{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":17}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":17},"mode":"FUNC_PARAM_DEFAULT","location":17}}]}},"newowner":{"roletype":"ROLESPEC_CSTRING","rolename":"x","location":44}}}}]} +== 012 +COMMENT ON FUNCTION f(double precision) IS 'c' +-- +{"version":180004,"stmts":[{"stmt":{"CommentStmt":{"objtype":"OBJECT_FUNCTION","object":{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":22}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":22},"mode":"FUNC_PARAM_DEFAULT","location":22}}]}},"comment":"c"}}}]} +== 013 +COMMENT ON AGGREGATE f(double precision) IS 'c' +-- +{"version":180004,"stmts":[{"stmt":{"CommentStmt":{"objtype":"OBJECT_AGGREGATE","object":{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":23}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":23},"mode":"FUNC_PARAM_DEFAULT","location":23}}]}},"comment":"c"}}}]} +== 014 +COMMENT ON AGGREGATE f(double precision ORDER BY double precision) IS 'c' +-- +{"version":180004,"stmts":[{"stmt":{"CommentStmt":{"objtype":"OBJECT_AGGREGATE","object":{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":23}},{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":49}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":23},"mode":"FUNC_PARAM_DEFAULT","location":23}},{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":49},"mode":"FUNC_PARAM_DEFAULT","location":49}}]}},"comment":"c"}}}]} +== 015 +CREATE AGGREGATE f(double precision) (sfunc = g, stype = int) +-- +{"version":180004,"stmts":[{"stmt":{"DefineStmt":{"kind":"OBJECT_AGGREGATE","defnames":[{"String":{"sval":"f"}}],"args":[{"List":{"items":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":19},"mode":"FUNC_PARAM_DEFAULT","location":19}}]}},{"Integer":{"ival":-1}}],"definition":[{"DefElem":{"defname":"sfunc","arg":{"TypeName":{"names":[{"String":{"sval":"g"}}],"typemod":-1,"location":46}},"defaction":"DEFELEM_UNSPEC","location":38}},{"DefElem":{"defname":"stype","arg":{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":57}},"defaction":"DEFELEM_UNSPEC","location":49}}]}}}]} +== 016 +CREATE FUNCTION f(double precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +{"version":180004,"stmts":[{"stmt":{"CreateFunctionStmt":{"funcname":[{"String":{"sval":"f"}}],"parameters":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":18},"mode":"FUNC_PARAM_DEFAULT","location":18}}],"returnType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":44},"options":[{"DefElem":{"defname":"language","arg":{"String":{"sval":"sql"}},"defaction":"DEFELEM_UNSPEC","location":48}},{"DefElem":{"defname":"as","arg":{"List":{"items":[{"String":{"sval":"select 1"}}]}},"defaction":"DEFELEM_UNSPEC","location":61}}]}}}]} +== 017 +CREATE FUNCTION f(IN double precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +{"version":180004,"stmts":[{"stmt":{"CreateFunctionStmt":{"funcname":[{"String":{"sval":"f"}}],"parameters":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":21},"mode":"FUNC_PARAM_IN","location":18}}],"returnType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":47},"options":[{"DefElem":{"defname":"language","arg":{"String":{"sval":"sql"}},"defaction":"DEFELEM_UNSPEC","location":51}},{"DefElem":{"defname":"as","arg":{"List":{"items":[{"String":{"sval":"select 1"}}]}},"defaction":"DEFELEM_UNSPEC","location":64}}]}}}]} +== 018 +CREATE FUNCTION f(VARIADIC double precision[]) RETURNS int LANGUAGE sql AS 'select 1' +-- +{"version":180004,"stmts":[{"stmt":{"CreateFunctionStmt":{"funcname":[{"String":{"sval":"f"}}],"parameters":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":27},"mode":"FUNC_PARAM_VARIADIC","location":18}}],"returnType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":55},"options":[{"DefElem":{"defname":"language","arg":{"String":{"sval":"sql"}},"defaction":"DEFELEM_UNSPEC","location":59}},{"DefElem":{"defname":"as","arg":{"List":{"items":[{"String":{"sval":"select 1"}}]}},"defaction":"DEFELEM_UNSPEC","location":72}}]}}}]} +== 019 +CREATE FUNCTION f(double precision DEFAULT 1) RETURNS int LANGUAGE sql AS 'select 1' +-- +{"version":180004,"stmts":[{"stmt":{"CreateFunctionStmt":{"funcname":[{"String":{"sval":"f"}}],"parameters":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":18},"mode":"FUNC_PARAM_DEFAULT","defexpr":{"A_Const":{"ival":{"ival":1},"location":43}},"location":18}}],"returnType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":54},"options":[{"DefElem":{"defname":"language","arg":{"String":{"sval":"sql"}},"defaction":"DEFELEM_UNSPEC","location":58}},{"DefElem":{"defname":"as","arg":{"List":{"items":[{"String":{"sval":"select 1"}}]}},"defaction":"DEFELEM_UNSPEC","location":71}}]}}}]} +== 020 +CREATE FUNCTION f(double precision = 1) RETURNS int LANGUAGE sql AS 'select 1' +-- +{"version":180004,"stmts":[{"stmt":{"CreateFunctionStmt":{"funcname":[{"String":{"sval":"f"}}],"parameters":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":18},"mode":"FUNC_PARAM_DEFAULT","defexpr":{"A_Const":{"ival":{"ival":1},"location":37}},"location":18}}],"returnType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":48},"options":[{"DefElem":{"defname":"language","arg":{"String":{"sval":"sql"}},"defaction":"DEFELEM_UNSPEC","location":52}},{"DefElem":{"defname":"as","arg":{"List":{"items":[{"String":{"sval":"select 1"}}]}},"defaction":"DEFELEM_UNSPEC","location":65}}]}}}]} +== 021 +CREATE FUNCTION f(a double precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +{"version":180004,"stmts":[{"stmt":{"CreateFunctionStmt":{"funcname":[{"String":{"sval":"f"}}],"parameters":[{"FunctionParameter":{"name":"a","argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":20},"mode":"FUNC_PARAM_DEFAULT","location":18}}],"returnType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":46},"options":[{"DefElem":{"defname":"language","arg":{"String":{"sval":"sql"}},"defaction":"DEFELEM_UNSPEC","location":50}},{"DefElem":{"defname":"as","arg":{"List":{"items":[{"String":{"sval":"select 1"}}]}},"defaction":"DEFELEM_UNSPEC","location":63}}]}}}]} +== 022 +CREATE FUNCTION f(double double precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +{"version":180004,"stmts":[{"stmt":{"CreateFunctionStmt":{"funcname":[{"String":{"sval":"f"}}],"parameters":[{"FunctionParameter":{"name":"double","argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":25},"mode":"FUNC_PARAM_DEFAULT","location":18}}],"returnType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":51},"options":[{"DefElem":{"defname":"language","arg":{"String":{"sval":"sql"}},"defaction":"DEFELEM_UNSPEC","location":55}},{"DefElem":{"defname":"as","arg":{"List":{"items":[{"String":{"sval":"select 1"}}]}},"defaction":"DEFELEM_UNSPEC","location":68}}]}}}]} +== 023 +CREATE FUNCTION f(double int) RETURNS int LANGUAGE sql AS 'select 1' +-- +{"version":180004,"stmts":[{"stmt":{"CreateFunctionStmt":{"funcname":[{"String":{"sval":"f"}}],"parameters":[{"FunctionParameter":{"name":"double","argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":25},"mode":"FUNC_PARAM_DEFAULT","location":18}}],"returnType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":38},"options":[{"DefElem":{"defname":"language","arg":{"String":{"sval":"sql"}},"defaction":"DEFELEM_UNSPEC","location":42}},{"DefElem":{"defname":"as","arg":{"List":{"items":[{"String":{"sval":"select 1"}}]}},"defaction":"DEFELEM_UNSPEC","location":55}}]}}}]} +== 024 +CREATE FUNCTION f(double) RETURNS int LANGUAGE sql AS 'select 1' +-- +{"version":180004,"stmts":[{"stmt":{"CreateFunctionStmt":{"funcname":[{"String":{"sval":"f"}}],"parameters":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"double"}}],"typemod":-1,"location":18},"mode":"FUNC_PARAM_DEFAULT","location":18}}],"returnType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":34},"options":[{"DefElem":{"defname":"language","arg":{"String":{"sval":"sql"}},"defaction":"DEFELEM_UNSPEC","location":38}},{"DefElem":{"defname":"as","arg":{"List":{"items":[{"String":{"sval":"select 1"}}]}},"defaction":"DEFELEM_UNSPEC","location":51}}]}}}]} +== 025 +CREATE FUNCTION f(precision double precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +ERROR: syntax error at or near "precision" +CURSORPOS: 19 +FILENAME: scan.l +FUNCNAME: scanner_yyerror +== 026 +CREATE FUNCTION f(a precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +ERROR: syntax error at or near "precision" +CURSORPOS: 21 +FILENAME: scan.l +FUNCNAME: scanner_yyerror +== 027 +ALTER EXTENSION e ADD FUNCTION f(double precision) +-- +{"version":180004,"stmts":[{"stmt":{"AlterExtensionContentsStmt":{"extname":"e","action":1,"objtype":"OBJECT_FUNCTION","object":{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":33}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":33},"mode":"FUNC_PARAM_DEFAULT","location":33}}]}}}}}]} +== 028 +SECURITY LABEL ON FUNCTION f(double precision) IS 'x' +-- +{"version":180004,"stmts":[{"stmt":{"SecLabelStmt":{"objtype":"OBJECT_FUNCTION","object":{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":29}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":29},"mode":"FUNC_PARAM_DEFAULT","location":29}}]}},"label":"x"}}}]} +== 029 +CREATE CAST (double precision AS int) WITH FUNCTION f(double precision) +-- +{"version":180004,"stmts":[{"stmt":{"CreateCastStmt":{"sourcetype":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":13},"targettype":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":33},"func":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":54}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":54},"mode":"FUNC_PARAM_DEFAULT","location":54}}]},"context":"COERCION_EXPLICIT"}}}]} +== 030 +GRANT ALL ON FUNCTION f(int4 ARRAY) TO x +-- +{"version":180004,"stmts":[{"stmt":{"GrantStmt":{"is_grant":true,"targtype":"ACL_TARGET_OBJECT","objtype":"OBJECT_FUNCTION","objects":[{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"int4"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":24}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"int4"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":24},"mode":"FUNC_PARAM_DEFAULT","location":24}}]}}],"grantees":[{"RoleSpec":{"roletype":"ROLESPEC_CSTRING","rolename":"x","location":39}}],"behavior":"DROP_RESTRICT"}}}]} +== 031 +GRANT ALL ON FUNCTION f(int4 ARRAY[3]) TO x +-- +{"version":180004,"stmts":[{"stmt":{"GrantStmt":{"is_grant":true,"targtype":"ACL_TARGET_OBJECT","objtype":"OBJECT_FUNCTION","objects":[{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"int4"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":3}}],"location":24}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"int4"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":3}}],"location":24},"mode":"FUNC_PARAM_DEFAULT","location":24}}]}}],"grantees":[{"RoleSpec":{"roletype":"ROLESPEC_CSTRING","rolename":"x","location":42}}],"behavior":"DROP_RESTRICT"}}}]} +== 032 +GRANT ALL ON FUNCTION f(public.t ARRAY) TO x +-- +{"version":180004,"stmts":[{"stmt":{"GrantStmt":{"is_grant":true,"targtype":"ACL_TARGET_OBJECT","objtype":"OBJECT_FUNCTION","objects":[{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"public"}},{"String":{"sval":"t"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":24}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"public"}},{"String":{"sval":"t"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":24},"mode":"FUNC_PARAM_DEFAULT","location":24}}]}}],"grantees":[{"RoleSpec":{"roletype":"ROLESPEC_CSTRING","rolename":"x","location":43}}],"behavior":"DROP_RESTRICT"}}}]} +== 033 +CREATE FUNCTION f(a int4 ARRAY) RETURNS int LANGUAGE sql AS 'select 1' +-- +{"version":180004,"stmts":[{"stmt":{"CreateFunctionStmt":{"funcname":[{"String":{"sval":"f"}}],"parameters":[{"FunctionParameter":{"name":"a","argType":{"names":[{"String":{"sval":"int4"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":20},"mode":"FUNC_PARAM_DEFAULT","location":18}}],"returnType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":40},"options":[{"DefElem":{"defname":"language","arg":{"String":{"sval":"sql"}},"defaction":"DEFELEM_UNSPEC","location":44}},{"DefElem":{"defname":"as","arg":{"List":{"items":[{"String":{"sval":"select 1"}}]}},"defaction":"DEFELEM_UNSPEC","location":57}}]}}}]} +== 034 +CREATE FUNCTION f(a ARRAY) RETURNS int LANGUAGE sql AS 'select 1' +-- +{"version":180004,"stmts":[{"stmt":{"CreateFunctionStmt":{"funcname":[{"String":{"sval":"f"}}],"parameters":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"a"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":18},"mode":"FUNC_PARAM_DEFAULT","location":18}}],"returnType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":35},"options":[{"DefElem":{"defname":"language","arg":{"String":{"sval":"sql"}},"defaction":"DEFELEM_UNSPEC","location":39}},{"DefElem":{"defname":"as","arg":{"List":{"items":[{"String":{"sval":"select 1"}}]}},"defaction":"DEFELEM_UNSPEC","location":52}}]}}}]} +== 035 +GRANT ALL ON FUNCTION f(character varying, bit varying, national character varying) TO x +-- +{"version":180004,"stmts":[{"stmt":{"GrantStmt":{"is_grant":true,"targtype":"ACL_TARGET_OBJECT","objtype":"OBJECT_FUNCTION","objects":[{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"varchar"}}],"typemod":-1,"location":24}},{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"varbit"}}],"typemod":-1,"location":43}},{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"varchar"}}],"typemod":-1,"location":56}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"varchar"}}],"typemod":-1,"location":24},"mode":"FUNC_PARAM_DEFAULT","location":24}},{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"varbit"}}],"typemod":-1,"location":43},"mode":"FUNC_PARAM_DEFAULT","location":43}},{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"varchar"}}],"typemod":-1,"location":56},"mode":"FUNC_PARAM_DEFAULT","location":56}}]}}],"grantees":[{"RoleSpec":{"roletype":"ROLESPEC_CSTRING","rolename":"x","location":87}}],"behavior":"DROP_RESTRICT"}}}]} +== 036 +GRANT ALL ON FUNCTION f(timestamp with time zone, time without time zone, interval) TO x +-- +{"version":180004,"stmts":[{"stmt":{"GrantStmt":{"is_grant":true,"targtype":"ACL_TARGET_OBJECT","objtype":"OBJECT_FUNCTION","objects":[{"ObjectWithArgs":{"objname":[{"String":{"sval":"f"}}],"objargs":[{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"timestamptz"}}],"typemod":-1,"location":24}},{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"time"}}],"typemod":-1,"location":50}},{"TypeName":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"interval"}}],"typemod":-1,"location":74}}],"objfuncargs":[{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"timestamptz"}}],"typemod":-1,"location":24},"mode":"FUNC_PARAM_DEFAULT","location":24}},{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"time"}}],"typemod":-1,"location":50},"mode":"FUNC_PARAM_DEFAULT","location":50}},{"FunctionParameter":{"argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"interval"}}],"typemod":-1,"location":74},"mode":"FUNC_PARAM_DEFAULT","location":74}}]}}],"grantees":[{"RoleSpec":{"roletype":"ROLESPEC_CSTRING","rolename":"x","location":87}}],"behavior":"DROP_RESTRICT"}}}]} +== 037 +CREATE FUNCTION f(a OUT double precision, b INOUT int, c IN OUT int, d VARIADIC int[]) RETURNS record LANGUAGE sql AS 'select 1' +-- +{"version":180004,"stmts":[{"stmt":{"CreateFunctionStmt":{"funcname":[{"String":{"sval":"f"}}],"parameters":[{"FunctionParameter":{"name":"a","argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"float8"}}],"typemod":-1,"location":24},"mode":"FUNC_PARAM_OUT","location":18}},{"FunctionParameter":{"name":"b","argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":50},"mode":"FUNC_PARAM_INOUT","location":42}},{"FunctionParameter":{"name":"c","argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":64},"mode":"FUNC_PARAM_INOUT","location":55}},{"FunctionParameter":{"name":"d","argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"arrayBounds":[{"Integer":{"ival":-1}}],"location":80},"mode":"FUNC_PARAM_VARIADIC","location":69}}],"returnType":{"names":[{"String":{"sval":"record"}}],"typemod":-1,"location":95},"options":[{"DefElem":{"defname":"language","arg":{"String":{"sval":"sql"}},"defaction":"DEFELEM_UNSPEC","location":102}},{"DefElem":{"defname":"as","arg":{"List":{"items":[{"String":{"sval":"select 1"}}]}},"defaction":"DEFELEM_UNSPEC","location":115}}]}}}]} +== 038 +CREATE FUNCTION f(a SETOF int) RETURNS int LANGUAGE sql AS 'select 1' +-- +{"version":180004,"stmts":[{"stmt":{"CreateFunctionStmt":{"funcname":[{"String":{"sval":"f"}}],"parameters":[{"FunctionParameter":{"name":"a","argType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"setof":true,"typemod":-1,"location":26},"mode":"FUNC_PARAM_DEFAULT","location":18}}],"returnType":{"names":[{"String":{"sval":"pg_catalog"}},{"String":{"sval":"int4"}}],"typemod":-1,"location":39},"options":[{"DefElem":{"defname":"language","arg":{"String":{"sval":"sql"}},"defaction":"DEFELEM_UNSPEC","location":43}},{"DefElem":{"defname":"as","arg":{"List":{"items":[{"String":{"sval":"select 1"}}]}},"defaction":"DEFELEM_UNSPEC","location":56}}]}}}]} +== 039 +CREATE FUNCTION f(json json, a b.c, d e.f%TYPE, g h(1)) RETURNS int LANGUAGE sql AS 'select 1' +-- +ERROR: syntax error at or near "json" +CURSORPOS: 24 +FILENAME: scan.l +FUNCNAME: scanner_yyerror diff --git a/parser/testdata/scan/regressions/func_arg_types.metadata.json b/parser/testdata/scan/regressions/func_arg_types.metadata.json new file mode 100644 index 0000000..737fd31 --- /dev/null +++ b/parser/testdata/scan/regressions/func_arg_types.metadata.json @@ -0,0 +1,3 @@ +{ + "todo": [] +} diff --git a/parser/testdata/scan/regressions/func_arg_types.test b/parser/testdata/scan/regressions/func_arg_types.test new file mode 100644 index 0000000..246cb64 --- /dev/null +++ b/parser/testdata/scan/regressions/func_arg_types.test @@ -0,0 +1,694 @@ +== 001 +-- func_arg: a param_name is followed by an arg_class or a func_type, so a +-- type_function_name followed by anything else (PRECISION, ARRAY, '[', ...) +-- is the argument's type. pg_dump names functions by unnamed argument +-- types, as pgvector's ACL entries do. +GRANT ALL ON FUNCTION extensions.vector_avg(double precision[]) TO postgres WITH GRANT OPTION +-- +0 74 SQL_COMMENT NO_KEYWORD +75 151 SQL_COMMENT NO_KEYWORD +152 222 SQL_COMMENT NO_KEYWORD +223 262 SQL_COMMENT NO_KEYWORD +263 268 GRANT RESERVED_KEYWORD +269 272 ALL RESERVED_KEYWORD +273 275 ON RESERVED_KEYWORD +276 284 FUNCTION UNRESERVED_KEYWORD +285 295 IDENT NO_KEYWORD +295 296 ASCII_46 NO_KEYWORD +296 306 IDENT NO_KEYWORD +306 307 ASCII_40 NO_KEYWORD +307 313 DOUBLE_P UNRESERVED_KEYWORD +314 323 PRECISION COL_NAME_KEYWORD +323 324 ASCII_91 NO_KEYWORD +324 325 ASCII_93 NO_KEYWORD +325 326 ASCII_41 NO_KEYWORD +327 329 TO RESERVED_KEYWORD +330 338 IDENT NO_KEYWORD +339 343 WITH RESERVED_KEYWORD +344 349 GRANT RESERVED_KEYWORD +350 356 OPTION UNRESERVED_KEYWORD +== 002 +GRANT ALL ON FUNCTION extensions.vector_combine(double precision[], double precision[]) TO postgres WITH GRANT OPTION +-- +0 5 GRANT RESERVED_KEYWORD +6 9 ALL RESERVED_KEYWORD +10 12 ON RESERVED_KEYWORD +13 21 FUNCTION UNRESERVED_KEYWORD +22 32 IDENT NO_KEYWORD +32 33 ASCII_46 NO_KEYWORD +33 47 IDENT NO_KEYWORD +47 48 ASCII_40 NO_KEYWORD +48 54 DOUBLE_P UNRESERVED_KEYWORD +55 64 PRECISION COL_NAME_KEYWORD +64 65 ASCII_91 NO_KEYWORD +65 66 ASCII_93 NO_KEYWORD +66 67 ASCII_44 NO_KEYWORD +68 74 DOUBLE_P UNRESERVED_KEYWORD +75 84 PRECISION COL_NAME_KEYWORD +84 85 ASCII_91 NO_KEYWORD +85 86 ASCII_93 NO_KEYWORD +86 87 ASCII_41 NO_KEYWORD +88 90 TO RESERVED_KEYWORD +91 99 IDENT NO_KEYWORD +100 104 WITH RESERVED_KEYWORD +105 110 GRANT RESERVED_KEYWORD +111 117 OPTION UNRESERVED_KEYWORD +== 003 +GRANT ALL ON FUNCTION extensions.array_to_vector(double precision[], integer, boolean) TO postgres WITH GRANT OPTION +-- +0 5 GRANT RESERVED_KEYWORD +6 9 ALL RESERVED_KEYWORD +10 12 ON RESERVED_KEYWORD +13 21 FUNCTION UNRESERVED_KEYWORD +22 32 IDENT NO_KEYWORD +32 33 ASCII_46 NO_KEYWORD +33 48 IDENT NO_KEYWORD +48 49 ASCII_40 NO_KEYWORD +49 55 DOUBLE_P UNRESERVED_KEYWORD +56 65 PRECISION COL_NAME_KEYWORD +65 66 ASCII_91 NO_KEYWORD +66 67 ASCII_93 NO_KEYWORD +67 68 ASCII_44 NO_KEYWORD +69 76 INTEGER COL_NAME_KEYWORD +76 77 ASCII_44 NO_KEYWORD +78 85 BOOLEAN_P COL_NAME_KEYWORD +85 86 ASCII_41 NO_KEYWORD +87 89 TO RESERVED_KEYWORD +90 98 IDENT NO_KEYWORD +99 103 WITH RESERVED_KEYWORD +104 109 GRANT RESERVED_KEYWORD +110 116 OPTION UNRESERVED_KEYWORD +== 004 +GRANT ALL ON FUNCTION f(double precision) TO x +-- +0 5 GRANT RESERVED_KEYWORD +6 9 ALL RESERVED_KEYWORD +10 12 ON RESERVED_KEYWORD +13 21 FUNCTION UNRESERVED_KEYWORD +22 23 IDENT NO_KEYWORD +23 24 ASCII_40 NO_KEYWORD +24 30 DOUBLE_P UNRESERVED_KEYWORD +31 40 PRECISION COL_NAME_KEYWORD +40 41 ASCII_41 NO_KEYWORD +42 44 TO RESERVED_KEYWORD +45 46 IDENT NO_KEYWORD +== 005 +GRANT ALL ON FUNCTION f(int, double precision) TO x +-- +0 5 GRANT RESERVED_KEYWORD +6 9 ALL RESERVED_KEYWORD +10 12 ON RESERVED_KEYWORD +13 21 FUNCTION UNRESERVED_KEYWORD +22 23 IDENT NO_KEYWORD +23 24 ASCII_40 NO_KEYWORD +24 27 INT_P COL_NAME_KEYWORD +27 28 ASCII_44 NO_KEYWORD +29 35 DOUBLE_P UNRESERVED_KEYWORD +36 45 PRECISION COL_NAME_KEYWORD +45 46 ASCII_41 NO_KEYWORD +47 49 TO RESERVED_KEYWORD +50 51 IDENT NO_KEYWORD +== 006 +REVOKE ALL ON FUNCTION f(double precision) FROM PUBLIC +-- +0 6 REVOKE UNRESERVED_KEYWORD +7 10 ALL RESERVED_KEYWORD +11 13 ON RESERVED_KEYWORD +14 22 FUNCTION UNRESERVED_KEYWORD +23 24 IDENT NO_KEYWORD +24 25 ASCII_40 NO_KEYWORD +25 31 DOUBLE_P UNRESERVED_KEYWORD +32 41 PRECISION COL_NAME_KEYWORD +41 42 ASCII_41 NO_KEYWORD +43 47 FROM RESERVED_KEYWORD +48 54 IDENT NO_KEYWORD +== 007 +GRANT ALL ON PROCEDURE p(double precision) TO x +-- +0 5 GRANT RESERVED_KEYWORD +6 9 ALL RESERVED_KEYWORD +10 12 ON RESERVED_KEYWORD +13 22 PROCEDURE UNRESERVED_KEYWORD +23 24 IDENT NO_KEYWORD +24 25 ASCII_40 NO_KEYWORD +25 31 DOUBLE_P UNRESERVED_KEYWORD +32 41 PRECISION COL_NAME_KEYWORD +41 42 ASCII_41 NO_KEYWORD +43 45 TO RESERVED_KEYWORD +46 47 IDENT NO_KEYWORD +== 008 +GRANT ALL ON ROUTINE f(double precision) TO x +-- +0 5 GRANT RESERVED_KEYWORD +6 9 ALL RESERVED_KEYWORD +10 12 ON RESERVED_KEYWORD +13 20 ROUTINE UNRESERVED_KEYWORD +21 22 IDENT NO_KEYWORD +22 23 ASCII_40 NO_KEYWORD +23 29 DOUBLE_P UNRESERVED_KEYWORD +30 39 PRECISION COL_NAME_KEYWORD +39 40 ASCII_41 NO_KEYWORD +41 43 TO RESERVED_KEYWORD +44 45 IDENT NO_KEYWORD +== 009 +DROP FUNCTION f(double precision) +-- +0 4 DROP UNRESERVED_KEYWORD +5 13 FUNCTION UNRESERVED_KEYWORD +14 15 IDENT NO_KEYWORD +15 16 ASCII_40 NO_KEYWORD +16 22 DOUBLE_P UNRESERVED_KEYWORD +23 32 PRECISION COL_NAME_KEYWORD +32 33 ASCII_41 NO_KEYWORD +== 010 +DROP ROUTINE f(double precision), g(double precision[]) +-- +0 4 DROP UNRESERVED_KEYWORD +5 12 ROUTINE UNRESERVED_KEYWORD +13 14 IDENT NO_KEYWORD +14 15 ASCII_40 NO_KEYWORD +15 21 DOUBLE_P UNRESERVED_KEYWORD +22 31 PRECISION COL_NAME_KEYWORD +31 32 ASCII_41 NO_KEYWORD +32 33 ASCII_44 NO_KEYWORD +34 35 IDENT NO_KEYWORD +35 36 ASCII_40 NO_KEYWORD +36 42 DOUBLE_P UNRESERVED_KEYWORD +43 52 PRECISION COL_NAME_KEYWORD +52 53 ASCII_91 NO_KEYWORD +53 54 ASCII_93 NO_KEYWORD +54 55 ASCII_41 NO_KEYWORD +== 011 +ALTER FUNCTION f(double precision) OWNER TO x +-- +0 5 ALTER UNRESERVED_KEYWORD +6 14 FUNCTION UNRESERVED_KEYWORD +15 16 IDENT NO_KEYWORD +16 17 ASCII_40 NO_KEYWORD +17 23 DOUBLE_P UNRESERVED_KEYWORD +24 33 PRECISION COL_NAME_KEYWORD +33 34 ASCII_41 NO_KEYWORD +35 40 OWNER UNRESERVED_KEYWORD +41 43 TO RESERVED_KEYWORD +44 45 IDENT NO_KEYWORD +== 012 +COMMENT ON FUNCTION f(double precision) IS 'c' +-- +0 7 COMMENT UNRESERVED_KEYWORD +8 10 ON RESERVED_KEYWORD +11 19 FUNCTION UNRESERVED_KEYWORD +20 21 IDENT NO_KEYWORD +21 22 ASCII_40 NO_KEYWORD +22 28 DOUBLE_P UNRESERVED_KEYWORD +29 38 PRECISION COL_NAME_KEYWORD +38 39 ASCII_41 NO_KEYWORD +40 42 IS TYPE_FUNC_NAME_KEYWORD +43 46 SCONST NO_KEYWORD +== 013 +COMMENT ON AGGREGATE f(double precision) IS 'c' +-- +0 7 COMMENT UNRESERVED_KEYWORD +8 10 ON RESERVED_KEYWORD +11 20 AGGREGATE UNRESERVED_KEYWORD +21 22 IDENT NO_KEYWORD +22 23 ASCII_40 NO_KEYWORD +23 29 DOUBLE_P UNRESERVED_KEYWORD +30 39 PRECISION COL_NAME_KEYWORD +39 40 ASCII_41 NO_KEYWORD +41 43 IS TYPE_FUNC_NAME_KEYWORD +44 47 SCONST NO_KEYWORD +== 014 +COMMENT ON AGGREGATE f(double precision ORDER BY double precision) IS 'c' +-- +0 7 COMMENT UNRESERVED_KEYWORD +8 10 ON RESERVED_KEYWORD +11 20 AGGREGATE UNRESERVED_KEYWORD +21 22 IDENT NO_KEYWORD +22 23 ASCII_40 NO_KEYWORD +23 29 DOUBLE_P UNRESERVED_KEYWORD +30 39 PRECISION COL_NAME_KEYWORD +40 45 ORDER RESERVED_KEYWORD +46 48 BY UNRESERVED_KEYWORD +49 55 DOUBLE_P UNRESERVED_KEYWORD +56 65 PRECISION COL_NAME_KEYWORD +65 66 ASCII_41 NO_KEYWORD +67 69 IS TYPE_FUNC_NAME_KEYWORD +70 73 SCONST NO_KEYWORD +== 015 +CREATE AGGREGATE f(double precision) (sfunc = g, stype = int) +-- +0 6 CREATE RESERVED_KEYWORD +7 16 AGGREGATE UNRESERVED_KEYWORD +17 18 IDENT NO_KEYWORD +18 19 ASCII_40 NO_KEYWORD +19 25 DOUBLE_P UNRESERVED_KEYWORD +26 35 PRECISION COL_NAME_KEYWORD +35 36 ASCII_41 NO_KEYWORD +37 38 ASCII_40 NO_KEYWORD +38 43 IDENT NO_KEYWORD +44 45 ASCII_61 NO_KEYWORD +46 47 IDENT NO_KEYWORD +47 48 ASCII_44 NO_KEYWORD +49 54 IDENT NO_KEYWORD +55 56 ASCII_61 NO_KEYWORD +57 60 INT_P COL_NAME_KEYWORD +60 61 ASCII_41 NO_KEYWORD +== 016 +CREATE FUNCTION f(double precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 24 DOUBLE_P UNRESERVED_KEYWORD +25 34 PRECISION COL_NAME_KEYWORD +34 35 ASCII_41 NO_KEYWORD +36 43 RETURNS UNRESERVED_KEYWORD +44 47 INT_P COL_NAME_KEYWORD +48 56 LANGUAGE UNRESERVED_KEYWORD +57 60 SQL_P UNRESERVED_KEYWORD +61 63 AS RESERVED_KEYWORD +64 74 SCONST NO_KEYWORD +== 017 +CREATE FUNCTION f(IN double precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 20 IN_P RESERVED_KEYWORD +21 27 DOUBLE_P UNRESERVED_KEYWORD +28 37 PRECISION COL_NAME_KEYWORD +37 38 ASCII_41 NO_KEYWORD +39 46 RETURNS UNRESERVED_KEYWORD +47 50 INT_P COL_NAME_KEYWORD +51 59 LANGUAGE UNRESERVED_KEYWORD +60 63 SQL_P UNRESERVED_KEYWORD +64 66 AS RESERVED_KEYWORD +67 77 SCONST NO_KEYWORD +== 018 +CREATE FUNCTION f(VARIADIC double precision[]) RETURNS int LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 26 VARIADIC RESERVED_KEYWORD +27 33 DOUBLE_P UNRESERVED_KEYWORD +34 43 PRECISION COL_NAME_KEYWORD +43 44 ASCII_91 NO_KEYWORD +44 45 ASCII_93 NO_KEYWORD +45 46 ASCII_41 NO_KEYWORD +47 54 RETURNS UNRESERVED_KEYWORD +55 58 INT_P COL_NAME_KEYWORD +59 67 LANGUAGE UNRESERVED_KEYWORD +68 71 SQL_P UNRESERVED_KEYWORD +72 74 AS RESERVED_KEYWORD +75 85 SCONST NO_KEYWORD +== 019 +CREATE FUNCTION f(double precision DEFAULT 1) RETURNS int LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 24 DOUBLE_P UNRESERVED_KEYWORD +25 34 PRECISION COL_NAME_KEYWORD +35 42 DEFAULT RESERVED_KEYWORD +43 44 ICONST NO_KEYWORD +44 45 ASCII_41 NO_KEYWORD +46 53 RETURNS UNRESERVED_KEYWORD +54 57 INT_P COL_NAME_KEYWORD +58 66 LANGUAGE UNRESERVED_KEYWORD +67 70 SQL_P UNRESERVED_KEYWORD +71 73 AS RESERVED_KEYWORD +74 84 SCONST NO_KEYWORD +== 020 +CREATE FUNCTION f(double precision = 1) RETURNS int LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 24 DOUBLE_P UNRESERVED_KEYWORD +25 34 PRECISION COL_NAME_KEYWORD +35 36 ASCII_61 NO_KEYWORD +37 38 ICONST NO_KEYWORD +38 39 ASCII_41 NO_KEYWORD +40 47 RETURNS UNRESERVED_KEYWORD +48 51 INT_P COL_NAME_KEYWORD +52 60 LANGUAGE UNRESERVED_KEYWORD +61 64 SQL_P UNRESERVED_KEYWORD +65 67 AS RESERVED_KEYWORD +68 78 SCONST NO_KEYWORD +== 021 +CREATE FUNCTION f(a double precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 19 IDENT NO_KEYWORD +20 26 DOUBLE_P UNRESERVED_KEYWORD +27 36 PRECISION COL_NAME_KEYWORD +36 37 ASCII_41 NO_KEYWORD +38 45 RETURNS UNRESERVED_KEYWORD +46 49 INT_P COL_NAME_KEYWORD +50 58 LANGUAGE UNRESERVED_KEYWORD +59 62 SQL_P UNRESERVED_KEYWORD +63 65 AS RESERVED_KEYWORD +66 76 SCONST NO_KEYWORD +== 022 +CREATE FUNCTION f(double double precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 24 DOUBLE_P UNRESERVED_KEYWORD +25 31 DOUBLE_P UNRESERVED_KEYWORD +32 41 PRECISION COL_NAME_KEYWORD +41 42 ASCII_41 NO_KEYWORD +43 50 RETURNS UNRESERVED_KEYWORD +51 54 INT_P COL_NAME_KEYWORD +55 63 LANGUAGE UNRESERVED_KEYWORD +64 67 SQL_P UNRESERVED_KEYWORD +68 70 AS RESERVED_KEYWORD +71 81 SCONST NO_KEYWORD +== 023 +CREATE FUNCTION f(double int) RETURNS int LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 24 DOUBLE_P UNRESERVED_KEYWORD +25 28 INT_P COL_NAME_KEYWORD +28 29 ASCII_41 NO_KEYWORD +30 37 RETURNS UNRESERVED_KEYWORD +38 41 INT_P COL_NAME_KEYWORD +42 50 LANGUAGE UNRESERVED_KEYWORD +51 54 SQL_P UNRESERVED_KEYWORD +55 57 AS RESERVED_KEYWORD +58 68 SCONST NO_KEYWORD +== 024 +CREATE FUNCTION f(double) RETURNS int LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 24 DOUBLE_P UNRESERVED_KEYWORD +24 25 ASCII_41 NO_KEYWORD +26 33 RETURNS UNRESERVED_KEYWORD +34 37 INT_P COL_NAME_KEYWORD +38 46 LANGUAGE UNRESERVED_KEYWORD +47 50 SQL_P UNRESERVED_KEYWORD +51 53 AS RESERVED_KEYWORD +54 64 SCONST NO_KEYWORD +== 025 +CREATE FUNCTION f(precision double precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 27 PRECISION COL_NAME_KEYWORD +28 34 DOUBLE_P UNRESERVED_KEYWORD +35 44 PRECISION COL_NAME_KEYWORD +44 45 ASCII_41 NO_KEYWORD +46 53 RETURNS UNRESERVED_KEYWORD +54 57 INT_P COL_NAME_KEYWORD +58 66 LANGUAGE UNRESERVED_KEYWORD +67 70 SQL_P UNRESERVED_KEYWORD +71 73 AS RESERVED_KEYWORD +74 84 SCONST NO_KEYWORD +== 026 +CREATE FUNCTION f(a precision) RETURNS int LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 19 IDENT NO_KEYWORD +20 29 PRECISION COL_NAME_KEYWORD +29 30 ASCII_41 NO_KEYWORD +31 38 RETURNS UNRESERVED_KEYWORD +39 42 INT_P COL_NAME_KEYWORD +43 51 LANGUAGE UNRESERVED_KEYWORD +52 55 SQL_P UNRESERVED_KEYWORD +56 58 AS RESERVED_KEYWORD +59 69 SCONST NO_KEYWORD +== 027 +ALTER EXTENSION e ADD FUNCTION f(double precision) +-- +0 5 ALTER UNRESERVED_KEYWORD +6 15 EXTENSION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +18 21 ADD_P UNRESERVED_KEYWORD +22 30 FUNCTION UNRESERVED_KEYWORD +31 32 IDENT NO_KEYWORD +32 33 ASCII_40 NO_KEYWORD +33 39 DOUBLE_P UNRESERVED_KEYWORD +40 49 PRECISION COL_NAME_KEYWORD +49 50 ASCII_41 NO_KEYWORD +== 028 +SECURITY LABEL ON FUNCTION f(double precision) IS 'x' +-- +0 8 SECURITY UNRESERVED_KEYWORD +9 14 LABEL UNRESERVED_KEYWORD +15 17 ON RESERVED_KEYWORD +18 26 FUNCTION UNRESERVED_KEYWORD +27 28 IDENT NO_KEYWORD +28 29 ASCII_40 NO_KEYWORD +29 35 DOUBLE_P UNRESERVED_KEYWORD +36 45 PRECISION COL_NAME_KEYWORD +45 46 ASCII_41 NO_KEYWORD +47 49 IS TYPE_FUNC_NAME_KEYWORD +50 53 SCONST NO_KEYWORD +== 029 +CREATE CAST (double precision AS int) WITH FUNCTION f(double precision) +-- +0 6 CREATE RESERVED_KEYWORD +7 11 CAST RESERVED_KEYWORD +12 13 ASCII_40 NO_KEYWORD +13 19 DOUBLE_P UNRESERVED_KEYWORD +20 29 PRECISION COL_NAME_KEYWORD +30 32 AS RESERVED_KEYWORD +33 36 INT_P COL_NAME_KEYWORD +36 37 ASCII_41 NO_KEYWORD +38 42 WITH RESERVED_KEYWORD +43 51 FUNCTION UNRESERVED_KEYWORD +52 53 IDENT NO_KEYWORD +53 54 ASCII_40 NO_KEYWORD +54 60 DOUBLE_P UNRESERVED_KEYWORD +61 70 PRECISION COL_NAME_KEYWORD +70 71 ASCII_41 NO_KEYWORD +== 030 +GRANT ALL ON FUNCTION f(int4 ARRAY) TO x +-- +0 5 GRANT RESERVED_KEYWORD +6 9 ALL RESERVED_KEYWORD +10 12 ON RESERVED_KEYWORD +13 21 FUNCTION UNRESERVED_KEYWORD +22 23 IDENT NO_KEYWORD +23 24 ASCII_40 NO_KEYWORD +24 28 IDENT NO_KEYWORD +29 34 ARRAY RESERVED_KEYWORD +34 35 ASCII_41 NO_KEYWORD +36 38 TO RESERVED_KEYWORD +39 40 IDENT NO_KEYWORD +== 031 +GRANT ALL ON FUNCTION f(int4 ARRAY[3]) TO x +-- +0 5 GRANT RESERVED_KEYWORD +6 9 ALL RESERVED_KEYWORD +10 12 ON RESERVED_KEYWORD +13 21 FUNCTION UNRESERVED_KEYWORD +22 23 IDENT NO_KEYWORD +23 24 ASCII_40 NO_KEYWORD +24 28 IDENT NO_KEYWORD +29 34 ARRAY RESERVED_KEYWORD +34 35 ASCII_91 NO_KEYWORD +35 36 ICONST NO_KEYWORD +36 37 ASCII_93 NO_KEYWORD +37 38 ASCII_41 NO_KEYWORD +39 41 TO RESERVED_KEYWORD +42 43 IDENT NO_KEYWORD +== 032 +GRANT ALL ON FUNCTION f(public.t ARRAY) TO x +-- +0 5 GRANT RESERVED_KEYWORD +6 9 ALL RESERVED_KEYWORD +10 12 ON RESERVED_KEYWORD +13 21 FUNCTION UNRESERVED_KEYWORD +22 23 IDENT NO_KEYWORD +23 24 ASCII_40 NO_KEYWORD +24 30 IDENT NO_KEYWORD +30 31 ASCII_46 NO_KEYWORD +31 32 IDENT NO_KEYWORD +33 38 ARRAY RESERVED_KEYWORD +38 39 ASCII_41 NO_KEYWORD +40 42 TO RESERVED_KEYWORD +43 44 IDENT NO_KEYWORD +== 033 +CREATE FUNCTION f(a int4 ARRAY) RETURNS int LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 19 IDENT NO_KEYWORD +20 24 IDENT NO_KEYWORD +25 30 ARRAY RESERVED_KEYWORD +30 31 ASCII_41 NO_KEYWORD +32 39 RETURNS UNRESERVED_KEYWORD +40 43 INT_P COL_NAME_KEYWORD +44 52 LANGUAGE UNRESERVED_KEYWORD +53 56 SQL_P UNRESERVED_KEYWORD +57 59 AS RESERVED_KEYWORD +60 70 SCONST NO_KEYWORD +== 034 +CREATE FUNCTION f(a ARRAY) RETURNS int LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 19 IDENT NO_KEYWORD +20 25 ARRAY RESERVED_KEYWORD +25 26 ASCII_41 NO_KEYWORD +27 34 RETURNS UNRESERVED_KEYWORD +35 38 INT_P COL_NAME_KEYWORD +39 47 LANGUAGE UNRESERVED_KEYWORD +48 51 SQL_P UNRESERVED_KEYWORD +52 54 AS RESERVED_KEYWORD +55 65 SCONST NO_KEYWORD +== 035 +GRANT ALL ON FUNCTION f(character varying, bit varying, national character varying) TO x +-- +0 5 GRANT RESERVED_KEYWORD +6 9 ALL RESERVED_KEYWORD +10 12 ON RESERVED_KEYWORD +13 21 FUNCTION UNRESERVED_KEYWORD +22 23 IDENT NO_KEYWORD +23 24 ASCII_40 NO_KEYWORD +24 33 CHARACTER COL_NAME_KEYWORD +34 41 VARYING UNRESERVED_KEYWORD +41 42 ASCII_44 NO_KEYWORD +43 46 BIT COL_NAME_KEYWORD +47 54 VARYING UNRESERVED_KEYWORD +54 55 ASCII_44 NO_KEYWORD +56 64 NATIONAL COL_NAME_KEYWORD +65 74 CHARACTER COL_NAME_KEYWORD +75 82 VARYING UNRESERVED_KEYWORD +82 83 ASCII_41 NO_KEYWORD +84 86 TO RESERVED_KEYWORD +87 88 IDENT NO_KEYWORD +== 036 +GRANT ALL ON FUNCTION f(timestamp with time zone, time without time zone, interval) TO x +-- +0 5 GRANT RESERVED_KEYWORD +6 9 ALL RESERVED_KEYWORD +10 12 ON RESERVED_KEYWORD +13 21 FUNCTION UNRESERVED_KEYWORD +22 23 IDENT NO_KEYWORD +23 24 ASCII_40 NO_KEYWORD +24 33 TIMESTAMP COL_NAME_KEYWORD +34 38 WITH RESERVED_KEYWORD +39 43 TIME COL_NAME_KEYWORD +44 48 ZONE UNRESERVED_KEYWORD +48 49 ASCII_44 NO_KEYWORD +50 54 TIME COL_NAME_KEYWORD +55 62 WITHOUT UNRESERVED_KEYWORD +63 67 TIME COL_NAME_KEYWORD +68 72 ZONE UNRESERVED_KEYWORD +72 73 ASCII_44 NO_KEYWORD +74 82 INTERVAL COL_NAME_KEYWORD +82 83 ASCII_41 NO_KEYWORD +84 86 TO RESERVED_KEYWORD +87 88 IDENT NO_KEYWORD +== 037 +CREATE FUNCTION f(a OUT double precision, b INOUT int, c IN OUT int, d VARIADIC int[]) RETURNS record LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 19 IDENT NO_KEYWORD +20 23 OUT_P COL_NAME_KEYWORD +24 30 DOUBLE_P UNRESERVED_KEYWORD +31 40 PRECISION COL_NAME_KEYWORD +40 41 ASCII_44 NO_KEYWORD +42 43 IDENT NO_KEYWORD +44 49 INOUT COL_NAME_KEYWORD +50 53 INT_P COL_NAME_KEYWORD +53 54 ASCII_44 NO_KEYWORD +55 56 IDENT NO_KEYWORD +57 59 IN_P RESERVED_KEYWORD +60 63 OUT_P COL_NAME_KEYWORD +64 67 INT_P COL_NAME_KEYWORD +67 68 ASCII_44 NO_KEYWORD +69 70 IDENT NO_KEYWORD +71 79 VARIADIC RESERVED_KEYWORD +80 83 INT_P COL_NAME_KEYWORD +83 84 ASCII_91 NO_KEYWORD +84 85 ASCII_93 NO_KEYWORD +85 86 ASCII_41 NO_KEYWORD +87 94 RETURNS UNRESERVED_KEYWORD +95 101 IDENT NO_KEYWORD +102 110 LANGUAGE UNRESERVED_KEYWORD +111 114 SQL_P UNRESERVED_KEYWORD +115 117 AS RESERVED_KEYWORD +118 128 SCONST NO_KEYWORD +== 038 +CREATE FUNCTION f(a SETOF int) RETURNS int LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 19 IDENT NO_KEYWORD +20 25 SETOF COL_NAME_KEYWORD +26 29 INT_P COL_NAME_KEYWORD +29 30 ASCII_41 NO_KEYWORD +31 38 RETURNS UNRESERVED_KEYWORD +39 42 INT_P COL_NAME_KEYWORD +43 51 LANGUAGE UNRESERVED_KEYWORD +52 55 SQL_P UNRESERVED_KEYWORD +56 58 AS RESERVED_KEYWORD +59 69 SCONST NO_KEYWORD +== 039 +CREATE FUNCTION f(json json, a b.c, d e.f%TYPE, g h(1)) RETURNS int LANGUAGE sql AS 'select 1' +-- +0 6 CREATE RESERVED_KEYWORD +7 15 FUNCTION UNRESERVED_KEYWORD +16 17 IDENT NO_KEYWORD +17 18 ASCII_40 NO_KEYWORD +18 22 JSON COL_NAME_KEYWORD +23 27 JSON COL_NAME_KEYWORD +27 28 ASCII_44 NO_KEYWORD +29 30 IDENT NO_KEYWORD +31 32 IDENT NO_KEYWORD +32 33 ASCII_46 NO_KEYWORD +33 34 IDENT NO_KEYWORD +34 35 ASCII_44 NO_KEYWORD +36 37 IDENT NO_KEYWORD +38 39 IDENT NO_KEYWORD +39 40 ASCII_46 NO_KEYWORD +40 41 IDENT NO_KEYWORD +41 42 ASCII_37 NO_KEYWORD +42 46 TYPE_P UNRESERVED_KEYWORD +46 47 ASCII_44 NO_KEYWORD +48 49 IDENT NO_KEYWORD +50 51 IDENT NO_KEYWORD +51 52 ASCII_40 NO_KEYWORD +52 53 ICONST NO_KEYWORD +53 54 ASCII_41 NO_KEYWORD +54 55 ASCII_41 NO_KEYWORD +56 63 RETURNS UNRESERVED_KEYWORD +64 67 INT_P COL_NAME_KEYWORD +68 76 LANGUAGE UNRESERVED_KEYWORD +77 80 SQL_P UNRESERVED_KEYWORD +81 83 AS RESERVED_KEYWORD +84 94 SCONST NO_KEYWORD