mirror of
https://git.postgresql.org/git/postgresql.git
synced 2025-03-19 20:00:51 +08:00
Partial pgindent of .l and .y files
Trying to clean up the code a bit while we're working on these files for the reentrant scanner/pure parser patches. This cleanup only touches the code sections after the second '%%' in each file, via a manually-supervised and locally hacked up pgindent.
This commit is contained in:
Peter Eisentraut
parent
2571c1d5cc
commit
301de6a6f6
@ -244,8 +244,8 @@ write_box(int dim, char *str1, char *str2,
|
||||
* The value turned out to be a point, ie. all the upper-right
|
||||
* coordinates were equal to the lower-left coordinates. Resize the
|
||||
* cube we constructed. Note: we don't bother to repalloc() it
|
||||
* smaller, as it's unlikely that the tiny amount of memory freed
|
||||
* that way would be useful, and the output is always short-lived.
|
||||
* smaller, as it's unlikely that the tiny amount of memory freed that
|
||||
* way would be useful, and the output is always short-lived.
|
||||
*/
|
||||
size = POINT_SIZE(dim);
|
||||
SET_VARSIZE(bp, size);
|
||||
@ -260,7 +260,7 @@ static bool
|
||||
write_point_as_box(int dim, char *str,
|
||||
NDBOX **result, struct Node *escontext)
|
||||
{
|
||||
NDBOX *bp;
|
||||
NDBOX *bp;
|
||||
int i,
|
||||
size;
|
||||
char *s;
|
||||
|
||||
@ -73,14 +73,15 @@ cube_yyerror(NDBOX **result, Size scanbuflen,
|
||||
yyscan_t yyscanner,
|
||||
const char *message)
|
||||
{
|
||||
struct yyguts_t * yyg = (struct yyguts_t *) yyscanner; /* needed for yytext macro */
|
||||
struct yyguts_t *yyg = (struct yyguts_t *) yyscanner; /* needed for yytext
|
||||
* macro */
|
||||
|
||||
if (*yytext == YY_END_OF_BUFFER_CHAR)
|
||||
{
|
||||
errsave(escontext,
|
||||
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
|
||||
errmsg("invalid input syntax for cube"),
|
||||
/* translator: %s is typically "syntax error" */
|
||||
/* translator: %s is typically "syntax error" */
|
||||
errdetail("%s at end of input", message)));
|
||||
}
|
||||
else
|
||||
@ -88,7 +89,7 @@ cube_yyerror(NDBOX **result, Size scanbuflen,
|
||||
errsave(escontext,
|
||||
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
|
||||
errmsg("invalid input syntax for cube"),
|
||||
/* translator: first %s is typically "syntax error" */
|
||||
/* translator: first %s is typically "syntax error" */
|
||||
errdetail("%s at or near \"%s\"", message, yytext)));
|
||||
}
|
||||
}
|
||||
|
||||
@ -66,7 +66,8 @@ float ({integer}|{real})([eE]{integer})?
|
||||
void
|
||||
seg_yyerror(SEG *result, struct Node *escontext, yyscan_t yyscanner, const char *message)
|
||||
{
|
||||
struct yyguts_t * yyg = (struct yyguts_t *) yyscanner; /* needed for yytext macro */
|
||||
struct yyguts_t *yyg = (struct yyguts_t *) yyscanner; /* needed for yytext
|
||||
* macro */
|
||||
|
||||
/* if we already reported an error, don't overwrite it */
|
||||
if (SOFT_ERROR_OCCURRED(escontext))
|
||||
@ -77,7 +78,7 @@ seg_yyerror(SEG *result, struct Node *escontext, yyscan_t yyscanner, const char
|
||||
errsave(escontext,
|
||||
(errcode(ERRCODE_SYNTAX_ERROR),
|
||||
errmsg("bad seg representation"),
|
||||
/* translator: %s is typically "syntax error" */
|
||||
/* translator: %s is typically "syntax error" */
|
||||
errdetail("%s at end of input", message)));
|
||||
}
|
||||
else
|
||||
@ -85,7 +86,7 @@ seg_yyerror(SEG *result, struct Node *escontext, yyscan_t yyscanner, const char
|
||||
errsave(escontext,
|
||||
(errcode(ERRCODE_SYNTAX_ERROR),
|
||||
errmsg("bad seg representation"),
|
||||
/* translator: first %s is typically "syntax error" */
|
||||
/* translator: first %s is typically "syntax error" */
|
||||
errdetail("%s at or near \"%s\"", message, yytext)));
|
||||
}
|
||||
}
|
||||
@ -97,7 +98,7 @@ seg_yyerror(SEG *result, struct Node *escontext, yyscan_t yyscanner, const char
|
||||
void
|
||||
seg_scanner_init(const char *str, yyscan_t *yyscannerp)
|
||||
{
|
||||
yyscan_t yyscanner;
|
||||
yyscan_t yyscanner;
|
||||
|
||||
if (yylex_init(yyscannerp) != 0)
|
||||
elog(ERROR, "yylex_init() failed: %m");
|
||||
|
||||
@ -131,7 +131,8 @@ NULL { yylval->kw = "NULL"; return XNULL; }
|
||||
void
|
||||
boot_yyerror(yyscan_t yyscanner, const char *message)
|
||||
{
|
||||
struct yyguts_t * yyg = (struct yyguts_t *) yyscanner; /* needed for yylineno macro */
|
||||
struct yyguts_t *yyg = (struct yyguts_t *) yyscanner; /* needed for yylineno
|
||||
* macro */
|
||||
|
||||
elog(ERROR, "%s at line %d", message, yylineno);
|
||||
}
|
||||
@ -159,6 +160,6 @@ yyrealloc(void *ptr, yy_size_t size, yyscan_t yyscanner)
|
||||
void
|
||||
yyfree(void *ptr, yyscan_t yyscanner)
|
||||
{
|
||||
if (ptr)
|
||||
pfree(ptr);
|
||||
if (ptr)
|
||||
pfree(ptr);
|
||||
}
|
||||
|
||||
@ -18646,31 +18646,31 @@ updatePreparableStmtEnd(Node *n, int end_location)
|
||||
{
|
||||
if (IsA(n, SelectStmt))
|
||||
{
|
||||
SelectStmt *stmt = (SelectStmt *)n;
|
||||
SelectStmt *stmt = (SelectStmt *) n;
|
||||
|
||||
stmt->stmt_len = end_location - stmt->stmt_location;
|
||||
}
|
||||
else if (IsA(n, InsertStmt))
|
||||
{
|
||||
InsertStmt *stmt = (InsertStmt *)n;
|
||||
InsertStmt *stmt = (InsertStmt *) n;
|
||||
|
||||
stmt->stmt_len = end_location - stmt->stmt_location;
|
||||
}
|
||||
else if (IsA(n, UpdateStmt))
|
||||
{
|
||||
UpdateStmt *stmt = (UpdateStmt *)n;
|
||||
UpdateStmt *stmt = (UpdateStmt *) n;
|
||||
|
||||
stmt->stmt_len = end_location - stmt->stmt_location;
|
||||
}
|
||||
else if (IsA(n, DeleteStmt))
|
||||
{
|
||||
DeleteStmt *stmt = (DeleteStmt *)n;
|
||||
DeleteStmt *stmt = (DeleteStmt *) n;
|
||||
|
||||
stmt->stmt_len = end_location - stmt->stmt_location;
|
||||
}
|
||||
else if (IsA(n, MergeStmt))
|
||||
{
|
||||
MergeStmt *stmt = (MergeStmt *)n;
|
||||
MergeStmt *stmt = (MergeStmt *) n;
|
||||
|
||||
stmt->stmt_len = end_location - stmt->stmt_location;
|
||||
}
|
||||
@ -18683,10 +18683,10 @@ makeColumnRef(char *colname, List *indirection,
|
||||
int location, core_yyscan_t yyscanner)
|
||||
{
|
||||
/*
|
||||
* Generate a ColumnRef node, with an A_Indirection node added if there
|
||||
* is any subscripting in the specified indirection list. However,
|
||||
* any field selection at the start of the indirection list must be
|
||||
* transposed into the "fields" part of the ColumnRef node.
|
||||
* Generate a ColumnRef node, with an A_Indirection node added if there is
|
||||
* any subscripting in the specified indirection list. However, any field
|
||||
* selection at the start of the indirection list must be transposed into
|
||||
* the "fields" part of the ColumnRef node.
|
||||
*/
|
||||
ColumnRef *c = makeNode(ColumnRef);
|
||||
int nfields = 0;
|
||||
@ -18752,55 +18752,55 @@ makeStringConstCast(char *str, int location, TypeName *typename)
|
||||
static Node *
|
||||
makeIntConst(int val, int location)
|
||||
{
|
||||
A_Const *n = makeNode(A_Const);
|
||||
A_Const *n = makeNode(A_Const);
|
||||
|
||||
n->val.ival.type = T_Integer;
|
||||
n->val.ival.ival = val;
|
||||
n->location = location;
|
||||
|
||||
return (Node *) n;
|
||||
return (Node *) n;
|
||||
}
|
||||
|
||||
static Node *
|
||||
makeFloatConst(char *str, int location)
|
||||
{
|
||||
A_Const *n = makeNode(A_Const);
|
||||
A_Const *n = makeNode(A_Const);
|
||||
|
||||
n->val.fval.type = T_Float;
|
||||
n->val.fval.fval = str;
|
||||
n->location = location;
|
||||
|
||||
return (Node *) n;
|
||||
return (Node *) n;
|
||||
}
|
||||
|
||||
static Node *
|
||||
makeBoolAConst(bool state, int location)
|
||||
{
|
||||
A_Const *n = makeNode(A_Const);
|
||||
A_Const *n = makeNode(A_Const);
|
||||
|
||||
n->val.boolval.type = T_Boolean;
|
||||
n->val.boolval.boolval = state;
|
||||
n->location = location;
|
||||
|
||||
return (Node *) n;
|
||||
return (Node *) n;
|
||||
}
|
||||
|
||||
static Node *
|
||||
makeBitStringConst(char *str, int location)
|
||||
{
|
||||
A_Const *n = makeNode(A_Const);
|
||||
A_Const *n = makeNode(A_Const);
|
||||
|
||||
n->val.bsval.type = T_BitString;
|
||||
n->val.bsval.bsval = str;
|
||||
n->location = location;
|
||||
|
||||
return (Node *) n;
|
||||
return (Node *) n;
|
||||
}
|
||||
|
||||
static Node *
|
||||
makeNullAConst(int location)
|
||||
{
|
||||
A_Const *n = makeNode(A_Const);
|
||||
A_Const *n = makeNode(A_Const);
|
||||
|
||||
n->isnull = true;
|
||||
n->location = location;
|
||||
@ -18889,7 +18889,7 @@ check_func_name(List *names, core_yyscan_t yyscanner)
|
||||
static List *
|
||||
check_indirection(List *indirection, core_yyscan_t yyscanner)
|
||||
{
|
||||
ListCell *l;
|
||||
ListCell *l;
|
||||
|
||||
foreach(l, indirection)
|
||||
{
|
||||
@ -18944,7 +18944,7 @@ makeOrderedSetArgs(List *directargs, List *orderedargs,
|
||||
core_yyscan_t yyscanner)
|
||||
{
|
||||
FunctionParameter *lastd = (FunctionParameter *) llast(directargs);
|
||||
Integer *ndirectargs;
|
||||
Integer *ndirectargs;
|
||||
|
||||
/* No restriction unless last direct arg is VARIADIC */
|
||||
if (lastd->mode == FUNC_PARAM_VARIADIC)
|
||||
@ -18952,8 +18952,8 @@ makeOrderedSetArgs(List *directargs, List *orderedargs,
|
||||
FunctionParameter *firsto = (FunctionParameter *) linitial(orderedargs);
|
||||
|
||||
/*
|
||||
* We ignore the names, though the aggr_arg production allows them;
|
||||
* it doesn't allow default values, so those need not be checked.
|
||||
* We ignore the names, though the aggr_arg production allows them; it
|
||||
* doesn't allow default values, so those need not be checked.
|
||||
*/
|
||||
if (list_length(orderedargs) != 1 ||
|
||||
firsto->mode != FUNC_PARAM_VARIADIC ||
|
||||
@ -19115,7 +19115,7 @@ doNegate(Node *n, int location)
|
||||
{
|
||||
if (IsA(n, A_Const))
|
||||
{
|
||||
A_Const *con = (A_Const *) n;
|
||||
A_Const *con = (A_Const *) n;
|
||||
|
||||
/* report the constant's location as that of the '-' sign */
|
||||
con->location = location;
|
||||
@ -19143,7 +19143,7 @@ doNegateFloat(Float *v)
|
||||
if (*oldval == '+')
|
||||
oldval++;
|
||||
if (*oldval == '-')
|
||||
v->fval = oldval+1; /* just strip the '-' */
|
||||
v->fval = oldval + 1; /* just strip the '-' */
|
||||
else
|
||||
v->fval = psprintf("-%s", oldval);
|
||||
}
|
||||
@ -19214,10 +19214,11 @@ static Node *
|
||||
makeXmlExpr(XmlExprOp op, char *name, List *named_args, List *args,
|
||||
int location)
|
||||
{
|
||||
XmlExpr *x = makeNode(XmlExpr);
|
||||
XmlExpr *x = makeNode(XmlExpr);
|
||||
|
||||
x->op = op;
|
||||
x->name = name;
|
||||
|
||||
/*
|
||||
* named_args is a list of ResTarget; it'll be split apart into separate
|
||||
* expression and name lists in transformXmlExpr().
|
||||
@ -19227,7 +19228,7 @@ makeXmlExpr(XmlExprOp op, char *name, List *named_args, List *args,
|
||||
x->args = args;
|
||||
/* xmloption, if relevant, must be filled in by caller */
|
||||
/* type and typmod will be filled in during parse analysis */
|
||||
x->type = InvalidOid; /* marks the node as not analyzed */
|
||||
x->type = InvalidOid; /* marks the node as not analyzed */
|
||||
x->location = location;
|
||||
return (Node *) x;
|
||||
}
|
||||
@ -19352,7 +19353,7 @@ makeRangeVarFromQualifiedName(char *name, List *namelist, int location,
|
||||
errcode(ERRCODE_SYNTAX_ERROR),
|
||||
errmsg("improper qualified name (too many dotted names): %s",
|
||||
NameListToString(lcons(makeString(name), namelist))),
|
||||
parser_errposition(location));
|
||||
parser_errposition(location));
|
||||
break;
|
||||
}
|
||||
|
||||
@ -19421,7 +19422,7 @@ processCASbits(int cas_bits, int location, const char *constrType,
|
||||
else
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
||||
/* translator: %s is CHECK, UNIQUE, or similar */
|
||||
/* translator: %s is CHECK, UNIQUE, or similar */
|
||||
errmsg("%s constraints cannot be marked DEFERRABLE",
|
||||
constrType),
|
||||
parser_errposition(location)));
|
||||
@ -19434,7 +19435,7 @@ processCASbits(int cas_bits, int location, const char *constrType,
|
||||
else
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
||||
/* translator: %s is CHECK, UNIQUE, or similar */
|
||||
/* translator: %s is CHECK, UNIQUE, or similar */
|
||||
errmsg("%s constraints cannot be marked DEFERRABLE",
|
||||
constrType),
|
||||
parser_errposition(location)));
|
||||
@ -19447,7 +19448,7 @@ processCASbits(int cas_bits, int location, const char *constrType,
|
||||
else
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
||||
/* translator: %s is CHECK, UNIQUE, or similar */
|
||||
/* translator: %s is CHECK, UNIQUE, or similar */
|
||||
errmsg("%s constraints cannot be marked NOT VALID",
|
||||
constrType),
|
||||
parser_errposition(location)));
|
||||
@ -19460,7 +19461,7 @@ processCASbits(int cas_bits, int location, const char *constrType,
|
||||
else
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
|
||||
/* translator: %s is CHECK, UNIQUE, or similar */
|
||||
/* translator: %s is CHECK, UNIQUE, or similar */
|
||||
errmsg("%s constraints cannot be marked NO INHERIT",
|
||||
constrType),
|
||||
parser_errposition(location)));
|
||||
@ -19485,7 +19486,7 @@ parsePartitionStrategy(char *strategy, int location, core_yyscan_t yyscanner)
|
||||
(errcode(ERRCODE_INVALID_PARAMETER_VALUE),
|
||||
errmsg("unrecognized partitioning strategy \"%s\"", strategy),
|
||||
parser_errposition(location)));
|
||||
return PARTITION_STRATEGY_LIST; /* keep compiler quiet */
|
||||
return PARTITION_STRATEGY_LIST; /* keep compiler quiet */
|
||||
|
||||
}
|
||||
|
||||
@ -19556,8 +19557,8 @@ preprocess_pubobj_list(List *pubobjspec_list, core_yyscan_t yyscanner)
|
||||
parser_errposition(pubobj->location));
|
||||
|
||||
/*
|
||||
* We can distinguish between the different type of schema
|
||||
* objects based on whether name and pubtable is set.
|
||||
* We can distinguish between the different type of schema objects
|
||||
* based on whether name and pubtable is set.
|
||||
*/
|
||||
if (pubobj->name)
|
||||
pubobj->pubobjtype = PUBLICATIONOBJ_TABLES_IN_SCHEMA;
|
||||
@ -19612,11 +19613,13 @@ makeRecursiveViewSelect(char *relname, List *aliases, Node *query)
|
||||
w->ctes = list_make1(cte);
|
||||
w->location = -1;
|
||||
|
||||
/* create target list for the new SELECT from the alias list of the
|
||||
* recursive view specification */
|
||||
foreach (lc, aliases)
|
||||
/*
|
||||
* create target list for the new SELECT from the alias list of the
|
||||
* recursive view specification
|
||||
*/
|
||||
foreach(lc, aliases)
|
||||
{
|
||||
ResTarget *rt = makeNode(ResTarget);
|
||||
ResTarget *rt = makeNode(ResTarget);
|
||||
|
||||
rt->name = NULL;
|
||||
rt->indirection = NIL;
|
||||
@ -19626,8 +19629,10 @@ makeRecursiveViewSelect(char *relname, List *aliases, Node *query)
|
||||
tl = lappend(tl, rt);
|
||||
}
|
||||
|
||||
/* create new SELECT combining WITH clause, target list, and fake FROM
|
||||
* clause */
|
||||
/*
|
||||
* create new SELECT combining WITH clause, target list, and fake FROM
|
||||
* clause
|
||||
*/
|
||||
s->withClause = w;
|
||||
s->targetList = tl;
|
||||
s->fromClause = list_make1(makeRangeVar(NULL, relname, -1));
|
||||
|
||||
@ -1468,9 +1468,9 @@ check_escape_warning(core_yyscan_t yyscanner)
|
||||
ereport(WARNING,
|
||||
(errcode(ERRCODE_NONSTANDARD_USE_OF_ESCAPE_CHARACTER),
|
||||
errmsg("nonstandard use of escape in a string literal"),
|
||||
errhint("Use the escape string syntax for escapes, e.g., E'\\r\\n'."),
|
||||
errhint("Use the escape string syntax for escapes, e.g., E'\\r\\n'."),
|
||||
lexer_errposition()));
|
||||
yyextra->warn_on_first_escape = false; /* warn only once per string */
|
||||
yyextra->warn_on_first_escape = false; /* warn only once per string */
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -341,6 +341,6 @@ yyrealloc(void *ptr, yy_size_t size, yyscan_t yyscanner)
|
||||
void
|
||||
yyfree(void *ptr, yyscan_t yyscanner)
|
||||
{
|
||||
if (ptr)
|
||||
pfree(ptr);
|
||||
if (ptr)
|
||||
pfree(ptr);
|
||||
}
|
||||
|
||||
@ -140,7 +140,8 @@ xdinside [^"]+
|
||||
void
|
||||
syncrep_yyerror(yyscan_t yyscanner, const char *message)
|
||||
{
|
||||
struct yyguts_t * yyg = (struct yyguts_t *) yyscanner; /* needed for yytext macro */
|
||||
struct yyguts_t *yyg = (struct yyguts_t *) yyscanner; /* needed for yytext
|
||||
* macro */
|
||||
|
||||
/* report only the first error in a parse operation */
|
||||
if (syncrep_parse_error_msg)
|
||||
|
||||
@ -562,7 +562,7 @@ makeAny(int first, int last)
|
||||
|
||||
static bool
|
||||
makeItemLikeRegex(JsonPathParseItem *expr, JsonPathString *pattern,
|
||||
JsonPathString *flags, JsonPathParseItem ** result,
|
||||
JsonPathString *flags, JsonPathParseItem **result,
|
||||
struct Node *escontext)
|
||||
{
|
||||
JsonPathParseItem *v = makeItemType(jpiLikeRegex);
|
||||
@ -605,15 +605,15 @@ makeItemLikeRegex(JsonPathParseItem *expr, JsonPathString *pattern,
|
||||
}
|
||||
|
||||
/* Convert flags to what pg_regcomp needs */
|
||||
if ( !jspConvertRegexFlags(v->value.like_regex.flags, &cflags, escontext))
|
||||
return false;
|
||||
if (!jspConvertRegexFlags(v->value.like_regex.flags, &cflags, escontext))
|
||||
return false;
|
||||
|
||||
/* check regex validity */
|
||||
{
|
||||
regex_t re_tmp;
|
||||
regex_t re_tmp;
|
||||
pg_wchar *wpattern;
|
||||
int wpattern_len;
|
||||
int re_result;
|
||||
int wpattern_len;
|
||||
int re_result;
|
||||
|
||||
wpattern = (pg_wchar *) palloc((pattern->len + 1) * sizeof(pg_wchar));
|
||||
wpattern_len = pg_mb2wchar_with_len(pattern->val,
|
||||
@ -623,7 +623,7 @@ makeItemLikeRegex(JsonPathParseItem *expr, JsonPathString *pattern,
|
||||
if ((re_result = pg_regcomp(&re_tmp, wpattern, wpattern_len, cflags,
|
||||
DEFAULT_COLLATION_OID)) != REG_OKAY)
|
||||
{
|
||||
char errMsg[100];
|
||||
char errMsg[100];
|
||||
|
||||
pg_regerror(re_result, &re_tmp, errMsg, sizeof(errMsg));
|
||||
ereturn(escontext, false,
|
||||
|
||||
@ -363,7 +363,8 @@ jsonpath_yyerror(JsonPathParseResult **result, struct Node *escontext,
|
||||
yyscan_t yyscanner,
|
||||
const char *message)
|
||||
{
|
||||
struct yyguts_t * yyg = (struct yyguts_t *) yyscanner; /* needed for yytext macro */
|
||||
struct yyguts_t *yyg = (struct yyguts_t *) yyscanner; /* needed for yytext
|
||||
* macro */
|
||||
|
||||
/* don't overwrite escontext if it's already been set */
|
||||
if (SOFT_ERROR_OCCURRED(escontext))
|
||||
@ -373,14 +374,14 @@ jsonpath_yyerror(JsonPathParseResult **result, struct Node *escontext,
|
||||
{
|
||||
errsave(escontext,
|
||||
(errcode(ERRCODE_SYNTAX_ERROR),
|
||||
/* translator: %s is typically "syntax error" */
|
||||
/* translator: %s is typically "syntax error" */
|
||||
errmsg("%s at end of jsonpath input", _(message))));
|
||||
}
|
||||
else
|
||||
{
|
||||
errsave(escontext,
|
||||
(errcode(ERRCODE_SYNTAX_ERROR),
|
||||
/* translator: first %s is typically "syntax error" */
|
||||
/* translator: first %s is typically "syntax error" */
|
||||
errmsg("%s at or near \"%s\" of jsonpath input",
|
||||
_(message), yytext)));
|
||||
}
|
||||
@ -399,39 +400,39 @@ typedef struct JsonPathKeyword
|
||||
* alphabetical order
|
||||
*/
|
||||
static const JsonPathKeyword keywords[] = {
|
||||
{ 2, false, IS_P, "is"},
|
||||
{ 2, false, TO_P, "to"},
|
||||
{ 3, false, ABS_P, "abs"},
|
||||
{ 3, false, LAX_P, "lax"},
|
||||
{ 4, false, DATE_P, "date"},
|
||||
{ 4, false, FLAG_P, "flag"},
|
||||
{ 4, false, LAST_P, "last"},
|
||||
{ 4, true, NULL_P, "null"},
|
||||
{ 4, false, SIZE_P, "size"},
|
||||
{ 4, false, TIME_P, "time"},
|
||||
{ 4, true, TRUE_P, "true"},
|
||||
{ 4, false, TYPE_P, "type"},
|
||||
{ 4, false, WITH_P, "with"},
|
||||
{ 5, true, FALSE_P, "false"},
|
||||
{ 5, false, FLOOR_P, "floor"},
|
||||
{ 6, false, BIGINT_P, "bigint"},
|
||||
{ 6, false, DOUBLE_P, "double"},
|
||||
{ 6, false, EXISTS_P, "exists"},
|
||||
{ 6, false, NUMBER_P, "number"},
|
||||
{ 6, false, STARTS_P, "starts"},
|
||||
{ 6, false, STRICT_P, "strict"},
|
||||
{ 6, false, STRINGFUNC_P, "string"},
|
||||
{ 7, false, BOOLEAN_P, "boolean"},
|
||||
{ 7, false, CEILING_P, "ceiling"},
|
||||
{ 7, false, DECIMAL_P, "decimal"},
|
||||
{ 7, false, INTEGER_P, "integer"},
|
||||
{ 7, false, TIME_TZ_P, "time_tz"},
|
||||
{ 7, false, UNKNOWN_P, "unknown"},
|
||||
{ 8, false, DATETIME_P, "datetime"},
|
||||
{ 8, false, KEYVALUE_P, "keyvalue"},
|
||||
{ 9, false, TIMESTAMP_P, "timestamp"},
|
||||
{ 10,false, LIKE_REGEX_P, "like_regex"},
|
||||
{ 12,false, TIMESTAMP_TZ_P, "timestamp_tz"},
|
||||
{2, false, IS_P, "is"},
|
||||
{2, false, TO_P, "to"},
|
||||
{3, false, ABS_P, "abs"},
|
||||
{3, false, LAX_P, "lax"},
|
||||
{4, false, DATE_P, "date"},
|
||||
{4, false, FLAG_P, "flag"},
|
||||
{4, false, LAST_P, "last"},
|
||||
{4, true, NULL_P, "null"},
|
||||
{4, false, SIZE_P, "size"},
|
||||
{4, false, TIME_P, "time"},
|
||||
{4, true, TRUE_P, "true"},
|
||||
{4, false, TYPE_P, "type"},
|
||||
{4, false, WITH_P, "with"},
|
||||
{5, true, FALSE_P, "false"},
|
||||
{5, false, FLOOR_P, "floor"},
|
||||
{6, false, BIGINT_P, "bigint"},
|
||||
{6, false, DOUBLE_P, "double"},
|
||||
{6, false, EXISTS_P, "exists"},
|
||||
{6, false, NUMBER_P, "number"},
|
||||
{6, false, STARTS_P, "starts"},
|
||||
{6, false, STRICT_P, "strict"},
|
||||
{6, false, STRINGFUNC_P, "string"},
|
||||
{7, false, BOOLEAN_P, "boolean"},
|
||||
{7, false, CEILING_P, "ceiling"},
|
||||
{7, false, DECIMAL_P, "decimal"},
|
||||
{7, false, INTEGER_P, "integer"},
|
||||
{7, false, TIME_TZ_P, "time_tz"},
|
||||
{7, false, UNKNOWN_P, "unknown"},
|
||||
{8, false, DATETIME_P, "datetime"},
|
||||
{8, false, KEYVALUE_P, "keyvalue"},
|
||||
{9, false, TIMESTAMP_P, "timestamp"},
|
||||
{10, false, LIKE_REGEX_P, "like_regex"},
|
||||
{12, false, TIMESTAMP_TZ_P, "timestamp_tz"},
|
||||
};
|
||||
|
||||
/*
|
||||
@ -442,9 +443,9 @@ checkKeyword(yyscan_t yyscanner)
|
||||
{
|
||||
int res = IDENT_P;
|
||||
int diff;
|
||||
const JsonPathKeyword *StopLow = keywords,
|
||||
*StopHigh = keywords + lengthof(keywords),
|
||||
*StopMiddle;
|
||||
const JsonPathKeyword *StopLow = keywords,
|
||||
*StopHigh = keywords + lengthof(keywords),
|
||||
*StopMiddle;
|
||||
|
||||
if (yyextra->scanstring.len > keywords[lengthof(keywords) - 1].len)
|
||||
return res;
|
||||
@ -526,7 +527,7 @@ addchar(bool init, char c, yyscan_t yyscanner)
|
||||
JsonPathParseResult *
|
||||
parsejsonpath(const char *str, int len, struct Node *escontext)
|
||||
{
|
||||
JsonPathParseResult *parseresult;
|
||||
JsonPathParseResult *parseresult;
|
||||
yyscan_t scanner;
|
||||
struct jsonpath_yy_extra_type yyext;
|
||||
|
||||
@ -541,7 +542,7 @@ parsejsonpath(const char *str, int len, struct Node *escontext)
|
||||
jsonpath_yy_scan_bytes(str, len, scanner);
|
||||
|
||||
if (jsonpath_yyparse(&parseresult, escontext, scanner) != 0)
|
||||
jsonpath_yyerror(NULL, escontext, scanner, "invalid input"); /* shouldn't happen */
|
||||
jsonpath_yyerror(NULL, escontext, scanner, "invalid input"); /* shouldn't happen */
|
||||
|
||||
jsonpath_yylex_destroy(scanner);
|
||||
|
||||
@ -581,7 +582,7 @@ addUnicodeChar(int ch, struct Node *escontext, yyscan_t yyscanner)
|
||||
ereturn(escontext, false,
|
||||
(errcode(ERRCODE_UNTRANSLATABLE_CHARACTER),
|
||||
errmsg("unsupported Unicode escape sequence"),
|
||||
errdetail("\\u0000 cannot be converted to text.")));
|
||||
errdetail("\\u0000 cannot be converted to text.")));
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -593,7 +594,7 @@ addUnicodeChar(int ch, struct Node *escontext, yyscan_t yyscanner)
|
||||
* more detailed errors.
|
||||
*/
|
||||
|
||||
if (! escontext || ! IsA(escontext, ErrorSaveContext))
|
||||
if (!escontext || !IsA(escontext, ErrorSaveContext))
|
||||
pg_unicode_to_server(ch, (unsigned char *) cbuf);
|
||||
else if (!pg_unicode_to_server_noerror(ch, (unsigned char *) cbuf))
|
||||
ereturn(escontext, false,
|
||||
@ -655,9 +656,10 @@ parseUnicode(char *s, int l, struct Node *escontext, yyscan_t yyscanner)
|
||||
for (i = 2; i < l; i += 2) /* skip '\u' */
|
||||
{
|
||||
int ch = 0;
|
||||
int j, si;
|
||||
int j,
|
||||
si;
|
||||
|
||||
if (s[i] == '{') /* parse '\u{XX...}' */
|
||||
if (s[i] == '{') /* parse '\u{XX...}' */
|
||||
{
|
||||
while (s[++i] != '}' && i < l)
|
||||
{
|
||||
@ -665,9 +667,9 @@ parseUnicode(char *s, int l, struct Node *escontext, yyscan_t yyscanner)
|
||||
return false;
|
||||
ch = (ch << 4) | si;
|
||||
}
|
||||
i++; /* skip '}' */
|
||||
i++; /* skip '}' */
|
||||
}
|
||||
else /* parse '\uXXXX' */
|
||||
else /* parse '\uXXXX' */
|
||||
{
|
||||
for (j = 0; j < 4 && i < l; j++)
|
||||
{
|
||||
@ -677,7 +679,7 @@ parseUnicode(char *s, int l, struct Node *escontext, yyscan_t yyscanner)
|
||||
}
|
||||
}
|
||||
|
||||
if (! addUnicode(ch, &hi_surrogate, escontext, yyscanner))
|
||||
if (!addUnicode(ch, &hi_surrogate, escontext, yyscanner))
|
||||
return false;
|
||||
}
|
||||
|
||||
@ -697,7 +699,10 @@ parseUnicode(char *s, int l, struct Node *escontext, yyscan_t yyscanner)
|
||||
static bool
|
||||
parseHexChar(char *s, struct Node *escontext, yyscan_t yyscanner)
|
||||
{
|
||||
int s2, s3, ch;
|
||||
int s2,
|
||||
s3,
|
||||
ch;
|
||||
|
||||
if (!hexval(s[2], &s2, escontext, yyscanner))
|
||||
return false;
|
||||
if (!hexval(s[3], &s3, escontext, yyscanner))
|
||||
|
||||
@ -515,8 +515,8 @@ parse_error:
|
||||
{
|
||||
ereport(elevel,
|
||||
(errcode(ERRCODE_SYNTAX_ERROR),
|
||||
errmsg("syntax error in file \"%s\" line %u, near end of line",
|
||||
config_file, ConfigFileLineno - 1)));
|
||||
errmsg("syntax error in file \"%s\" line %u, near end of line",
|
||||
config_file, ConfigFileLineno - 1)));
|
||||
record_config_file_error("syntax error",
|
||||
config_file, ConfigFileLineno - 1,
|
||||
head_p, tail_p);
|
||||
@ -525,8 +525,8 @@ parse_error:
|
||||
{
|
||||
ereport(elevel,
|
||||
(errcode(ERRCODE_SYNTAX_ERROR),
|
||||
errmsg("syntax error in file \"%s\" line %u, near token \"%s\"",
|
||||
config_file, ConfigFileLineno, yytext)));
|
||||
errmsg("syntax error in file \"%s\" line %u, near token \"%s\"",
|
||||
config_file, ConfigFileLineno, yytext)));
|
||||
record_config_file_error("syntax error",
|
||||
config_file, ConfigFileLineno,
|
||||
head_p, tail_p);
|
||||
@ -545,8 +545,8 @@ parse_error:
|
||||
{
|
||||
ereport(elevel,
|
||||
(errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED),
|
||||
errmsg("too many syntax errors found, abandoning file \"%s\"",
|
||||
config_file)));
|
||||
errmsg("too many syntax errors found, abandoning file \"%s\"",
|
||||
config_file)));
|
||||
break;
|
||||
}
|
||||
|
||||
@ -589,7 +589,7 @@ ParseConfigDirectory(const char *includedir,
|
||||
int num_filenames;
|
||||
|
||||
filenames = GetConfFilesInDir(includedir, calling_file, elevel,
|
||||
&num_filenames, &err_msg);
|
||||
&num_filenames, &err_msg);
|
||||
|
||||
if (!filenames)
|
||||
{
|
||||
|
||||
@ -252,7 +252,8 @@ static const struct
|
||||
const char *fname;
|
||||
int nargs;
|
||||
PgBenchFunction tag;
|
||||
} PGBENCH_FUNCTIONS[] =
|
||||
} PGBENCH_FUNCTIONS[] =
|
||||
|
||||
{
|
||||
/* parsed as operators, executed as functions */
|
||||
{
|
||||
@ -451,7 +452,7 @@ elist_length(PgBenchExprList *list)
|
||||
static PgBenchExpr *
|
||||
make_func(yyscan_t yyscanner, int fnumber, PgBenchExprList *args)
|
||||
{
|
||||
int len = elist_length(args);
|
||||
int len = elist_length(args);
|
||||
|
||||
PgBenchExpr *expr = pg_malloc(sizeof(PgBenchExpr));
|
||||
|
||||
@ -460,14 +461,14 @@ make_func(yyscan_t yyscanner, int fnumber, PgBenchExprList *args)
|
||||
/* validate arguments number including few special cases */
|
||||
switch (PGBENCH_FUNCTIONS[fnumber].nargs)
|
||||
{
|
||||
/* check at least one arg for least & greatest */
|
||||
/* check at least one arg for least & greatest */
|
||||
case PGBENCH_NARGS_VARIABLE:
|
||||
if (len == 0)
|
||||
expr_yyerror_more(yyscanner, "at least one argument expected",
|
||||
PGBENCH_FUNCTIONS[fnumber].fname);
|
||||
break;
|
||||
|
||||
/* case (when ... then ...)+ (else ...)? end */
|
||||
/* case (when ... then ...)+ (else ...)? end */
|
||||
case PGBENCH_NARGS_CASE:
|
||||
/* 'else' branch is always present, but could be a NULL-constant */
|
||||
if (len < 3 || len % 2 != 1)
|
||||
@ -476,7 +477,7 @@ make_func(yyscan_t yyscanner, int fnumber, PgBenchExprList *args)
|
||||
"case control structure");
|
||||
break;
|
||||
|
||||
/* hash functions with optional seed argument */
|
||||
/* hash functions with optional seed argument */
|
||||
case PGBENCH_NARGS_HASH:
|
||||
if (len < 1 || len > 2)
|
||||
expr_yyerror_more(yyscanner, "unexpected number of arguments",
|
||||
@ -485,11 +486,12 @@ make_func(yyscan_t yyscanner, int fnumber, PgBenchExprList *args)
|
||||
if (len == 1)
|
||||
{
|
||||
PgBenchExpr *var = make_variable("default_seed");
|
||||
|
||||
args = make_elist(var, args);
|
||||
}
|
||||
break;
|
||||
|
||||
/* pseudorandom permutation function with optional seed argument */
|
||||
/* pseudorandom permutation function with optional seed argument */
|
||||
case PGBENCH_NARGS_PERMUTE:
|
||||
if (len < 2 || len > 3)
|
||||
expr_yyerror_more(yyscanner, "unexpected number of arguments",
|
||||
@ -498,11 +500,12 @@ make_func(yyscan_t yyscanner, int fnumber, PgBenchExprList *args)
|
||||
if (len == 2)
|
||||
{
|
||||
PgBenchExpr *var = make_variable("default_seed");
|
||||
|
||||
args = make_elist(var, args);
|
||||
}
|
||||
break;
|
||||
|
||||
/* common case: positive arguments number */
|
||||
/* common case: positive arguments number */
|
||||
default:
|
||||
Assert(PGBENCH_FUNCTIONS[fnumber].nargs >= 0);
|
||||
|
||||
|
||||
@ -598,9 +598,9 @@ psql_scan_slash_option(PsqlScanState state,
|
||||
psql_scan_reselect_sql_lexer(state);
|
||||
|
||||
/*
|
||||
* Check the lex result: we should have gotten back either LEXRES_OK
|
||||
* or LEXRES_EOL (the latter indicating end of string). If we were inside
|
||||
* a quoted string, as indicated by final_state, EOL is an error.
|
||||
* Check the lex result: we should have gotten back either LEXRES_OK or
|
||||
* LEXRES_EOL (the latter indicating end of string). If we were inside a
|
||||
* quoted string, as indicated by final_state, EOL is an error.
|
||||
*/
|
||||
Assert(lexresult == LEXRES_EOL || lexresult == LEXRES_OK);
|
||||
|
||||
@ -642,6 +642,7 @@ psql_scan_slash_option(PsqlScanState state,
|
||||
termPQExpBuffer(&mybuf);
|
||||
return NULL;
|
||||
case xslashwholeline:
|
||||
|
||||
/*
|
||||
* In whole-line mode, we interpret semicolon = true as stripping
|
||||
* trailing whitespace as well as semicolons; this gives the
|
||||
|
||||
@ -1317,7 +1317,7 @@ bool
|
||||
psql_scan_in_quote(PsqlScanState state)
|
||||
{
|
||||
return state->start_state != INITIAL &&
|
||||
state->start_state != xqs;
|
||||
state->start_state != xqs;
|
||||
}
|
||||
|
||||
/*
|
||||
@ -1568,8 +1568,8 @@ psqlscan_escape_variable(PsqlScanState state, const char *txt, int len,
|
||||
void
|
||||
psqlscan_test_variable(PsqlScanState state, const char *txt, int len)
|
||||
{
|
||||
char *varname;
|
||||
char *value;
|
||||
char *varname;
|
||||
char *value;
|
||||
|
||||
varname = psqlscan_extract_substring(state, txt + 3, len - 4);
|
||||
if (state->callbacks->get_variable)
|
||||
|
||||
@ -1847,9 +1847,9 @@ isdefine(void)
|
||||
ptr->used = yb;
|
||||
|
||||
/*
|
||||
* We use yy_scan_string which will copy the value, so there's
|
||||
* no need to worry about a possible undef happening while we
|
||||
* are still scanning it.
|
||||
* We use yy_scan_string which will copy the value, so there's no
|
||||
* need to worry about a possible undef happening while we are
|
||||
* still scanning it.
|
||||
*/
|
||||
yy_scan_string(ptr->value);
|
||||
return true;
|
||||
|
||||
@ -2707,7 +2707,7 @@ read_sql_construct(int until,
|
||||
for (;;)
|
||||
{
|
||||
tok = yylex();
|
||||
if (startlocation < 0) /* remember loc of first token */
|
||||
if (startlocation < 0) /* remember loc of first token */
|
||||
startlocation = yylloc;
|
||||
if (tok == until && parenlevel == 0)
|
||||
break;
|
||||
@ -2723,10 +2723,11 @@ read_sql_construct(int until,
|
||||
if (parenlevel < 0)
|
||||
yyerror("mismatched parentheses");
|
||||
}
|
||||
|
||||
/*
|
||||
* End of function definition is an error, and we don't expect to
|
||||
* hit a semicolon either (unless it's the until symbol, in which
|
||||
* case we should have fallen out above).
|
||||
* End of function definition is an error, and we don't expect to hit
|
||||
* a semicolon either (unless it's the until symbol, in which case we
|
||||
* should have fallen out above).
|
||||
*/
|
||||
if (tok == 0 || tok == ';')
|
||||
{
|
||||
@ -2983,8 +2984,8 @@ make_execsql_stmt(int firsttoken, int location, PLword *word)
|
||||
plpgsql_IdentifierLookup = IDENTIFIER_LOOKUP_EXPR;
|
||||
|
||||
/*
|
||||
* Scan to the end of the SQL command. Identify any INTO-variables
|
||||
* clause lurking within it, and parse that via read_into_target().
|
||||
* Scan to the end of the SQL command. Identify any INTO-variables clause
|
||||
* lurking within it, and parse that via read_into_target().
|
||||
*
|
||||
* The end of the statement is defined by a semicolon ... except that
|
||||
* semicolons within parentheses or BEGIN/END blocks don't terminate a
|
||||
@ -3006,12 +3007,12 @@ make_execsql_stmt(int firsttoken, int location, PLword *word)
|
||||
* but it's not very likely.
|
||||
*
|
||||
* 3. IMPORT FOREIGN SCHEMA ... INTO. This is not allowed in CREATE RULE
|
||||
* or WITH, so we just check for IMPORT as the command's first token.
|
||||
* (If IMPORT FOREIGN SCHEMA returned data someone might wish to capture
|
||||
* with an INTO-variables clause, we'd have to work much harder here.)
|
||||
* or WITH, so we just check for IMPORT as the command's first token. (If
|
||||
* IMPORT FOREIGN SCHEMA returned data someone might wish to capture with
|
||||
* an INTO-variables clause, we'd have to work much harder here.)
|
||||
*
|
||||
* Fortunately, INTO is a fully reserved word in the main grammar, so
|
||||
* at least we need not worry about it appearing as an identifier.
|
||||
* Fortunately, INTO is a fully reserved word in the main grammar, so at
|
||||
* least we need not worry about it appearing as an identifier.
|
||||
*
|
||||
* Any future additional uses of INTO in the main grammar will doubtless
|
||||
* break this logic again ... beware!
|
||||
@ -3026,7 +3027,7 @@ make_execsql_stmt(int firsttoken, int location, PLword *word)
|
||||
prev_tok = tok;
|
||||
tok = yylex();
|
||||
if (have_into && into_end_loc < 0)
|
||||
into_end_loc = yylloc; /* token after the INTO part */
|
||||
into_end_loc = yylloc; /* token after the INTO part */
|
||||
/* Detect CREATE [OR REPLACE] {FUNCTION|PROCEDURE} */
|
||||
if (tokens[0] == 'c' && token_count < sizeof(tokens))
|
||||
{
|
||||
@ -3087,9 +3088,9 @@ make_execsql_stmt(int firsttoken, int location, PLword *word)
|
||||
if (have_into)
|
||||
{
|
||||
/*
|
||||
* Insert an appropriate number of spaces corresponding to the
|
||||
* INTO text, so that locations within the redacted SQL statement
|
||||
* still line up with those in the original source text.
|
||||
* Insert an appropriate number of spaces corresponding to the INTO
|
||||
* text, so that locations within the redacted SQL statement still
|
||||
* line up with those in the original source text.
|
||||
*/
|
||||
plpgsql_append_source_text(&ds, location, into_start_loc);
|
||||
appendStringInfoSpaces(&ds, into_end_loc - into_start_loc);
|
||||
@ -3137,8 +3138,8 @@ read_fetch_direction(void)
|
||||
bool check_FROM = true;
|
||||
|
||||
/*
|
||||
* We create the PLpgSQL_stmt_fetch struct here, but only fill in
|
||||
* the fields arising from the optional direction clause
|
||||
* We create the PLpgSQL_stmt_fetch struct here, but only fill in the
|
||||
* fields arising from the optional direction clause
|
||||
*/
|
||||
fetch = (PLpgSQL_stmt_fetch *) palloc0(sizeof(PLpgSQL_stmt_fetch));
|
||||
fetch->cmd_type = PLPGSQL_STMT_FETCH;
|
||||
@ -3172,7 +3173,7 @@ read_fetch_direction(void)
|
||||
K_LAST, "last"))
|
||||
{
|
||||
fetch->direction = FETCH_ABSOLUTE;
|
||||
fetch->how_many = -1;
|
||||
fetch->how_many = -1;
|
||||
}
|
||||
else if (tok_is_keyword(tok, &yylval,
|
||||
K_ABSOLUTE, "absolute"))
|
||||
@ -3223,12 +3224,12 @@ read_fetch_direction(void)
|
||||
else
|
||||
{
|
||||
/*
|
||||
* Assume it's a count expression with no preceding keyword.
|
||||
* Note: we allow this syntax because core SQL does, but it's
|
||||
* ambiguous with the case of an omitted direction clause; for
|
||||
* instance, "MOVE n IN c" will fail if n is a variable, because the
|
||||
* preceding else-arm will trigger. Perhaps this can be improved
|
||||
* someday, but it hardly seems worth a lot of work.
|
||||
* Assume it's a count expression with no preceding keyword. Note: we
|
||||
* allow this syntax because core SQL does, but it's ambiguous with
|
||||
* the case of an omitted direction clause; for instance, "MOVE n IN
|
||||
* c" will fail if n is a variable, because the preceding else-arm
|
||||
* will trigger. Perhaps this can be improved someday, but it hardly
|
||||
* seems worth a lot of work.
|
||||
*/
|
||||
plpgsql_push_back_token(tok);
|
||||
fetch->expr = read_sql_expression2(K_FROM, K_IN,
|
||||
@ -3256,7 +3257,7 @@ read_fetch_direction(void)
|
||||
* BACKWARD expr, BACKWARD ALL, BACKWARD
|
||||
*/
|
||||
static void
|
||||
complete_direction(PLpgSQL_stmt_fetch *fetch, bool *check_FROM)
|
||||
complete_direction(PLpgSQL_stmt_fetch *fetch, bool *check_FROM)
|
||||
{
|
||||
int tok;
|
||||
|
||||
@ -3295,7 +3296,7 @@ make_return_stmt(int location)
|
||||
new = palloc0(sizeof(PLpgSQL_stmt_return));
|
||||
new->cmd_type = PLPGSQL_STMT_RETURN;
|
||||
new->lineno = plpgsql_location_to_lineno(location);
|
||||
new->stmtid = ++plpgsql_curr_compile->nstatements;
|
||||
new->stmtid = ++plpgsql_curr_compile->nstatements;
|
||||
new->expr = NULL;
|
||||
new->retvarno = -1;
|
||||
|
||||
@ -3357,8 +3358,8 @@ make_return_stmt(int location)
|
||||
/*
|
||||
* Not (just) a variable name, so treat as expression.
|
||||
*
|
||||
* Note that a well-formed expression is _required_ here;
|
||||
* anything else is a compile-time error.
|
||||
* Note that a well-formed expression is _required_ here; anything
|
||||
* else is a compile-time error.
|
||||
*/
|
||||
plpgsql_push_back_token(tok);
|
||||
new->expr = read_sql_expression(';', ";");
|
||||
@ -3420,8 +3421,8 @@ make_return_next_stmt(int location)
|
||||
/*
|
||||
* Not (just) a variable name, so treat as expression.
|
||||
*
|
||||
* Note that a well-formed expression is _required_ here;
|
||||
* anything else is a compile-time error.
|
||||
* Note that a well-formed expression is _required_ here; anything
|
||||
* else is a compile-time error.
|
||||
*/
|
||||
plpgsql_push_back_token(tok);
|
||||
new->expr = read_sql_expression(';', ";");
|
||||
@ -3540,11 +3541,11 @@ read_into_target(PLpgSQL_variable **target, bool *strict)
|
||||
}
|
||||
|
||||
/*
|
||||
* Currently, a row or record variable can be the single INTO target,
|
||||
* but not a member of a multi-target list. So we throw error if there
|
||||
* is a comma after it, because that probably means the user tried to
|
||||
* write a multi-target list. If this ever gets generalized, we should
|
||||
* probably refactor read_into_scalar_list so it handles all cases.
|
||||
* Currently, a row or record variable can be the single INTO target, but
|
||||
* not a member of a multi-target list. So we throw error if there is a
|
||||
* comma after it, because that probably means the user tried to write a
|
||||
* multi-target list. If this ever gets generalized, we should probably
|
||||
* refactor read_into_scalar_list so it handles all cases.
|
||||
*/
|
||||
switch (tok)
|
||||
{
|
||||
@ -3590,7 +3591,7 @@ read_into_scalar_list(char *initial_name,
|
||||
int nfields;
|
||||
char *fieldnames[1024];
|
||||
int varnos[1024];
|
||||
PLpgSQL_row *row;
|
||||
PLpgSQL_row *row;
|
||||
int tok;
|
||||
|
||||
check_assignable(initial_datum, initial_location);
|
||||
@ -3620,7 +3621,7 @@ read_into_scalar_list(char *initial_name,
|
||||
NameOfDatum(&(yylval.wdatum))),
|
||||
parser_errposition(yylloc)));
|
||||
fieldnames[nfields] = NameOfDatum(&(yylval.wdatum));
|
||||
varnos[nfields++] = yylval.wdatum.datum->dno;
|
||||
varnos[nfields++] = yylval.wdatum.datum->dno;
|
||||
break;
|
||||
|
||||
default:
|
||||
@ -3630,8 +3631,8 @@ read_into_scalar_list(char *initial_name,
|
||||
}
|
||||
|
||||
/*
|
||||
* We read an extra, non-comma token from yylex(), so push it
|
||||
* back onto the input stream
|
||||
* We read an extra, non-comma token from yylex(), so push it back onto
|
||||
* the input stream
|
||||
*/
|
||||
plpgsql_push_back_token(tok);
|
||||
|
||||
@ -3712,7 +3713,7 @@ static void
|
||||
check_sql_expr(const char *stmt, RawParseMode parseMode, int location)
|
||||
{
|
||||
sql_error_callback_arg cbarg;
|
||||
ErrorContextCallback syntax_errcontext;
|
||||
ErrorContextCallback syntax_errcontext;
|
||||
MemoryContext oldCxt;
|
||||
|
||||
if (!plpgsql_check_syntax)
|
||||
@ -3741,14 +3742,14 @@ plpgsql_sql_error_callback(void *arg)
|
||||
|
||||
/*
|
||||
* First, set up internalerrposition to point to the start of the
|
||||
* statement text within the function text. Note this converts
|
||||
* location (a byte offset) to a character number.
|
||||
* statement text within the function text. Note this converts location
|
||||
* (a byte offset) to a character number.
|
||||
*/
|
||||
parser_errposition(cbarg->location);
|
||||
|
||||
/*
|
||||
* If the core parser provided an error position, transpose it.
|
||||
* Note we are dealing with 1-based character numbers at this point.
|
||||
* If the core parser provided an error position, transpose it. Note we
|
||||
* are dealing with 1-based character numbers at this point.
|
||||
*/
|
||||
errpos = geterrposition();
|
||||
if (errpos > 0)
|
||||
@ -3779,7 +3780,7 @@ parse_datatype(const char *string, int location)
|
||||
Oid type_id;
|
||||
int32 typmod;
|
||||
sql_error_callback_arg cbarg;
|
||||
ErrorContextCallback syntax_errcontext;
|
||||
ErrorContextCallback syntax_errcontext;
|
||||
|
||||
cbarg.location = location;
|
||||
|
||||
@ -3890,7 +3891,7 @@ read_cursor_args(PLpgSQL_var *cursor, int until)
|
||||
plpgsql_peek2(&tok1, &tok2, &arglocation, NULL);
|
||||
if (tok1 == IDENT && tok2 == COLON_EQUALS)
|
||||
{
|
||||
char *argname;
|
||||
char *argname;
|
||||
IdentifierLookup save_IdentifierLookup;
|
||||
|
||||
/* Read the argument name, ignoring any matching variable */
|
||||
@ -4088,11 +4089,11 @@ check_raise_parameters(PLpgSQL_stmt_raise *stmt)
|
||||
if (expected_nparams < list_length(stmt->params))
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_SYNTAX_ERROR),
|
||||
errmsg("too many parameters specified for RAISE")));
|
||||
errmsg("too many parameters specified for RAISE")));
|
||||
if (expected_nparams > list_length(stmt->params))
|
||||
ereport(ERROR,
|
||||
(errcode(ERRCODE_SYNTAX_ERROR),
|
||||
errmsg("too few parameters specified for RAISE")));
|
||||
errmsg("too few parameters specified for RAISE")));
|
||||
}
|
||||
|
||||
/*
|
||||
@ -4121,9 +4122,9 @@ make_case(int location, PLpgSQL_expr *t_expr,
|
||||
/*
|
||||
* When test expression is present, we create a var for it and then
|
||||
* convert all the WHEN expressions to "VAR IN (original_expression)".
|
||||
* This is a bit klugy, but okay since we haven't yet done more than
|
||||
* read the expressions as text. (Note that previous parsing won't
|
||||
* have complained if the WHEN ... THEN expression contained multiple
|
||||
* This is a bit klugy, but okay since we haven't yet done more than read
|
||||
* the expressions as text. (Note that previous parsing won't have
|
||||
* complained if the WHEN ... THEN expression contained multiple
|
||||
* comma-separated values.)
|
||||
*/
|
||||
if (t_expr)
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user