SELECT foo.*) so that it cannot be confused with a quoted identifier "*".
Instead create a separate node type A_Star to represent this notation.
Per pgsql-hackers discussion of 2007-Sep-27.
*
* This is used primarily to form error messages, and so we do not quote
* the list elements, for the sake of legibility.
+ *
+ * In most scenarios the list elements should always be Value strings,
+ * but we also allow A_Star for the convenience of ColumnRef processing.
*/
char *
NameListToString(List *names)
foreach(l, names)
{
+ Node *name = (Node *) lfirst(l);
+
if (l != list_head(names))
appendStringInfoChar(&string, '.');
- appendStringInfoString(&string, strVal(lfirst(l)));
+
+ if (IsA(name, String))
+ appendStringInfoString(&string, strVal(name));
+ else if (IsA(name, A_Star))
+ appendStringInfoString(&string, "*");
+ else
+ elog(ERROR, "unexpected node type in name list: %d",
+ (int) nodeTag(name));
}
return string.data;
void
Async_Unlisten(const char *relname)
{
- /* Handle specially the `unlisten "*"' command */
- if ((!relname) || (*relname == '\0') || (strcmp(relname, "*") == 0))
- {
- Async_UnlistenAll();
- }
- else
- {
- if (Trace_notify)
- elog(DEBUG1, "Async_Unlisten(%s,%d)", relname, MyProcPid);
+ if (Trace_notify)
+ elog(DEBUG1, "Async_Unlisten(%s,%d)", relname, MyProcPid);
- queue_listen(LISTEN_UNLISTEN, relname);
- }
+ queue_listen(LISTEN_UNLISTEN, relname);
}
/*
* Async_UnlistenAll
*
- * This is invoked by UNLISTEN "*" command, and also at backend exit.
+ * This is invoked by UNLISTEN * command, and also at backend exit.
*/
void
Async_UnlistenAll(void)
return newnode;
}
+static A_Star *
+_copyAStar(A_Star *from)
+{
+ A_Star *newnode = makeNode(A_Star);
+
+ return newnode;
+}
+
static A_Indices *
_copyAIndices(A_Indices *from)
{
case T_FuncCall:
retval = _copyFuncCall(from);
break;
+ case T_A_Star:
+ retval = _copyAStar(from);
+ break;
case T_A_Indices:
retval = _copyAIndices(from);
break;
return true;
}
+static bool
+_equalAStar(A_Star *a, A_Star *b)
+{
+ return true;
+}
+
static bool
_equalAIndices(A_Indices *a, A_Indices *b)
{
case T_FuncCall:
retval = _equalFuncCall(a, b);
break;
+ case T_A_Star:
+ retval = _equalAStar(a, b);
+ break;
case T_A_Indices:
retval = _equalAIndices(a, b);
break;
WRITE_LOCATION_FIELD(location);
}
+static void
+_outA_Star(StringInfo str, A_Star *node)
+{
+ WRITE_NODE_TYPE("A_STAR");
+}
+
static void
_outA_Indices(StringInfo str, A_Indices *node)
{
case T_A_Const:
_outAConst(str, obj);
break;
+ case T_A_Star:
+ _outA_Star(str, obj);
+ break;
case T_A_Indices:
_outA_Indices(str, obj);
break;
*/
/*#define __YYSCLASS*/
-static Node *makeColumnRef(char *relname, List *indirection, int location);
+static Node *makeColumnRef(char *colname, List *indirection, int location);
static Node *makeTypeCast(Node *arg, TypeName *typename, int location);
static Node *makeStringConst(char *str, int location);
static Node *makeStringConstCast(char *str, int location, TypeName *typename);
static FuncCall *makeOverlaps(List *largs, List *rargs, int location);
static void check_qualified_name(List *names);
static List *check_func_name(List *names);
+static List *check_indirection(List *indirection);
static List *extractArgTypes(List *parameters);
static SelectStmt *findLeftmostSelect(SelectStmt *node);
static void insertSelectOptions(SelectStmt *stmt,
| UNLISTEN '*'
{
UnlistenStmt *n = makeNode(UnlistenStmt);
- n->relation = makeNode(RangeVar);
- n->relation->relname = "*";
- n->relation->schemaname = NULL;
+ n->relation = NULL;
$$ = (Node *)n;
}
;
{
$$ = makeNode(ResTarget);
$$->name = $1;
- $$->indirection = $2;
+ $$->indirection = check_indirection($2);
$$->val = NULL;
$$->location = @1;
}
{
$$ = makeNode(ResTarget);
$$->name = $1;
- $$->indirection = $2;
+ $$->indirection = check_indirection($2);
$$->val = NULL; /* upper production sets this */
$$->location = @1;
}
{
A_Indirection *n = makeNode(A_Indirection);
n->arg = (Node *) p;
- n->indirection = $2;
+ n->indirection = check_indirection($2);
$$ = (Node *) n;
}
else
{
A_Indirection *n = makeNode(A_Indirection);
n->arg = $2;
- n->indirection = $4;
+ n->indirection = check_indirection($4);
$$ = (Node *)n;
}
else
{
$$ = makeNode(ResTarget);
$$->name = $3;
- $$->indirection = NULL;
+ $$->indirection = NIL;
$$->val = (Node *) $1;
$$->location = @1;
}
{
$$ = makeNode(ResTarget);
$$->name = NULL;
- $$->indirection = NULL;
+ $$->indirection = NIL;
$$->val = (Node *) $1;
$$->location = @1;
}
}
| '.' '*'
{
- $$ = (Node *) makeString("*");
+ $$ = (Node *) makeNode(A_Star);
}
| '[' a_expr ']'
{
| '*'
{
ColumnRef *n = makeNode(ColumnRef);
- n->fields = list_make1(makeString("*"));
+ n->fields = list_make1(makeNode(A_Star));
n->location = @1;
$$ = makeNode(ResTarget);
%%
static Node *
-makeColumnRef(char *relname, List *indirection, int location)
+makeColumnRef(char *colname, List *indirection, int location)
{
/*
* Generate a ColumnRef node, with an A_Indirection node added if there
if (nfields == 0)
{
/* easy case - all indirection goes to A_Indirection */
- c->fields = list_make1(makeString(relname));
- i->indirection = indirection;
+ c->fields = list_make1(makeString(colname));
+ i->indirection = check_indirection(indirection);
}
else
{
/* got to split the list in two */
- i->indirection = list_copy_tail(indirection, nfields);
+ i->indirection = check_indirection(list_copy_tail(indirection,
+ nfields));
indirection = list_truncate(indirection, nfields);
- c->fields = lcons(makeString(relname), indirection);
+ c->fields = lcons(makeString(colname), indirection);
}
i->arg = (Node *) c;
return (Node *) i;
}
+ else if (IsA(lfirst(l), A_Star))
+ {
+ /* We only allow '*' at the end of a ColumnRef */
+ if (lnext(l) != NULL)
+ yyerror("improper use of \"*\"");
+ }
nfields++;
}
/* No subscripting, so all indirection gets added to field list */
- c->fields = lcons(makeString(relname), indirection);
+ c->fields = lcons(makeString(colname), indirection);
return (Node *) c;
}
{
if (!IsA(lfirst(i), String))
yyerror("syntax error");
- else if (strcmp(strVal(lfirst(i)), "*") == 0)
- yyerror("syntax error");
}
}
{
if (!IsA(lfirst(i), String))
yyerror("syntax error");
- else if (strcmp(strVal(lfirst(i)), "*") == 0)
- yyerror("syntax error");
}
return names;
}
+/* check_indirection --- check the result of indirection production
+ *
+ * We only allow '*' at the end of the list, but it's hard to enforce that
+ * in the grammar, so do it here.
+ */
+static List *
+check_indirection(List *indirection)
+{
+ ListCell *l;
+
+ foreach(l, indirection)
+ {
+ if (IsA(lfirst(l), A_Star))
+ {
+ if (lnext(l) != NULL)
+ yyerror("improper use of \"*\"");
+ }
+ }
+ return indirection;
+}
+
/* extractArgTypes()
* Given a list of FunctionParameter nodes, extract a list of just the
* argument types (TypeNames) for input parameters only. This is what
*----------
*/
if (IsA(node, ColumnRef) &&
- list_length(((ColumnRef *) node)->fields) == 1)
+ list_length(((ColumnRef *) node)->fields) == 1 &&
+ IsA(linitial(((ColumnRef *) node)->fields), String))
{
char *name = strVal(linitial(((ColumnRef *) node)->fields));
int location = ((ColumnRef *) node)->location;
if (IsA(n, A_Indices))
subscripts = lappend(subscripts, n);
+ else if (IsA(n, A_Star))
+ {
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("row expansion via \"*\" is not supported here"),
+ parser_errposition(pstate, exprLocation(basenode))));
+ }
else
{
Assert(IsA(n, String));
{
case 1:
{
- char *name = strVal(linitial(cref->fields));
+ Node *field1 = (Node *) linitial(cref->fields);
+ char *name1;
+
+ Assert(IsA(field1, String));
+ name1 = strVal(field1);
/* Try to identify as an unqualified column */
- node = colNameToVar(pstate, name, false, cref->location);
+ node = colNameToVar(pstate, name1, false, cref->location);
if (node == NULL)
{
* have used VALUE as a column name in the past.)
*/
if (pstate->p_value_substitute != NULL &&
- strcmp(name, "value") == 0)
+ strcmp(name1, "value") == 0)
{
node = (Node *) copyObject(pstate->p_value_substitute);
* PostQUEL-inspired syntax. The preferred form now is
* "rel.*".
*/
- if (refnameRangeTblEntry(pstate, NULL, name,
+ if (refnameRangeTblEntry(pstate, NULL, name1,
&levels_up) != NULL)
- node = transformWholeRowRef(pstate, NULL, name,
+ node = transformWholeRowRef(pstate, NULL, name1,
cref->location);
else
ereport(ERROR,
(errcode(ERRCODE_UNDEFINED_COLUMN),
errmsg("column \"%s\" does not exist",
- name),
+ name1),
parser_errposition(pstate, cref->location)));
}
break;
}
case 2:
{
- char *name1 = strVal(linitial(cref->fields));
- char *name2 = strVal(lsecond(cref->fields));
+ Node *field1 = (Node *) linitial(cref->fields);
+ Node *field2 = (Node *) lsecond(cref->fields);
+ char *name1;
+ char *name2;
+
+ Assert(IsA(field1, String));
+ name1 = strVal(field1);
/* Whole-row reference? */
- if (strcmp(name2, "*") == 0)
+ if (IsA(field2, A_Star))
{
node = transformWholeRowRef(pstate, NULL, name1,
cref->location);
break;
}
+ Assert(IsA(field2, String));
+ name2 = strVal(field2);
+
/* Try to identify as a once-qualified column */
node = qualifiedNameToVar(pstate, NULL, name1, name2, true,
cref->location);
}
case 3:
{
- char *name1 = strVal(linitial(cref->fields));
- char *name2 = strVal(lsecond(cref->fields));
- char *name3 = strVal(lthird(cref->fields));
+ Node *field1 = (Node *) linitial(cref->fields);
+ Node *field2 = (Node *) lsecond(cref->fields);
+ Node *field3 = (Node *) lthird(cref->fields);
+ char *name1;
+ char *name2;
+ char *name3;
+
+ Assert(IsA(field1, String));
+ name1 = strVal(field1);
+ Assert(IsA(field2, String));
+ name2 = strVal(field2);
/* Whole-row reference? */
- if (strcmp(name3, "*") == 0)
+ if (IsA(field3, A_Star))
{
node = transformWholeRowRef(pstate, name1, name2,
cref->location);
break;
}
+ Assert(IsA(field3, String));
+ name3 = strVal(field3);
+
/* Try to identify as a twice-qualified column */
node = qualifiedNameToVar(pstate, name1, name2, name3, true,
cref->location);
}
case 4:
{
- char *name1 = strVal(linitial(cref->fields));
- char *name2 = strVal(lsecond(cref->fields));
- char *name3 = strVal(lthird(cref->fields));
- char *name4 = strVal(lfourth(cref->fields));
+ Node *field1 = (Node *) linitial(cref->fields);
+ Node *field2 = (Node *) lsecond(cref->fields);
+ Node *field3 = (Node *) lthird(cref->fields);
+ Node *field4 = (Node *) lfourth(cref->fields);
+ char *name1;
+ char *name2;
+ char *name3;
+ char *name4;
+
+ Assert(IsA(field1, String));
+ name1 = strVal(field1);
+ Assert(IsA(field2, String));
+ name2 = strVal(field2);
+ Assert(IsA(field3, String));
+ name3 = strVal(field3);
/*
* We check the catalog name and then ignore it.
parser_errposition(pstate, cref->location)));
/* Whole-row reference? */
- if (strcmp(name4, "*") == 0)
+ if (IsA(field4, A_Star))
{
node = transformWholeRowRef(pstate, name2, name3,
cref->location);
break;
}
+ Assert(IsA(field4, String));
+ name4 = strVal(field4);
+
/* Try to identify as a twice-qualified column */
node = qualifiedNameToVar(pstate, name2, name3, name4, true,
cref->location);
/*
* Check for "something.*". Depending on the complexity of the
- * "something", the star could appear as the last name in ColumnRef,
+ * "something", the star could appear as the last field in ColumnRef,
* or as the last indirection item in A_Indirection.
*/
if (IsA(res->val, ColumnRef))
{
ColumnRef *cref = (ColumnRef *) res->val;
- if (strcmp(strVal(llast(cref->fields)), "*") == 0)
+ if (IsA(llast(cref->fields), A_Star))
{
/* It is something.*, expand into multiple items */
p_target = list_concat(p_target,
else if (IsA(res->val, A_Indirection))
{
A_Indirection *ind = (A_Indirection *) res->val;
- Node *lastitem = llast(ind->indirection);
- if (IsA(lastitem, String) &&
- strcmp(strVal(lastitem), "*") == 0)
+ if (IsA(llast(ind->indirection), A_Star))
{
/* It is something.*, expand into multiple items */
p_target = list_concat(p_target,
/*
* Check for "something.*". Depending on the complexity of the
- * "something", the star could appear as the last name in ColumnRef,
+ * "something", the star could appear as the last field in ColumnRef,
* or as the last indirection item in A_Indirection.
*/
if (IsA(e, ColumnRef))
{
ColumnRef *cref = (ColumnRef *) e;
- if (strcmp(strVal(llast(cref->fields)), "*") == 0)
+ if (IsA(llast(cref->fields), A_Star))
{
/* It is something.*, expand into multiple items */
result = list_concat(result,
else if (IsA(e, A_Indirection))
{
A_Indirection *ind = (A_Indirection *) e;
- Node *lastitem = llast(ind->indirection);
- if (IsA(lastitem, String) &&
- strcmp(strVal(lastitem), "*") == 0)
+ if (IsA(llast(ind->indirection), A_Star))
{
/* It is something.*, expand into multiple items */
result = list_concat(result,
if (((A_Indices *) n)->lidx != NULL)
isSlice = true;
}
+ else if (IsA(n, A_Star))
+ {
+ ereport(ERROR,
+ (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
+ errmsg("row expansion via \"*\" is not supported here"),
+ parser_errposition(pstate, location)));
+ }
else
{
FieldStore *fstore;
* ExpandColumnRefStar()
* Transforms foo.* into a list of expressions or targetlist entries.
*
- * This handles the case where '*' appears as the last or only name in a
+ * This handles the case where '*' appears as the last or only item in a
* ColumnRef. The code is shared between the case of foo.* at the top level
* in a SELECT target list (where we want TargetEntry nodes in the result)
* and foo.* in a ROW() or VALUES() construct (where we want just bare
* (e.g., SELECT * FROM emp, dept)
*
* Since the grammar only accepts bare '*' at top level of SELECT, we
- * need not handle the targetlist==false case here. However, we must
- * test for it because the grammar currently fails to distinguish a
- * quoted name "*" from a real asterisk.
+ * need not handle the targetlist==false case here.
*/
- if (!targetlist)
- elog(ERROR, "invalid use of *");
-
+ Assert(targetlist);
return ExpandAllTables(pstate);
}
else
{
Node *i = lfirst(l);
- if (strcmp(strVal(i), "*") != 0)
+ if (IsA(i, String))
fname = strVal(i);
}
if (fname)
char *fname = NULL;
ListCell *l;
- /* find last field name, if any, ignoring "*" */
+ /* find last field name, if any, ignoring "*" and subscripts */
foreach(l, ind->indirection)
{
Node *i = lfirst(l);
- if (IsA(i, String) &&
- strcmp(strVal(i), "*") != 0)
+ if (IsA(i, String))
fname = strVal(i);
}
if (fname)
{
ColumnRef *cr = (ColumnRef *) tm;
- if (list_length(cr->fields) == 1)
+ if (list_length(cr->fields) == 1 &&
+ IsA(linitial(cr->fields), String))
cstr = strVal(linitial(cr->fields));
}
if (!cstr)
{
UnlistenStmt *stmt = (UnlistenStmt *) parsetree;
- Async_Unlisten(stmt->relation->relname);
+ if (stmt->relation)
+ Async_Unlisten(stmt->relation->relname);
+ else
+ Async_UnlistenAll();
}
break;
T_ParamRef,
T_A_Const,
T_FuncCall,
+ T_A_Star,
T_A_Indices,
T_A_Indirection,
T_A_ArrayExpr,
/*
* ColumnRef - specifies a reference to a column, or possibly a whole tuple
*
- * The "fields" list must be nonempty; its last component may be "*"
- * instead of a regular field name.
+ * The "fields" list must be nonempty. It can contain string Value nodes
+ * (representing names) and A_Star nodes (representing occurrence of a '*').
+ * Currently, A_Star must appear only as the last list element --- the grammar
+ * is responsible for enforcing this!
*
* Note: any array subscripting or selection of fields from composite columns
* is represented by an A_Indirection node above the ColumnRef. However,
typedef struct ColumnRef
{
NodeTag type;
- List *fields; /* field names (list of Value strings) */
+ List *fields; /* field names (Value strings) or A_Star */
int location; /* token location, or -1 if unknown */
} ColumnRef;
} FuncCall;
/*
- * A_Indices - array reference or bounds ([lidx:uidx] or [uidx])
+ * A_Star - '*' representing all columns of a table or compound field
+ *
+ * This can appear within ColumnRef.fields, A_Indirection.indirection, and
+ * ResTarget.indirection lists.
+ */
+typedef struct A_Star
+{
+ NodeTag type;
+} A_Star;
+
+/*
+ * A_Indices - array subscript or slice bounds ([lidx:uidx] or [uidx])
*/
typedef struct A_Indices
{
NodeTag type;
- Node *lidx; /* could be NULL */
+ Node *lidx; /* NULL if it's a single subscript */
Node *uidx;
} A_Indices;
/*
* A_Indirection - select a field and/or array element from an expression
*
- * The indirection list can contain both A_Indices nodes (representing
- * subscripting) and string Value nodes (representing field selection
- * --- the string value is the name of the field to select). For example,
- * a complex selection operation like
+ * The indirection list can contain A_Indices nodes (representing
+ * subscripting), string Value nodes (representing field selection --- the
+ * string value is the name of the field to select), and A_Star nodes
+ * (representing selection of all fields of a composite type).
+ * For example, a complex selection operation like
* (foo).field1[42][7].field2
* would be represented with a single A_Indirection node having a 4-element
* indirection list.
*
- * Note: as of Postgres 8.0, we don't support arrays of composite values,
- * so cases in which a field select follows a subscript aren't actually
- * semantically legal. However the parser is prepared to handle such.
+ * Currently, A_Star must appear only as the last list element --- the grammar
+ * is responsible for enforcing this!
*/
typedef struct A_Indirection
{
NodeTag type;
Node *arg; /* the thing being selected from */
- List *indirection; /* subscripts and/or field names */
+ List *indirection; /* subscripts and/or field names and/or * */
} A_Indirection;
/*
{
NodeTag type;
char *name; /* column name or NULL */
- List *indirection; /* subscripts and field names, or NIL */
+ List *indirection; /* subscripts, field names, and '*', or NIL */
Node *val; /* the value expression to compute or assign */
int location; /* token location, or -1 if unknown */
} ResTarget;
typedef struct ListenStmt
{
NodeTag type;
- RangeVar *relation; /* qualified name to listen on */
+ RangeVar *relation; /* name to listen on */
} ListenStmt;
/* ----------------------
typedef struct UnlistenStmt
{
NodeTag type;
- RangeVar *relation; /* qualified name to unlisten on, or '*' */
+ RangeVar *relation; /* name to unlisten on, or NULL for all */
} UnlistenStmt;
/* ----------------------
projects / users / simon / postgres.git / commitdiff