*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.22 1998/08/23 14:43:46 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.23 1998/08/25 03:17:28 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int32 attrtypmod);
-/* transformTargetIdent()
+/* MakeTargetEntryIdent()
* Transforms an Ident Node to a Target Entry
* Created this function to allow the ORDER/GROUP BY clause to be able
* to construct a TargetEntry from an Ident.
* - thomas 1998-06-02
*/
TargetEntry *
-transformTargetIdent(ParseState *pstate,
+MakeTargetEntryIdent(ParseState *pstate,
#if FALSE
Ident *ident,
#else
Node *node,
#endif
- TargetEntry *tent,
char **resname,
char *refname,
char *colname,
{
Node *expr = NULL;
Oid attrtype_target;
-
+ TargetEntry *tent = makeNode(TargetEntry);
if (pstate->p_is_insert)
{
target_colname = *resname;
+ /* this looks strange to me, returning an empty TargetEntry bjm 1998/08/24 */
if (target_colname == NULL || colname == NULL)
return (tent);
attrtypmod_target = get_atttypmod(pstate->p_target_relation->rd_id, resdomno_target);
#ifdef PARSEDEBUG
-printf("transformTargetIdent- transform type %d to %d\n",
+printf("MakeTargetEntryIdent- transform type %d to %d\n",
attrtype_id, attrtype_target);
#endif
if ((attrtype_id != attrtype_target)
{
expr = coerce_type(pstate, node, attrtype_id, attrtype_target);
expr = transformExpr(pstate, expr, EXPR_COLUMN_FIRST);
- tent = MakeTargetlistExpr(pstate, *resname, expr, FALSE, FALSE);
+ tent = MakeTargetEntryExpr(pstate, *resname, expr, FALSE, FALSE);
expr = tent->expr;
}
else
name = ((*resname != NULL)? *resname: colname);
#ifdef PARSEDEBUG
-printf("transformTargetIdent- call transformIdent()\n");
+printf("MakeTargetEntryIdent- call transformIdent()\n");
#endif
#if FALSE
expr = transformIdent(pstate, (Node *) ident, EXPR_COLUMN_FIRST);
type_mod = -1;
#ifdef PARSEDEBUG
-printf("transformTargetIdent- attrtype_target = %d; type_mod = %d\n", attrtype_target, type_mod);
+printf("MakeTargetEntryIdent- attrtype_target = %d; type_mod = %d\n", attrtype_target, type_mod);
#endif
tent->resdom = makeResdom((AttrNumber) pstate->p_last_resno++,
}
return (tent);
-} /* transformTargetIdent() */
+} /* MakeTargetEntryIdent() */
-/* MakeTargetlistExpr()
+/* MakeTargetEntryExpr()
* Make a TargetEntry from an expression.
* arrayRef is a list of transformed A_Indices.
*
*/
TargetEntry *
-MakeTargetlistExpr(ParseState *pstate,
+MakeTargetEntryExpr(ParseState *pstate,
char *colname,
Node *expr,
List *arrayRef,
int resdomno;
Relation rd;
bool attrisset;
- TargetEntry *tent;
Resdom *resnode;
if (expr == NULL)
- elog(ERROR, "MakeTargetlistExpr: invalid use of NULL expression");
+ elog(ERROR, "MakeTargetEntryExpr: invalid use of NULL expression");
type_id = exprType(expr);
if (nodeTag(expr) == T_Var)
else
type_mod = -1;
- /* Processes target columns that will be receiving results */
+ /* Process target columns that will be receiving results */
if (pstate->p_is_insert || pstate->p_is_update)
{
/*
}
#ifdef PARSEDEBUG
-printf("MakeTargetlistExpr: attrtypmod is %d\n", (int4) attrtypmod);
+printf("MakeTargetEntryExpr: attrtypmod is %d\n", (int4) attrtypmod);
#endif
/* Apparently going to a fixed-length string?
(Oid) 0,
resjunk);
- tent = makeTargetEntry(resnode, expr);
+ return makeTargetEntry(resnode, expr);
+} /* MakeTargetEntryExpr() */
- return tent;
-} /* MakeTargetlistExpr() */
+/*
+ * MakeTargetlistComplex()
+ * pMake a TargetEntry from an complex node.
+ */
+static TargetEntry *
+MakeTargetEntryComplex(ParseState *pstate,
+ ResTarget *res)
+{
+ Node *expr = transformExpr(pstate, (Node *) res->val, EXPR_COLUMN_FIRST);
+
+#ifdef PARSEDEBUG
+printf("transformTargetList: decode T_Expr\n");
+#endif
+
+ handleTargetColname(pstate, &res->name, NULL, NULL);
+ /* note indirection has not been transformed */
+ if (pstate->p_is_insert && res->indirection != NIL)
+ {
+ /* this is an array assignment */
+ char *val;
+ char *str,
+ *save_str;
+ List *elt;
+ int i = 0,
+ ndims;
+ int lindx[MAXDIM],
+ uindx[MAXDIM];
+ int resdomno;
+ Relation rd;
+ Value *constval;
+
+ if (exprType(expr) != UNKNOWNOID || !IsA(expr, Const))
+ elog(ERROR, "yyparse: string constant expected");
+
+ val = (char *) textout((struct varlena *)
+ ((Const *) expr)->constvalue);
+ str = save_str = (char *) palloc(strlen(val) + MAXDIM * 25 + 2);
+ foreach(elt, res->indirection)
+ {
+ A_Indices *aind = (A_Indices *) lfirst(elt);
+
+ aind->uidx = transformExpr(pstate, aind->uidx, EXPR_COLUMN_FIRST);
+ if (!IsA(aind->uidx, Const))
+ elog(ERROR, "Array Index for Append should be a constant");
+
+ uindx[i] = ((Const *) aind->uidx)->constvalue;
+ if (aind->lidx != NULL)
+ {
+ aind->lidx = transformExpr(pstate, aind->lidx, EXPR_COLUMN_FIRST);
+ if (!IsA(aind->lidx, Const))
+ elog(ERROR, "Array Index for Append should be a constant");
+
+ lindx[i] = ((Const *) aind->lidx)->constvalue;
+ }
+ else
+ lindx[i] = 1;
+ if (lindx[i] > uindx[i])
+ elog(ERROR, "yyparse: lower index cannot be greater than upper index");
+ sprintf(str, "[%d:%d]", lindx[i], uindx[i]);
+ str += strlen(str);
+ i++;
+ }
+ sprintf(str, "=%s", val);
+ rd = pstate->p_target_relation;
+ Assert(rd != NULL);
+ resdomno = attnameAttNum(rd, res->name);
+ ndims = attnumAttNelems(rd, resdomno);
+ if (i != ndims)
+ elog(ERROR, "yyparse: array dimensions do not match");
+
+ constval = makeNode(Value);
+ constval->type = T_String;
+ constval->val.str = save_str;
+ return MakeTargetEntryExpr(pstate, res->name,
+ (Node *) make_const(constval),
+ NULL, FALSE);
+ pfree(save_str);
+ }
+ else
+ {
+ char *colname = res->name;
+ /* this is not an array assignment */
+ if (colname == NULL)
+ {
+ /*
+ * if you're wondering why this is here, look
+ * at the yacc grammar for why a name can be
+ * missing. -ay
+ */
+ colname = FigureColname(expr, res->val);
+ }
+ if (res->indirection)
+ {
+ List *ilist = res->indirection;
+
+ while (ilist != NIL)
+ {
+ A_Indices *ind = lfirst(ilist);
+
+ ind->lidx = transformExpr(pstate, ind->lidx, EXPR_COLUMN_FIRST);
+ ind->uidx = transformExpr(pstate, ind->uidx, EXPR_COLUMN_FIRST);
+ ilist = lnext(ilist);
+ }
+ }
+ res->name = colname;
+ return MakeTargetEntryExpr(pstate, res->name, expr,
+ res->indirection, FALSE);
+ }
+}
+
+/*
+ * MakeTargetlistComplex()
+ * pMake a TargetEntry from an complex node.
+ */
+static TargetEntry *
+MakeTargetEntryAttr(ParseState *pstate,
+ ResTarget *res)
+{
+ Oid type_id;
+ int32 type_mod;
+ Attr *att = (Attr *) res->val;
+ Node *result;
+ char *attrname;
+ char *resname;
+ Resdom *resnode;
+ int resdomno;
+ List *attrs = att->attrs;
+ TargetEntry *tent;
+ Oid relid;
+
+ attrname = strVal(lfirst(att->attrs));
+ /*
+ * Target item is fully specified: ie.
+ * relation.attribute
+ */
+#ifdef PARSEDEBUG
+printf("transformTargetList: decode T_Attr\n");
+#endif
+ result = ParseNestedFuncOrColumn(pstate, att, &pstate->p_last_resno, EXPR_COLUMN_FIRST);
+ handleTargetColname(pstate, &res->name, att->relname, attrname);
+ if (att->indirection != NIL)
+ {
+ List *ilist = att->indirection;
+
+ while (ilist != NIL)
+ {
+ A_Indices *ind = lfirst(ilist);
+
+ ind->lidx = transformExpr(pstate, ind->lidx, EXPR_COLUMN_FIRST);
+ ind->uidx = transformExpr(pstate, ind->uidx, EXPR_COLUMN_FIRST);
+ ilist = lnext(ilist);
+ }
+ result = (Node *) make_array_ref(result, att->indirection);
+ }
+ type_id = exprType(result);
+ if (nodeTag(result) == T_Var)
+ type_mod = ((Var *) result)->vartypmod;
+ else
+ type_mod = -1;
+ /* move to last entry */
+ while (lnext(attrs) != NIL)
+ attrs = lnext(attrs);
+ resname = (res->name) ? res->name : strVal(lfirst(attrs));
+ if (pstate->p_is_insert || pstate->p_is_update)
+ {
+ /*
+ * insert or update query -- insert, update work only on one
+ * relation, so multiple occurence of same resdomno is bogus
+ */
+ relid = refnameRangeTableEntry(pstate, att->relname)->relid;
+ resdomno = get_attnum(relid, attrname);
+ }
+ else
+ resdomno = pstate->p_last_resno++;
+ resnode = makeResdom((AttrNumber) resdomno,
+ (Oid) type_id,
+ type_mod,
+ resname,
+ (Index) 0,
+ (Oid) 0,
+ 0);
+ tent = makeNode(TargetEntry);
+ tent->resdom = resnode;
+ tent->expr = result;
+ return tent;
+}
+
+
/* transformTargetList()
* Turns a list of ResTarget's into a list of TargetEntry's.
*/
while (targetlist != NIL)
{
ResTarget *res = (ResTarget *) lfirst(targetlist);
- TargetEntry *tent = makeNode(TargetEntry);
+ TargetEntry *tent = NULL;
switch (nodeTag(res->val))
{
case T_Ident:
{
char *identname;
-#if FALSE
- char *resname;
-#endif
#ifdef PARSEDEBUG
printf("transformTargetList: decode T_Ident\n");
#endif
identname = ((Ident *) res->val)->name;
- tent = transformTargetIdent(pstate, (Node *)res->val, tent, &res->name, NULL, identname, FALSE);
+ tent = MakeTargetEntryIdent(pstate, (Node *)res->val, &res->name, NULL, identname, FALSE);
break;
}
case T_ParamNo:
case T_A_Const:
case T_A_Expr:
{
- Node *expr = transformExpr(pstate, (Node *) res->val, EXPR_COLUMN_FIRST);
-
-#ifdef PARSEDEBUG
-printf("transformTargetList: decode T_Expr\n");
-#endif
- handleTargetColname(pstate, &res->name, NULL, NULL);
- /* note indirection has not been transformed */
- if (pstate->p_is_insert && res->indirection != NIL)
- {
- /* this is an array assignment */
- char *val;
- char *str,
- *save_str;
- List *elt;
- int i = 0,
- ndims;
- int lindx[MAXDIM],
- uindx[MAXDIM];
- int resdomno;
- Relation rd;
- Value *constval;
-
- if (exprType(expr) != UNKNOWNOID || !IsA(expr, Const))
- elog(ERROR, "yyparse: string constant expected");
-
- val = (char *) textout((struct varlena *)
- ((Const *) expr)->constvalue);
- str = save_str = (char *) palloc(strlen(val) + MAXDIM * 25 + 2);
- foreach(elt, res->indirection)
- {
- A_Indices *aind = (A_Indices *) lfirst(elt);
-
- aind->uidx = transformExpr(pstate, aind->uidx, EXPR_COLUMN_FIRST);
- if (!IsA(aind->uidx, Const))
- elog(ERROR, "Array Index for Append should be a constant");
-
- uindx[i] = ((Const *) aind->uidx)->constvalue;
- if (aind->lidx != NULL)
- {
- aind->lidx = transformExpr(pstate, aind->lidx, EXPR_COLUMN_FIRST);
- if (!IsA(aind->lidx, Const))
- elog(ERROR, "Array Index for Append should be a constant");
-
- lindx[i] = ((Const *) aind->lidx)->constvalue;
- }
- else
- lindx[i] = 1;
- if (lindx[i] > uindx[i])
- elog(ERROR, "yyparse: lower index cannot be greater than upper index");
-
- sprintf(str, "[%d:%d]", lindx[i], uindx[i]);
- str += strlen(str);
- i++;
- }
- sprintf(str, "=%s", val);
- rd = pstate->p_target_relation;
- Assert(rd != NULL);
- resdomno = attnameAttNum(rd, res->name);
- ndims = attnumAttNelems(rd, resdomno);
- if (i != ndims)
- elog(ERROR, "yyparse: array dimensions do not match");
-
- constval = makeNode(Value);
- constval->type = T_String;
- constval->val.str = save_str;
- tent = MakeTargetlistExpr(pstate, res->name,
- (Node *) make_const(constval),
- NULL, FALSE);
- pfree(save_str);
- }
- else
- {
- char *colname = res->name;
-
- /* this is not an array assignment */
- if (colname == NULL)
- {
- /*
- * if you're wondering why this is here, look
- * at the yacc grammar for why a name can be
- * missing. -ay
- */
- colname = FigureColname(expr, res->val);
- }
- if (res->indirection)
- {
- List *ilist = res->indirection;
-
- while (ilist != NIL)
- {
- A_Indices *ind = lfirst(ilist);
-
- ind->lidx = transformExpr(pstate, ind->lidx, EXPR_COLUMN_FIRST);
- ind->uidx = transformExpr(pstate, ind->uidx, EXPR_COLUMN_FIRST);
- ilist = lnext(ilist);
- }
- }
- res->name = colname;
- tent = MakeTargetlistExpr(pstate, res->name, expr,
- res->indirection, FALSE);
- }
+ tent = MakeTargetEntryComplex(pstate, res);
break;
}
case T_Attr:
{
- Oid type_id;
- int32 type_mod;
- Attr *att = (Attr *) res->val;
- Node *result;
+ bool expand_star = false;
char *attrname;
- char *resname;
- Resdom *resnode;
- List *attrs = att->attrs;
-
+ Attr *att = (Attr *) res->val;
/*
* Target item is a single '*', expand all tables (eg.
* SELECT * FROM emp)
p_target = tail_p_target = ExpandAllTables(pstate);
else
lnext(tail_p_target) = ExpandAllTables(pstate);
-
- while (lnext(tail_p_target) != NIL)
- /* make sure we point to the last target entry */
- tail_p_target = lnext(tail_p_target);
-
- /*
- * skip rest of while loop
- */
- targetlist = lnext(targetlist);
- continue;
+ expand_star = true;
}
/*
lnext(tail_p_target) =
expandAll(pstate, att->relname, att->relname,
&pstate->p_last_resno);
+ expand_star = true;
+ }
+ if (expand_star)
+ {
while (lnext(tail_p_target) != NIL)
/* make sure we point to the last target entry */
tail_p_target = lnext(tail_p_target);
-
/*
- * skip the rest of the while loop
+ * skip rest of while loop
*/
targetlist = lnext(targetlist);
continue;
}
-
-
- /*
- * Target item is fully specified: ie.
- * relation.attribute
- */
-#ifdef PARSEDEBUG
-printf("transformTargetList: decode T_Attr\n");
-#endif
- result = ParseNestedFuncOrColumn(pstate, att, &pstate->p_last_resno, EXPR_COLUMN_FIRST);
- handleTargetColname(pstate, &res->name, att->relname, attrname);
- if (att->indirection != NIL)
+ else
{
- List *ilist = att->indirection;
-
- while (ilist != NIL)
- {
- A_Indices *ind = lfirst(ilist);
-
- ind->lidx = transformExpr(pstate, ind->lidx, EXPR_COLUMN_FIRST);
- ind->uidx = transformExpr(pstate, ind->uidx, EXPR_COLUMN_FIRST);
- ilist = lnext(ilist);
- }
- result = (Node *) make_array_ref(result, att->indirection);
+ tent = MakeTargetEntryAttr(pstate, res);
+ break;
}
- type_id = exprType(result);
- if (nodeTag(result) == T_Var)
- type_mod = ((Var *) result)->vartypmod;
- else
- type_mod = -1;
- /* move to last entry */
- while (lnext(attrs) != NIL)
- attrs = lnext(attrs);
- resname = (res->name) ? res->name : strVal(lfirst(attrs));
- resnode = makeResdom((AttrNumber) pstate->p_last_resno++,
- (Oid) type_id,
- type_mod,
- resname,
- (Index) 0,
- (Oid) 0,
- 0);
- tent->resdom = resnode;
- tent->expr = result;
- break;
}
default:
/* internal error */
projects / postgresql.git / commitdiff