mirror of
https://github.com/postgres/postgres.git
synced 2025-07-17 06:41:09 +03:00
pgindent run before 6.3 release, with Thomas' requested changes.
This commit is contained in:
Bruce Momjian
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.70 1998/02/10 04:01:38 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.71 1998/02/26 04:33:26 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -42,7 +42,7 @@ static Query *transformUpdateStmt(ParseState *pstate, UpdateStmt *stmt);
|
||||
static Query *transformCursorStmt(ParseState *pstate, SelectStmt *stmt);
|
||||
static Query *transformCreateStmt(ParseState *pstate, CreateStmt *stmt);
|
||||
|
||||
List *extras = NIL;
|
||||
List *extras = NIL;
|
||||
|
||||
/*
|
||||
* parse_analyze -
|
||||
@ -102,10 +102,10 @@ transformStmt(ParseState *pstate, Node *parseTree)
|
||||
|
||||
switch (nodeTag(parseTree))
|
||||
{
|
||||
/*------------------------
|
||||
* Non-optimizable statements
|
||||
*------------------------
|
||||
*/
|
||||
/*------------------------
|
||||
* Non-optimizable statements
|
||||
*------------------------
|
||||
*/
|
||||
case T_CreateStmt:
|
||||
result = transformCreateStmt(pstate, (CreateStmt *) parseTree);
|
||||
break;
|
||||
@ -162,10 +162,10 @@ transformStmt(ParseState *pstate, Node *parseTree)
|
||||
}
|
||||
break;
|
||||
|
||||
/*------------------------
|
||||
* Optimizable statements
|
||||
*------------------------
|
||||
*/
|
||||
/*------------------------
|
||||
* Optimizable statements
|
||||
*------------------------
|
||||
*/
|
||||
case T_InsertStmt:
|
||||
result = transformInsertStmt(pstate, (InsertStmt *) parseTree);
|
||||
break;
|
||||
@ -179,7 +179,7 @@ transformStmt(ParseState *pstate, Node *parseTree)
|
||||
break;
|
||||
|
||||
case T_SelectStmt:
|
||||
if (!((SelectStmt *)parseTree)->portalname)
|
||||
if (!((SelectStmt *) parseTree)->portalname)
|
||||
result = transformSelectStmt(pstate, (SelectStmt *) parseTree);
|
||||
else
|
||||
result = transformCursorStmt(pstate, (SelectStmt *) parseTree);
|
||||
@ -218,7 +218,7 @@ transformDeleteStmt(ParseState *pstate, DeleteStmt *stmt)
|
||||
/* fix where clause */
|
||||
qry->qual = transformWhereClause(pstate, stmt->whereClause);
|
||||
qry->hasSubLinks = pstate->p_hasSubLinks;
|
||||
|
||||
|
||||
qry->rtable = pstate->p_rtable;
|
||||
qry->resultRelation = refnameRangeTablePosn(pstate, stmt->relname, NULL);
|
||||
|
||||
@ -249,43 +249,43 @@ transformInsertStmt(ParseState *pstate, InsertStmt *stmt)
|
||||
|
||||
/* fix the target list */
|
||||
icolumns = pstate->p_insert_columns = makeTargetNames(pstate, stmt->cols);
|
||||
|
||||
|
||||
qry->targetList = transformTargetList(pstate, stmt->targetList);
|
||||
|
||||
|
||||
/* DEFAULT handling */
|
||||
if (length(qry->targetList) < pstate->p_target_relation->rd_att->natts &&
|
||||
pstate->p_target_relation->rd_att->constr &&
|
||||
pstate->p_target_relation->rd_att->constr->num_defval > 0)
|
||||
{
|
||||
AttributeTupleForm *att = pstate->p_target_relation->rd_att->attrs;
|
||||
AttrDefault *defval = pstate->p_target_relation->rd_att->constr->defval;
|
||||
int ndef = pstate->p_target_relation->rd_att->constr->num_defval;
|
||||
|
||||
/*
|
||||
AttributeTupleForm *att = pstate->p_target_relation->rd_att->attrs;
|
||||
AttrDefault *defval = pstate->p_target_relation->rd_att->constr->defval;
|
||||
int ndef = pstate->p_target_relation->rd_att->constr->num_defval;
|
||||
|
||||
/*
|
||||
* if stmt->cols == NIL then makeTargetNames returns list of all
|
||||
* attrs: have to shorter icolumns list...
|
||||
*/
|
||||
if (stmt->cols == NIL)
|
||||
{
|
||||
List *extrl;
|
||||
int i = length(qry->targetList);
|
||||
|
||||
foreach (extrl, icolumns)
|
||||
List *extrl;
|
||||
int i = length(qry->targetList);
|
||||
|
||||
foreach(extrl, icolumns)
|
||||
{
|
||||
if (--i <= 0)
|
||||
break;
|
||||
}
|
||||
freeList (lnext(extrl));
|
||||
freeList(lnext(extrl));
|
||||
lnext(extrl) = NIL;
|
||||
}
|
||||
|
||||
|
||||
while (ndef-- > 0)
|
||||
{
|
||||
List *tl;
|
||||
Ident *id;
|
||||
TargetEntry *te;
|
||||
|
||||
foreach (tl, icolumns)
|
||||
List *tl;
|
||||
Ident *id;
|
||||
TargetEntry *te;
|
||||
|
||||
foreach(tl, icolumns)
|
||||
{
|
||||
id = (Ident *) lfirst(tl);
|
||||
if (!namestrcmp(&(att[defval[ndef].adnum - 1]->attname), id->name))
|
||||
@ -293,33 +293,34 @@ transformInsertStmt(ParseState *pstate, InsertStmt *stmt)
|
||||
}
|
||||
if (tl != NIL) /* something given for this attr */
|
||||
continue;
|
||||
/*
|
||||
* Nothing given for this attr with DEFAULT expr, so
|
||||
* add new TargetEntry to qry->targetList.
|
||||
* Note, that we set resno to defval[ndef].adnum:
|
||||
* it's what transformTargetList()->make_targetlist_expr()
|
||||
* does for INSERT ... SELECT. But for INSERT ... VALUES
|
||||
* pstate->p_last_resno is used. It doesn't matter for
|
||||
* "normal" using (planner creates proper target list
|
||||
* in preptlist.c), but may break RULEs in some way.
|
||||
* It seems better to create proper target list here...
|
||||
|
||||
/*
|
||||
* Nothing given for this attr with DEFAULT expr, so add new
|
||||
* TargetEntry to qry->targetList. Note, that we set resno to
|
||||
* defval[ndef].adnum: it's what
|
||||
* transformTargetList()->make_targetlist_expr() does for
|
||||
* INSERT ... SELECT. But for INSERT ... VALUES
|
||||
* pstate->p_last_resno is used. It doesn't matter for
|
||||
* "normal" using (planner creates proper target list in
|
||||
* preptlist.c), but may break RULEs in some way. It seems
|
||||
* better to create proper target list here...
|
||||
*/
|
||||
te = makeNode(TargetEntry);
|
||||
te->resdom = makeResdom(defval[ndef].adnum,
|
||||
att[defval[ndef].adnum - 1]->atttypid,
|
||||
att[defval[ndef].adnum - 1]->atttypmod,
|
||||
pstrdup(nameout(&(att[defval[ndef].adnum - 1]->attname))),
|
||||
att[defval[ndef].adnum - 1]->atttypmod,
|
||||
pstrdup(nameout(&(att[defval[ndef].adnum - 1]->attname))),
|
||||
0, 0, 0);
|
||||
te->fjoin = NULL;
|
||||
te->expr = (Node *) stringToNode(defval[ndef].adbin);
|
||||
qry->targetList = lappend (qry->targetList, te);
|
||||
qry->targetList = lappend(qry->targetList, te);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/* fix where clause */
|
||||
qry->qual = transformWhereClause(pstate, stmt->whereClause);
|
||||
qry->hasSubLinks = pstate->p_hasSubLinks;
|
||||
|
||||
|
||||
/* now the range table will not change */
|
||||
qry->rtable = pstate->p_rtable;
|
||||
qry->resultRelation = refnameRangeTablePosn(pstate, stmt->relname, NULL);
|
||||
@ -340,7 +341,8 @@ transformInsertStmt(ParseState *pstate, InsertStmt *stmt)
|
||||
parseCheckAggregates(pstate, qry);
|
||||
|
||||
/* The INSERT INTO ... SELECT ... could have a UNION */
|
||||
qry->unionall = stmt->unionall; /* in child, so unionClause may be false */
|
||||
qry->unionall = stmt->unionall; /* in child, so unionClause may be
|
||||
* false */
|
||||
qry->unionClause = transformUnionClause(stmt->unionClause, qry->targetList);
|
||||
|
||||
return (Query *) qry;
|
||||
@ -353,33 +355,33 @@ transformInsertStmt(ParseState *pstate, InsertStmt *stmt)
|
||||
static char *
|
||||
makeTableName(void *elem,...)
|
||||
{
|
||||
va_list args;
|
||||
va_list args;
|
||||
|
||||
char *name;
|
||||
char buf[NAMEDATALEN+1];
|
||||
char *name;
|
||||
char buf[NAMEDATALEN + 1];
|
||||
|
||||
buf[0] = '\0';
|
||||
|
||||
va_start(args,elem);
|
||||
va_start(args, elem);
|
||||
|
||||
name = elem;
|
||||
while (name != NULL)
|
||||
{
|
||||
/* not enough room for next part? then return nothing */
|
||||
if ((strlen(buf)+strlen(name)) >= (sizeof(buf)-1))
|
||||
if ((strlen(buf) + strlen(name)) >= (sizeof(buf) - 1))
|
||||
return (NULL);
|
||||
|
||||
if (strlen(buf) > 0)
|
||||
strcat(buf,"_");
|
||||
strcat(buf,name);
|
||||
strcat(buf, "_");
|
||||
strcat(buf, name);
|
||||
|
||||
name = va_arg(args,void *);
|
||||
name = va_arg(args, void *);
|
||||
}
|
||||
|
||||
va_end(args);
|
||||
|
||||
name = palloc(strlen(buf)+1);
|
||||
strcpy(name,buf);
|
||||
name = palloc(strlen(buf) + 1);
|
||||
strcpy(name, buf);
|
||||
|
||||
return (name);
|
||||
}
|
||||
@ -391,10 +393,10 @@ CreateIndexName(char *tname, char *cname, char *label, List *indices)
|
||||
char *iname = NULL;
|
||||
List *ilist;
|
||||
IndexStmt *index;
|
||||
char name2[NAMEDATALEN+1];
|
||||
char name2[NAMEDATALEN + 1];
|
||||
|
||||
/* use working storage, since we might be trying several possibilities */
|
||||
strcpy(name2,cname);
|
||||
strcpy(name2, cname);
|
||||
while (iname == NULL)
|
||||
{
|
||||
iname = makeTableName(tname, name2, label, NULL);
|
||||
@ -406,7 +408,7 @@ CreateIndexName(char *tname, char *cname, char *label, List *indices)
|
||||
while (ilist != NIL)
|
||||
{
|
||||
index = lfirst(ilist);
|
||||
if (strcasecmp(iname,index->idxname) == 0)
|
||||
if (strcasecmp(iname, index->idxname) == 0)
|
||||
break;
|
||||
|
||||
ilist = lnext(ilist);
|
||||
@ -419,7 +421,7 @@ CreateIndexName(char *tname, char *cname, char *label, List *indices)
|
||||
pfree(iname);
|
||||
iname = NULL;
|
||||
pass++;
|
||||
sprintf(name2, "%s_%d", cname, (pass+1));
|
||||
sprintf(name2, "%s_%d", cname, (pass + 1));
|
||||
}
|
||||
|
||||
return (iname);
|
||||
@ -444,7 +446,8 @@ transformCreateStmt(ParseState *pstate, CreateStmt *stmt)
|
||||
List *columns;
|
||||
List *dlist;
|
||||
ColumnDef *column;
|
||||
List *constraints, *clist;
|
||||
List *constraints,
|
||||
*clist;
|
||||
Constraint *constraint;
|
||||
List *keys;
|
||||
Ident *key;
|
||||
@ -467,7 +470,7 @@ transformCreateStmt(ParseState *pstate, CreateStmt *stmt)
|
||||
{
|
||||
case T_ColumnDef:
|
||||
column = (ColumnDef *) element;
|
||||
columns = lappend(columns,column);
|
||||
columns = lappend(columns, column);
|
||||
if (column->constraints != NIL)
|
||||
{
|
||||
clist = column->constraints;
|
||||
@ -478,15 +481,15 @@ transformCreateStmt(ParseState *pstate, CreateStmt *stmt)
|
||||
{
|
||||
case CONSTR_NOTNULL:
|
||||
if (column->is_not_null)
|
||||
elog(ERROR,"CREATE TABLE/NOT NULL already specified"
|
||||
" for %s.%s", stmt->relname, column->colname);
|
||||
elog(ERROR, "CREATE TABLE/NOT NULL already specified"
|
||||
" for %s.%s", stmt->relname, column->colname);
|
||||
column->is_not_null = TRUE;
|
||||
break;
|
||||
|
||||
case CONSTR_DEFAULT:
|
||||
if (column->defval != NULL)
|
||||
elog(ERROR,"CREATE TABLE/DEFAULT multiple values specified"
|
||||
" for %s.%s", stmt->relname, column->colname);
|
||||
elog(ERROR, "CREATE TABLE/DEFAULT multiple values specified"
|
||||
" for %s.%s", stmt->relname, column->colname);
|
||||
column->defval = constraint->def;
|
||||
break;
|
||||
|
||||
@ -513,7 +516,7 @@ transformCreateStmt(ParseState *pstate, CreateStmt *stmt)
|
||||
break;
|
||||
|
||||
default:
|
||||
elog(ERROR,"parser: internal error; unrecognized constraint",NULL);
|
||||
elog(ERROR, "parser: internal error; unrecognized constraint", NULL);
|
||||
break;
|
||||
}
|
||||
clist = lnext(clist);
|
||||
@ -545,16 +548,16 @@ transformCreateStmt(ParseState *pstate, CreateStmt *stmt)
|
||||
|
||||
case CONSTR_NOTNULL:
|
||||
case CONSTR_DEFAULT:
|
||||
elog(ERROR,"parser: internal error; illegal context for constraint",NULL);
|
||||
elog(ERROR, "parser: internal error; illegal context for constraint", NULL);
|
||||
break;
|
||||
default:
|
||||
elog(ERROR,"parser: internal error; unrecognized constraint",NULL);
|
||||
elog(ERROR, "parser: internal error; unrecognized constraint", NULL);
|
||||
break;
|
||||
}
|
||||
break;
|
||||
|
||||
default:
|
||||
elog(ERROR,"parser: internal error; unrecognized node",NULL);
|
||||
elog(ERROR, "parser: internal error; unrecognized node", NULL);
|
||||
}
|
||||
|
||||
elements = lnext(elements);
|
||||
@ -568,25 +571,25 @@ transformCreateStmt(ParseState *pstate, CreateStmt *stmt)
|
||||
* For UNIQUE, create an index as for PRIMARY KEYS, but do not insist on NOT NULL.
|
||||
*
|
||||
* Note that this code does not currently look for all possible redundant cases
|
||||
* and either ignore or stop with warning. The create might fail later when
|
||||
* names for indices turn out to be redundant, or a user might have specified
|
||||
* extra useless indices which might hurt performance. - thomas 1997-12-08
|
||||
* and either ignore or stop with warning. The create might fail later when
|
||||
* names for indices turn out to be redundant, or a user might have specified
|
||||
* extra useless indices which might hurt performance. - thomas 1997-12-08
|
||||
*/
|
||||
ilist = NIL;
|
||||
while (dlist != NIL)
|
||||
{
|
||||
constraint = lfirst(dlist);
|
||||
if (nodeTag(constraint) != T_Constraint)
|
||||
elog(ERROR,"parser: internal error; unrecognized deferred node",NULL);
|
||||
elog(ERROR, "parser: internal error; unrecognized deferred node", NULL);
|
||||
|
||||
if (constraint->contype == CONSTR_PRIMARY)
|
||||
if (have_pkey)
|
||||
elog(ERROR,"CREATE TABLE/PRIMARY KEY multiple primary keys"
|
||||
" for table %s are not legal", stmt->relname);
|
||||
else
|
||||
elog(ERROR, "CREATE TABLE/PRIMARY KEY multiple primary keys"
|
||||
" for table %s are not legal", stmt->relname);
|
||||
else
|
||||
have_pkey = TRUE;
|
||||
else if (constraint->contype != CONSTR_UNIQUE)
|
||||
elog(ERROR,"parser: internal error; unrecognized deferred constraint",NULL);
|
||||
elog(ERROR, "parser: internal error; unrecognized deferred constraint", NULL);
|
||||
|
||||
index = makeNode(IndexStmt);
|
||||
|
||||
@ -596,7 +599,7 @@ transformCreateStmt(ParseState *pstate, CreateStmt *stmt)
|
||||
else if (constraint->contype == CONSTR_PRIMARY)
|
||||
{
|
||||
if (have_pkey)
|
||||
elog(ERROR,"CREATE TABLE/PRIMARY KEY multiple keys for table %s are not legal", stmt->relname);
|
||||
elog(ERROR, "CREATE TABLE/PRIMARY KEY multiple keys for table %s are not legal", stmt->relname);
|
||||
|
||||
have_pkey = TRUE;
|
||||
index->idxname = makeTableName(stmt->relname, "pkey", NULL);
|
||||
@ -609,7 +612,7 @@ transformCreateStmt(ParseState *pstate, CreateStmt *stmt)
|
||||
index->indexParams = NIL;
|
||||
index->withClause = NIL;
|
||||
index->whereClause = NULL;
|
||||
|
||||
|
||||
keys = constraint->keys;
|
||||
while (keys != NIL)
|
||||
{
|
||||
@ -619,17 +622,19 @@ transformCreateStmt(ParseState *pstate, CreateStmt *stmt)
|
||||
while (columns != NIL)
|
||||
{
|
||||
column = lfirst(columns);
|
||||
if (strcasecmp(column->colname,key->name) == 0) break;
|
||||
else column = NULL;
|
||||
if (strcasecmp(column->colname, key->name) == 0)
|
||||
break;
|
||||
else
|
||||
column = NULL;
|
||||
columns = lnext(columns);
|
||||
}
|
||||
if (column == NULL)
|
||||
elog(ERROR,"parser: column '%s' in key does not exist",key->name);
|
||||
elog(ERROR, "parser: column '%s' in key does not exist", key->name);
|
||||
|
||||
if (constraint->contype == CONSTR_PRIMARY)
|
||||
column->is_not_null = TRUE;
|
||||
iparam = makeNode(IndexElem);
|
||||
iparam->name = strcpy(palloc(strlen(column->colname)+1), column->colname);
|
||||
iparam->name = strcpy(palloc(strlen(column->colname) + 1), column->colname);
|
||||
iparam->args = NIL;
|
||||
iparam->class = NULL;
|
||||
iparam->tname = NULL;
|
||||
@ -642,12 +647,12 @@ transformCreateStmt(ParseState *pstate, CreateStmt *stmt)
|
||||
}
|
||||
|
||||
if (index->idxname == NULL)
|
||||
elog(ERROR,"parser: unable to construct implicit index for table %s"
|
||||
"; name too long", stmt->relname);
|
||||
elog(ERROR, "parser: unable to construct implicit index for table %s"
|
||||
"; name too long", stmt->relname);
|
||||
else
|
||||
elog(NOTICE,"CREATE TABLE/%s will create implicit index %s for table %s",
|
||||
((constraint->contype == CONSTR_PRIMARY)? "PRIMARY KEY": "UNIQUE"),
|
||||
index->idxname, stmt->relname);
|
||||
elog(NOTICE, "CREATE TABLE/%s will create implicit index %s for table %s",
|
||||
((constraint->contype == CONSTR_PRIMARY) ? "PRIMARY KEY" : "UNIQUE"),
|
||||
index->idxname, stmt->relname);
|
||||
|
||||
ilist = lappend(ilist, index);
|
||||
dlist = lnext(dlist);
|
||||
@ -674,7 +679,7 @@ transformIndexStmt(ParseState *pstate, IndexStmt *stmt)
|
||||
/* take care of the where clause */
|
||||
stmt->whereClause = transformWhereClause(pstate, stmt->whereClause);
|
||||
qry->hasSubLinks = pstate->p_hasSubLinks;
|
||||
|
||||
|
||||
stmt->rangetable = pstate->p_rtable;
|
||||
|
||||
qry->utilityStmt = (Node *) stmt;
|
||||
@ -793,7 +798,8 @@ transformSelectStmt(ParseState *pstate, SelectStmt *stmt)
|
||||
if (pstate->p_hasAggs)
|
||||
parseCheckAggregates(pstate, qry);
|
||||
|
||||
qry->unionall = stmt->unionall; /* in child, so unionClause may be false */
|
||||
qry->unionall = stmt->unionall; /* in child, so unionClause may be
|
||||
* false */
|
||||
qry->unionClause = transformUnionClause(stmt->unionClause, qry->targetList);
|
||||
|
||||
return (Query *) qry;
|
||||
|
||||
@ -1,224 +1,225 @@
|
||||
typedef union
|
||||
{
|
||||
double dval;
|
||||
int ival;
|
||||
char chr;
|
||||
char *str;
|
||||
bool boolean;
|
||||
bool* pboolean; /* for pg_user privileges */
|
||||
List *list;
|
||||
Node *node;
|
||||
Value *value;
|
||||
double dval;
|
||||
int ival;
|
||||
char chr;
|
||||
char *str;
|
||||
bool boolean;
|
||||
bool *pboolean; /* for pg_user privileges */
|
||||
List *list;
|
||||
Node *node;
|
||||
Value *value;
|
||||
|
||||
Attr *attr;
|
||||
Attr *attr;
|
||||
|
||||
TypeName *typnam;
|
||||
DefElem *defelt;
|
||||
ParamString *param;
|
||||
SortGroupBy *sortgroupby;
|
||||
IndexElem *ielem;
|
||||
RangeVar *range;
|
||||
RelExpr *relexp;
|
||||
A_Indices *aind;
|
||||
ResTarget *target;
|
||||
ParamNo *paramno;
|
||||
TypeName *typnam;
|
||||
DefElem *defelt;
|
||||
ParamString *param;
|
||||
SortGroupBy *sortgroupby;
|
||||
IndexElem *ielem;
|
||||
RangeVar *range;
|
||||
RelExpr *relexp;
|
||||
A_Indices *aind;
|
||||
ResTarget *target;
|
||||
ParamNo *paramno;
|
||||
|
||||
VersionStmt *vstmt;
|
||||
DefineStmt *dstmt;
|
||||
RuleStmt *rstmt;
|
||||
InsertStmt *astmt;
|
||||
VersionStmt *vstmt;
|
||||
DefineStmt *dstmt;
|
||||
RuleStmt *rstmt;
|
||||
InsertStmt *astmt;
|
||||
} YYSTYPE;
|
||||
#define ACTION 258
|
||||
#define ADD 259
|
||||
#define ALL 260
|
||||
#define ALTER 261
|
||||
#define AND 262
|
||||
#define ANY 263
|
||||
#define AS 264
|
||||
#define ASC 265
|
||||
#define BEGIN_TRANS 266
|
||||
#define BETWEEN 267
|
||||
#define BOTH 268
|
||||
#define BY 269
|
||||
#define CASCADE 270
|
||||
#define CAST 271
|
||||
#define CHAR 272
|
||||
#define CHARACTER 273
|
||||
#define CHECK 274
|
||||
#define CLOSE 275
|
||||
#define COLLATE 276
|
||||
#define COLUMN 277
|
||||
#define COMMIT 278
|
||||
#define CONSTRAINT 279
|
||||
#define CREATE 280
|
||||
#define CROSS 281
|
||||
#define CURRENT 282
|
||||
#define CURRENT_DATE 283
|
||||
#define CURRENT_TIME 284
|
||||
#define CURRENT_TIMESTAMP 285
|
||||
#define CURRENT_USER 286
|
||||
#define CURSOR 287
|
||||
#define DAY_P 288
|
||||
#define DECIMAL 289
|
||||
#define DECLARE 290
|
||||
#define DEFAULT 291
|
||||
#define DELETE 292
|
||||
#define DESC 293
|
||||
#define DISTINCT 294
|
||||
#define DOUBLE 295
|
||||
#define DROP 296
|
||||
#define END_TRANS 297
|
||||
#define EXECUTE 298
|
||||
#define EXISTS 299
|
||||
#define EXTRACT 300
|
||||
#define FETCH 301
|
||||
#define FLOAT 302
|
||||
#define FOR 303
|
||||
#define FOREIGN 304
|
||||
#define FROM 305
|
||||
#define FULL 306
|
||||
#define GRANT 307
|
||||
#define GROUP 308
|
||||
#define HAVING 309
|
||||
#define HOUR_P 310
|
||||
#define IN 311
|
||||
#define INNER_P 312
|
||||
#define INSERT 313
|
||||
#define INTERVAL 314
|
||||
#define INTO 315
|
||||
#define IS 316
|
||||
#define JOIN 317
|
||||
#define KEY 318
|
||||
#define LANGUAGE 319
|
||||
#define LEADING 320
|
||||
#define LEFT 321
|
||||
#define LIKE 322
|
||||
#define LOCAL 323
|
||||
#define MATCH 324
|
||||
#define MINUTE_P 325
|
||||
#define MONTH_P 326
|
||||
#define NATIONAL 327
|
||||
#define NATURAL 328
|
||||
#define NCHAR 329
|
||||
#define NO 330
|
||||
#define NOT 331
|
||||
#define NOTIFY 332
|
||||
#define NULL_P 333
|
||||
#define NUMERIC 334
|
||||
#define ON 335
|
||||
#define OPTION 336
|
||||
#define OR 337
|
||||
#define ORDER 338
|
||||
#define OUTER_P 339
|
||||
#define PARTIAL 340
|
||||
#define POSITION 341
|
||||
#define PRECISION 342
|
||||
#define PRIMARY 343
|
||||
#define PRIVILEGES 344
|
||||
#define PROCEDURE 345
|
||||
#define PUBLIC 346
|
||||
#define REFERENCES 347
|
||||
#define REVOKE 348
|
||||
#define RIGHT 349
|
||||
#define ROLLBACK 350
|
||||
#define SECOND_P 351
|
||||
#define SELECT 352
|
||||
#define SET 353
|
||||
#define SUBSTRING 354
|
||||
#define TABLE 355
|
||||
#define TIME 356
|
||||
#define TIMESTAMP 357
|
||||
#define TO 358
|
||||
#define TRAILING 359
|
||||
#define TRANSACTION 360
|
||||
#define TRIM 361
|
||||
#define UNION 362
|
||||
#define UNIQUE 363
|
||||
#define UPDATE 364
|
||||
#define USING 365
|
||||
#define VALUES 366
|
||||
#define VARCHAR 367
|
||||
#define VARYING 368
|
||||
#define VIEW 369
|
||||
#define WHERE 370
|
||||
#define WITH 371
|
||||
#define WORK 372
|
||||
#define YEAR_P 373
|
||||
#define ZONE 374
|
||||
#define FALSE_P 375
|
||||
#define TRIGGER 376
|
||||
#define TRUE_P 377
|
||||
#define TYPE_P 378
|
||||
#define ABORT_TRANS 379
|
||||
#define AFTER 380
|
||||
#define AGGREGATE 381
|
||||
#define ANALYZE 382
|
||||
#define BACKWARD 383
|
||||
#define BEFORE 384
|
||||
#define BINARY 385
|
||||
#define CLUSTER 386
|
||||
#define COPY 387
|
||||
#define DATABASE 388
|
||||
#define DELIMITERS 389
|
||||
#define DO 390
|
||||
#define EACH 391
|
||||
#define EXPLAIN 392
|
||||
#define EXTEND 393
|
||||
#define FORWARD 394
|
||||
#define FUNCTION 395
|
||||
#define HANDLER 396
|
||||
#define INDEX 397
|
||||
#define INHERITS 398
|
||||
#define INSTEAD 399
|
||||
#define ISNULL 400
|
||||
#define LANCOMPILER 401
|
||||
#define LISTEN 402
|
||||
#define LOAD 403
|
||||
#define LOCK_P 404
|
||||
#define LOCATION 405
|
||||
#define MOVE 406
|
||||
#define NEW 407
|
||||
#define NONE 408
|
||||
#define NOTHING 409
|
||||
#define NOTNULL 410
|
||||
#define OIDS 411
|
||||
#define OPERATOR 412
|
||||
#define PROCEDURAL 413
|
||||
#define RECIPE 414
|
||||
#define RENAME 415
|
||||
#define RESET 416
|
||||
#define RETURNS 417
|
||||
#define ROW 418
|
||||
#define RULE 419
|
||||
#define SEQUENCE 420
|
||||
#define SETOF 421
|
||||
#define SHOW 422
|
||||
#define STATEMENT 423
|
||||
#define STDIN 424
|
||||
#define STDOUT 425
|
||||
#define TRUSTED 426
|
||||
#define VACUUM 427
|
||||
#define VERBOSE 428
|
||||
#define VERSION 429
|
||||
#define ARCHIVE 430
|
||||
#define USER 431
|
||||
#define PASSWORD 432
|
||||
#define CREATEDB 433
|
||||
#define NOCREATEDB 434
|
||||
#define CREATEUSER 435
|
||||
#define NOCREATEUSER 436
|
||||
#define VALID 437
|
||||
#define UNTIL 438
|
||||
#define IDENT 439
|
||||
#define SCONST 440
|
||||
#define Op 441
|
||||
#define ICONST 442
|
||||
#define PARAM 443
|
||||
#define FCONST 444
|
||||
#define OP 445
|
||||
#define UMINUS 446
|
||||
#define TYPECAST 447
|
||||
#define REDUCE 448
|
||||
|
||||
#define ACTION 258
|
||||
#define ADD 259
|
||||
#define ALL 260
|
||||
#define ALTER 261
|
||||
#define AND 262
|
||||
#define ANY 263
|
||||
#define AS 264
|
||||
#define ASC 265
|
||||
#define BEGIN_TRANS 266
|
||||
#define BETWEEN 267
|
||||
#define BOTH 268
|
||||
#define BY 269
|
||||
#define CASCADE 270
|
||||
#define CAST 271
|
||||
#define CHAR 272
|
||||
#define CHARACTER 273
|
||||
#define CHECK 274
|
||||
#define CLOSE 275
|
||||
#define COLLATE 276
|
||||
#define COLUMN 277
|
||||
#define COMMIT 278
|
||||
#define CONSTRAINT 279
|
||||
#define CREATE 280
|
||||
#define CROSS 281
|
||||
#define CURRENT 282
|
||||
#define CURRENT_DATE 283
|
||||
#define CURRENT_TIME 284
|
||||
#define CURRENT_TIMESTAMP 285
|
||||
#define CURRENT_USER 286
|
||||
#define CURSOR 287
|
||||
#define DAY_P 288
|
||||
#define DECIMAL 289
|
||||
#define DECLARE 290
|
||||
#define DEFAULT 291
|
||||
#define DELETE 292
|
||||
#define DESC 293
|
||||
#define DISTINCT 294
|
||||
#define DOUBLE 295
|
||||
#define DROP 296
|
||||
#define END_TRANS 297
|
||||
#define EXECUTE 298
|
||||
#define EXISTS 299
|
||||
#define EXTRACT 300
|
||||
#define FETCH 301
|
||||
#define FLOAT 302
|
||||
#define FOR 303
|
||||
#define FOREIGN 304
|
||||
#define FROM 305
|
||||
#define FULL 306
|
||||
#define GRANT 307
|
||||
#define GROUP 308
|
||||
#define HAVING 309
|
||||
#define HOUR_P 310
|
||||
#define IN 311
|
||||
#define INNER_P 312
|
||||
#define INSERT 313
|
||||
#define INTERVAL 314
|
||||
#define INTO 315
|
||||
#define IS 316
|
||||
#define JOIN 317
|
||||
#define KEY 318
|
||||
#define LANGUAGE 319
|
||||
#define LEADING 320
|
||||
#define LEFT 321
|
||||
#define LIKE 322
|
||||
#define LOCAL 323
|
||||
#define MATCH 324
|
||||
#define MINUTE_P 325
|
||||
#define MONTH_P 326
|
||||
#define NATIONAL 327
|
||||
#define NATURAL 328
|
||||
#define NCHAR 329
|
||||
#define NO 330
|
||||
#define NOT 331
|
||||
#define NOTIFY 332
|
||||
#define NULL_P 333
|
||||
#define NUMERIC 334
|
||||
#define ON 335
|
||||
#define OPTION 336
|
||||
#define OR 337
|
||||
#define ORDER 338
|
||||
#define OUTER_P 339
|
||||
#define PARTIAL 340
|
||||
#define POSITION 341
|
||||
#define PRECISION 342
|
||||
#define PRIMARY 343
|
||||
#define PRIVILEGES 344
|
||||
#define PROCEDURE 345
|
||||
#define PUBLIC 346
|
||||
#define REFERENCES 347
|
||||
#define REVOKE 348
|
||||
#define RIGHT 349
|
||||
#define ROLLBACK 350
|
||||
#define SECOND_P 351
|
||||
#define SELECT 352
|
||||
#define SET 353
|
||||
#define SUBSTRING 354
|
||||
#define TABLE 355
|
||||
#define TIME 356
|
||||
#define TIMESTAMP 357
|
||||
#define TO 358
|
||||
#define TRAILING 359
|
||||
#define TRANSACTION 360
|
||||
#define TRIM 361
|
||||
#define UNION 362
|
||||
#define UNIQUE 363
|
||||
#define UPDATE 364
|
||||
#define USING 365
|
||||
#define VALUES 366
|
||||
#define VARCHAR 367
|
||||
#define VARYING 368
|
||||
#define VIEW 369
|
||||
#define WHERE 370
|
||||
#define WITH 371
|
||||
#define WORK 372
|
||||
#define YEAR_P 373
|
||||
#define ZONE 374
|
||||
#define FALSE_P 375
|
||||
#define TRIGGER 376
|
||||
#define TRUE_P 377
|
||||
#define TYPE_P 378
|
||||
#define ABORT_TRANS 379
|
||||
#define AFTER 380
|
||||
#define AGGREGATE 381
|
||||
#define ANALYZE 382
|
||||
#define BACKWARD 383
|
||||
#define BEFORE 384
|
||||
#define BINARY 385
|
||||
#define CLUSTER 386
|
||||
#define COPY 387
|
||||
#define DATABASE 388
|
||||
#define DELIMITERS 389
|
||||
#define DO 390
|
||||
#define EACH 391
|
||||
#define EXPLAIN 392
|
||||
#define EXTEND 393
|
||||
#define FORWARD 394
|
||||
#define FUNCTION 395
|
||||
#define HANDLER 396
|
||||
#define INDEX 397
|
||||
#define INHERITS 398
|
||||
#define INSTEAD 399
|
||||
#define ISNULL 400
|
||||
#define LANCOMPILER 401
|
||||
#define LISTEN 402
|
||||
#define LOAD 403
|
||||
#define LOCK_P 404
|
||||
#define LOCATION 405
|
||||
#define MOVE 406
|
||||
#define NEW 407
|
||||
#define NONE 408
|
||||
#define NOTHING 409
|
||||
#define NOTNULL 410
|
||||
#define OIDS 411
|
||||
#define OPERATOR 412
|
||||
#define PROCEDURAL 413
|
||||
#define RECIPE 414
|
||||
#define RENAME 415
|
||||
#define RESET 416
|
||||
#define RETURNS 417
|
||||
#define ROW 418
|
||||
#define RULE 419
|
||||
#define SEQUENCE 420
|
||||
#define SETOF 421
|
||||
#define SHOW 422
|
||||
#define STATEMENT 423
|
||||
#define STDIN 424
|
||||
#define STDOUT 425
|
||||
#define TRUSTED 426
|
||||
#define VACUUM 427
|
||||
#define VERBOSE 428
|
||||
#define VERSION 429
|
||||
#define ARCHIVE 430
|
||||
#define USER 431
|
||||
#define PASSWORD 432
|
||||
#define CREATEDB 433
|
||||
#define NOCREATEDB 434
|
||||
#define CREATEUSER 435
|
||||
#define NOCREATEUSER 436
|
||||
#define VALID 437
|
||||
#define UNTIL 438
|
||||
#define IDENT 439
|
||||
#define SCONST 440
|
||||
#define Op 441
|
||||
#define ICONST 442
|
||||
#define PARAM 443
|
||||
#define FCONST 444
|
||||
#define OP 445
|
||||
#define UMINUS 446
|
||||
#define TYPECAST 447
|
||||
#define REDUCE 448
|
||||
|
||||
|
||||
extern YYSTYPE yylval;
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_agg.c,v 1.8 1998/01/20 05:04:11 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_agg.c,v 1.9 1998/02/26 04:33:28 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -218,9 +218,9 @@ parseCheckAggregates(ParseState *pstate, Query *qry)
|
||||
}
|
||||
|
||||
|
||||
Aggreg *
|
||||
Aggreg *
|
||||
ParseAgg(ParseState *pstate, char *aggname, Oid basetype,
|
||||
List *target, int precedence)
|
||||
List *target, int precedence)
|
||||
{
|
||||
Oid fintype;
|
||||
Oid vartype;
|
||||
@ -229,7 +229,7 @@ ParseAgg(ParseState *pstate, char *aggname, Oid basetype,
|
||||
Aggreg *aggreg;
|
||||
HeapTuple theAggTuple;
|
||||
bool usenulls = false;
|
||||
|
||||
|
||||
theAggTuple = SearchSysCacheTuple(AGGNAME, PointerGetDatum(aggname),
|
||||
ObjectIdGetDatum(basetype),
|
||||
0, 0);
|
||||
@ -237,34 +237,33 @@ ParseAgg(ParseState *pstate, char *aggname, Oid basetype,
|
||||
elog(ERROR, "aggregate %s does not exist", aggname);
|
||||
|
||||
/*
|
||||
* We do a major hack for count(*) here.
|
||||
* We do a major hack for count(*) here.
|
||||
*
|
||||
* Count(*) poses several problems. First, we need a field that is
|
||||
* guaranteed to be in the range table, and unique. Using a constant
|
||||
* causes the optimizer to properly remove the aggragate from any
|
||||
* elements of the query.
|
||||
* Using just 'oid', which can not be null, in the parser fails on:
|
||||
* Count(*) poses several problems. First, we need a field that is
|
||||
* guaranteed to be in the range table, and unique. Using a constant
|
||||
* causes the optimizer to properly remove the aggragate from any
|
||||
* elements of the query. Using just 'oid', which can not be null, in
|
||||
* the parser fails on:
|
||||
*
|
||||
* select count(*) from tab1, tab2 -- oid is not unique
|
||||
* select count(*) from viewtable -- views don't have real oids
|
||||
* select count(*) from tab1, tab2 -- oid is not unique select
|
||||
* count(*) from viewtable -- views don't have real oids
|
||||
*
|
||||
* So, for an aggregate with parameter '*', we use the first valid
|
||||
* range table entry, and pick the first column from the table.
|
||||
* We set a flag to count nulls, because we could have nulls in
|
||||
* that column.
|
||||
* So, for an aggregate with parameter '*', we use the first valid range
|
||||
* table entry, and pick the first column from the table. We set a
|
||||
* flag to count nulls, because we could have nulls in that column.
|
||||
*
|
||||
* It's an ugly job, but someone has to do it.
|
||||
* bjm 1998/1/18
|
||||
* It's an ugly job, but someone has to do it. bjm 1998/1/18
|
||||
*/
|
||||
|
||||
|
||||
if (nodeTag(lfirst(target)) == T_Const)
|
||||
{
|
||||
Const *con = (Const *)lfirst(target);
|
||||
|
||||
Const *con = (Const *) lfirst(target);
|
||||
|
||||
if (con->consttype == UNKNOWNOID && VARSIZE(con->constvalue) == VARHDRSZ)
|
||||
{
|
||||
Attr *attr = makeNode(Attr);
|
||||
List *rtable, *rlist;
|
||||
Attr *attr = makeNode(Attr);
|
||||
List *rtable,
|
||||
*rlist;
|
||||
RangeTblEntry *first_valid_rte;
|
||||
|
||||
Assert(lnext(target) == NULL);
|
||||
@ -273,12 +272,12 @@ ParseAgg(ParseState *pstate, char *aggname, Oid basetype,
|
||||
rtable = lnext(lnext(pstate->p_rtable));
|
||||
else
|
||||
rtable = pstate->p_rtable;
|
||||
|
||||
|
||||
first_valid_rte = NULL;
|
||||
foreach(rlist, rtable)
|
||||
{
|
||||
RangeTblEntry *rte = lfirst(rlist);
|
||||
|
||||
|
||||
/* only entries on outer(non-function?) scope */
|
||||
if (!rte->inFromCl && rte != pstate->p_target_rangetblentry)
|
||||
continue;
|
||||
@ -288,16 +287,16 @@ ParseAgg(ParseState *pstate, char *aggname, Oid basetype,
|
||||
}
|
||||
if (first_valid_rte == NULL)
|
||||
elog(ERROR, "Can't find column to do aggregate(*) on.");
|
||||
|
||||
|
||||
attr->relname = first_valid_rte->refname;
|
||||
attr->attrs = lcons(makeString(
|
||||
get_attname(first_valid_rte->relid,1)),NIL);
|
||||
get_attname(first_valid_rte->relid, 1)), NIL);
|
||||
|
||||
lfirst(target) = transformExpr(pstate, (Node *) attr, precedence);
|
||||
usenulls = true;
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
aggform = (Form_pg_aggregate) GETSTRUCT(theAggTuple);
|
||||
fintype = aggform->aggfinaltype;
|
||||
xfn1 = aggform->aggtransfn1;
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.12 1998/01/20 22:55:25 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.13 1998/02/26 04:33:29 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -26,8 +26,9 @@
|
||||
#include "parser/parse_relation.h"
|
||||
#include "parser/parse_target.h"
|
||||
|
||||
static TargetEntry *find_targetlist_entry(ParseState *pstate,
|
||||
SortGroupBy *sortgroupby, List *tlist);
|
||||
static TargetEntry *
|
||||
find_targetlist_entry(ParseState *pstate,
|
||||
SortGroupBy *sortgroupby, List *tlist);
|
||||
static void parseFromClause(ParseState *pstate, List *frmList);
|
||||
|
||||
/*
|
||||
@ -39,8 +40,8 @@ void
|
||||
makeRangeTable(ParseState *pstate, char *relname, List *frmList)
|
||||
{
|
||||
RangeTblEntry *rte;
|
||||
int sublevels_up;
|
||||
|
||||
int sublevels_up;
|
||||
|
||||
parseFromClause(pstate, frmList);
|
||||
|
||||
if (relname == NULL)
|
||||
@ -48,7 +49,7 @@ makeRangeTable(ParseState *pstate, char *relname, List *frmList)
|
||||
|
||||
if (refnameRangeTablePosn(pstate, relname, &sublevels_up) == 0 ||
|
||||
sublevels_up != 0)
|
||||
rte = addRangeTableEntry(pstate, relname, relname, FALSE, FALSE);
|
||||
rte = addRangeTableEntry(pstate, relname, relname, FALSE, FALSE);
|
||||
else
|
||||
rte = refnameRangeTableEntry(pstate, relname);
|
||||
|
||||
@ -69,7 +70,7 @@ transformWhereClause(ParseState *pstate, Node *a_expr)
|
||||
Node *qual;
|
||||
|
||||
if (a_expr == NULL)
|
||||
return NULL; /* no qualifiers */
|
||||
return NULL; /* no qualifiers */
|
||||
|
||||
pstate->p_in_where_clause = true;
|
||||
qual = transformExpr(pstate, a_expr, EXPR_COLUMN_FIRST);
|
||||
@ -139,7 +140,7 @@ find_targetlist_entry(ParseState *pstate, SortGroupBy *sortgroupby, List *tlist)
|
||||
TargetEntry *target_result = NULL;
|
||||
|
||||
if (sortgroupby->range)
|
||||
real_rtable_pos = refnameRangeTablePosn(pstate, sortgroupby->range, NULL);
|
||||
real_rtable_pos = refnameRangeTablePosn(pstate, sortgroupby->range, NULL);
|
||||
|
||||
foreach(i, tlist)
|
||||
{
|
||||
@ -216,21 +217,21 @@ transformGroupClause(ParseState *pstate, List *grouplist, List *targetlist)
|
||||
else
|
||||
{
|
||||
List *i;
|
||||
|
||||
foreach (i, glist)
|
||||
|
||||
foreach(i, glist)
|
||||
{
|
||||
GroupClause *gcl = (GroupClause *) lfirst (i);
|
||||
|
||||
if ( gcl->entry == grpcl->entry )
|
||||
GroupClause *gcl = (GroupClause *) lfirst(i);
|
||||
|
||||
if (gcl->entry == grpcl->entry)
|
||||
break;
|
||||
}
|
||||
if ( i == NIL ) /* not in grouplist already */
|
||||
if (i == NIL) /* not in grouplist already */
|
||||
{
|
||||
lnext(gl) = lcons(grpcl, NIL);
|
||||
gl = lnext(gl);
|
||||
}
|
||||
else
|
||||
pfree (grpcl); /* get rid of this */
|
||||
pfree(grpcl); /* get rid of this */
|
||||
}
|
||||
grouplist = lnext(grouplist);
|
||||
}
|
||||
@ -259,7 +260,7 @@ transformSortClause(ParseState *pstate,
|
||||
TargetEntry *restarget;
|
||||
Resdom *resdom;
|
||||
|
||||
|
||||
|
||||
restarget = find_targetlist_entry(pstate, sortby, targetlist);
|
||||
if (restarget == NULL)
|
||||
elog(ERROR, "The field being ordered by must appear in the target list");
|
||||
@ -273,21 +274,21 @@ transformSortClause(ParseState *pstate,
|
||||
else
|
||||
{
|
||||
List *i;
|
||||
|
||||
foreach (i, sortlist)
|
||||
|
||||
foreach(i, sortlist)
|
||||
{
|
||||
SortClause *scl = (SortClause *) lfirst (i);
|
||||
|
||||
if ( scl->resdom == sortcl->resdom )
|
||||
SortClause *scl = (SortClause *) lfirst(i);
|
||||
|
||||
if (scl->resdom == sortcl->resdom)
|
||||
break;
|
||||
}
|
||||
if ( i == NIL ) /* not in sortlist already */
|
||||
if (i == NIL) /* not in sortlist already */
|
||||
{
|
||||
lnext(s) = lcons(sortcl, NIL);
|
||||
s = lnext(s);
|
||||
}
|
||||
else
|
||||
pfree (sortcl); /* get rid of this */
|
||||
pfree(sortcl); /* get rid of this */
|
||||
}
|
||||
orderlist = lnext(orderlist);
|
||||
}
|
||||
@ -295,7 +296,7 @@ transformSortClause(ParseState *pstate,
|
||||
if (uniqueFlag)
|
||||
{
|
||||
List *i;
|
||||
|
||||
|
||||
if (uniqueFlag[0] == '*')
|
||||
{
|
||||
|
||||
@ -342,7 +343,7 @@ transformSortClause(ParseState *pstate,
|
||||
}
|
||||
if (i == NIL)
|
||||
elog(ERROR, "The field specified in the UNIQUE ON clause is not in the targetlist");
|
||||
|
||||
|
||||
foreach(s, sortlist)
|
||||
{
|
||||
SortClause *sortcl = lfirst(s);
|
||||
@ -375,15 +376,15 @@ transformSortClause(ParseState *pstate,
|
||||
List *
|
||||
transformUnionClause(List *unionClause, List *targetlist)
|
||||
{
|
||||
List *union_list = NIL;
|
||||
List *union_list = NIL;
|
||||
QueryTreeList *qlist;
|
||||
int i;
|
||||
int i;
|
||||
|
||||
if (unionClause)
|
||||
{
|
||||
qlist = parse_analyze(unionClause, NULL);
|
||||
|
||||
for (i=0; i < qlist->len; i++)
|
||||
for (i = 0; i < qlist->len; i++)
|
||||
union_list = lappend(union_list, qlist->qtrees[i]);
|
||||
/* we need to check return types are consistent here */
|
||||
return union_list;
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.21 1998/02/13 08:10:33 vadim Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.22 1998/02/26 04:33:30 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -57,7 +57,7 @@ transformExpr(ParseState *pstate, Node *expr, int precedence)
|
||||
|
||||
/* what if att.attrs == "*"? */
|
||||
temp = ParseNestedFuncOrColumn(pstate, att, &pstate->p_last_resno,
|
||||
precedence);
|
||||
precedence);
|
||||
if (att->indirection != NIL)
|
||||
{
|
||||
List *idx = att->indirection;
|
||||
@ -147,8 +147,8 @@ transformExpr(ParseState *pstate, Node *expr, int precedence)
|
||||
|
||||
result = ParseFuncOrColumn(pstate,
|
||||
"nullvalue", lcons(lexpr, NIL),
|
||||
&pstate->p_last_resno,
|
||||
precedence);
|
||||
&pstate->p_last_resno,
|
||||
precedence);
|
||||
}
|
||||
break;
|
||||
case NOTNULL:
|
||||
@ -157,8 +157,8 @@ transformExpr(ParseState *pstate, Node *expr, int precedence)
|
||||
|
||||
result = ParseFuncOrColumn(pstate,
|
||||
"nonnullvalue", lcons(lexpr, NIL),
|
||||
&pstate->p_last_resno,
|
||||
precedence);
|
||||
&pstate->p_last_resno,
|
||||
precedence);
|
||||
}
|
||||
break;
|
||||
case AND:
|
||||
@ -169,11 +169,11 @@ transformExpr(ParseState *pstate, Node *expr, int precedence)
|
||||
|
||||
if (exprType(lexpr) != BOOLOID)
|
||||
elog(ERROR, "left-hand side of AND is type '%s', not bool",
|
||||
typeidTypeName(exprType(lexpr)));
|
||||
typeidTypeName(exprType(lexpr)));
|
||||
|
||||
if (exprType(rexpr) != BOOLOID)
|
||||
elog(ERROR, "right-hand side of AND is type '%s', not bool",
|
||||
typeidTypeName(exprType(rexpr)));
|
||||
typeidTypeName(exprType(rexpr)));
|
||||
|
||||
expr->typeOid = BOOLOID;
|
||||
expr->opType = AND_EXPR;
|
||||
@ -218,6 +218,7 @@ transformExpr(ParseState *pstate, Node *expr, int precedence)
|
||||
}
|
||||
case T_Ident:
|
||||
{
|
||||
|
||||
/*
|
||||
* look for a column name or a relation name (the default
|
||||
* behavior)
|
||||
@ -234,58 +235,59 @@ transformExpr(ParseState *pstate, Node *expr, int precedence)
|
||||
foreach(args, fn->args)
|
||||
lfirst(args) = transformExpr(pstate, (Node *) lfirst(args), precedence);
|
||||
result = ParseFuncOrColumn(pstate,
|
||||
fn->funcname, fn->args, &pstate->p_last_resno,
|
||||
precedence);
|
||||
fn->funcname, fn->args, &pstate->p_last_resno,
|
||||
precedence);
|
||||
break;
|
||||
}
|
||||
case T_SubLink:
|
||||
{
|
||||
SubLink *sublink = (SubLink *) expr;
|
||||
QueryTreeList *qtree;
|
||||
List *llist;
|
||||
SubLink *sublink = (SubLink *) expr;
|
||||
QueryTreeList *qtree;
|
||||
List *llist;
|
||||
|
||||
pstate->p_hasSubLinks = true;
|
||||
qtree = parse_analyze(lcons(sublink->subselect,NIL), pstate);
|
||||
if (qtree->len != 1 ||
|
||||
qtree->qtrees[0]->commandType != CMD_SELECT ||
|
||||
qtree->qtrees[0]->resultRelation != 0 )
|
||||
elog (ERROR, "parser: bad query in subselect");
|
||||
qtree = parse_analyze(lcons(sublink->subselect, NIL), pstate);
|
||||
if (qtree->len != 1 ||
|
||||
qtree->qtrees[0]->commandType != CMD_SELECT ||
|
||||
qtree->qtrees[0]->resultRelation != 0)
|
||||
elog(ERROR, "parser: bad query in subselect");
|
||||
sublink->subselect = (Node *) qtree->qtrees[0];
|
||||
|
||||
|
||||
if (sublink->subLinkType != EXISTS_SUBLINK)
|
||||
{
|
||||
char *op = lfirst(sublink->oper);
|
||||
List *left_expr = sublink->lefthand;
|
||||
List *right_expr = ((Query*) sublink->subselect)->targetList;
|
||||
List *elist;
|
||||
char *op = lfirst(sublink->oper);
|
||||
List *left_expr = sublink->lefthand;
|
||||
List *right_expr = ((Query *) sublink->subselect)->targetList;
|
||||
List *elist;
|
||||
|
||||
foreach(llist, left_expr)
|
||||
lfirst(llist) = transformExpr(pstate, lfirst(llist), precedence);
|
||||
|
||||
|
||||
if (length(left_expr) !=
|
||||
length(right_expr))
|
||||
elog(ERROR,"parser: Subselect has too many or too few fields.");
|
||||
|
||||
elog(ERROR, "parser: Subselect has too many or too few fields.");
|
||||
|
||||
sublink->oper = NIL;
|
||||
foreach(elist, left_expr)
|
||||
{
|
||||
Node *lexpr = lfirst(elist);
|
||||
Node *rexpr = lfirst(right_expr);
|
||||
TargetEntry *tent = (TargetEntry *)rexpr;
|
||||
Expr *op_expr;
|
||||
Node *lexpr = lfirst(elist);
|
||||
Node *rexpr = lfirst(right_expr);
|
||||
TargetEntry *tent = (TargetEntry *) rexpr;
|
||||
Expr *op_expr;
|
||||
|
||||
op_expr = make_op(op, lexpr, tent->expr);
|
||||
|
||||
/*
|
||||
* HACK! Second IF is more valid but currently
|
||||
* we don't support EXPR subqueries inside
|
||||
* HACK! Second IF is more valid but currently we
|
||||
* don't support EXPR subqueries inside
|
||||
* expressions generally, only in WHERE clauses.
|
||||
* After fixing this, first IF must be removed.
|
||||
*/
|
||||
if (op_expr->typeOid != BOOLOID)
|
||||
elog (ERROR, "parser: '%s' must return 'bool' to be used with subquery", op);
|
||||
if (op_expr->typeOid != BOOLOID &&
|
||||
sublink->subLinkType != EXPR_SUBLINK)
|
||||
elog (ERROR, "parser: '%s' must return 'bool' to be used with quantified predicate subquery", op);
|
||||
elog(ERROR, "parser: '%s' must return 'bool' to be used with subquery", op);
|
||||
if (op_expr->typeOid != BOOLOID &&
|
||||
sublink->subLinkType != EXPR_SUBLINK)
|
||||
elog(ERROR, "parser: '%s' must return 'bool' to be used with quantified predicate subquery", op);
|
||||
sublink->oper = lappend(sublink->oper, op_expr);
|
||||
right_expr = lnext(right_expr);
|
||||
}
|
||||
@ -325,7 +327,7 @@ transformIdent(ParseState *pstate, Node *expr, int precedence)
|
||||
att->attrs = lcons(makeString(ident->name), NIL);
|
||||
column_result =
|
||||
(Node *) ParseNestedFuncOrColumn(pstate, att, &pstate->p_last_resno,
|
||||
precedence);
|
||||
precedence);
|
||||
}
|
||||
|
||||
/* try to find the ident as a relation */
|
||||
@ -407,7 +409,7 @@ exprType(Node *expr)
|
||||
return type;
|
||||
}
|
||||
|
||||
static Node *
|
||||
static Node *
|
||||
parser_typecast(Value *expr, TypeName *typename, int16 atttypmod)
|
||||
{
|
||||
/* check for passing non-ints */
|
||||
@ -432,7 +434,7 @@ parser_typecast(Value *expr, TypeName *typename, int16 atttypmod)
|
||||
break;
|
||||
default:
|
||||
elog(ERROR,
|
||||
"parser_typecast: cannot cast this expression to type '%s'",
|
||||
"parser_typecast: cannot cast this expression to type '%s'",
|
||||
typename->name);
|
||||
}
|
||||
|
||||
@ -485,7 +487,7 @@ parser_typecast(Value *expr, TypeName *typename, int16 atttypmod)
|
||||
return (Node *) adt;
|
||||
}
|
||||
|
||||
Node *
|
||||
Node *
|
||||
parser_typecast2(Node *expr, Oid exprType, Type tp, int16 atttypmod)
|
||||
{
|
||||
/* check for passing non-ints */
|
||||
@ -605,10 +607,11 @@ parser_typecast2(Node *expr, Oid exprType, Type tp, int16 atttypmod)
|
||||
true /* is cast */ );
|
||||
|
||||
/*
|
||||
* printf("adt %s : %u %d %d\n",CString(expr),typeTypeId(tp) , len,cp);
|
||||
* printf("adt %s : %u %d %d\n",CString(expr),typeTypeId(tp) ,
|
||||
* len,cp);
|
||||
*/
|
||||
if (string_palloced)
|
||||
pfree(const_string);
|
||||
|
||||
return ((Node *) adt);
|
||||
}
|
||||
}
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.14 1998/02/10 16:03:34 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.15 1998/02/26 04:33:30 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -43,34 +43,39 @@
|
||||
#include "utils/lsyscache.h"
|
||||
#include "utils/syscache.h"
|
||||
|
||||
static Node *ParseComplexProjection(ParseState *pstate,
|
||||
char *funcname,
|
||||
Node *first_arg,
|
||||
bool *attisset);
|
||||
static Oid ** argtype_inherit(int nargs, Oid *oid_array);
|
||||
static Node *
|
||||
ParseComplexProjection(ParseState *pstate,
|
||||
char *funcname,
|
||||
Node *first_arg,
|
||||
bool *attisset);
|
||||
static Oid **argtype_inherit(int nargs, Oid *oid_array);
|
||||
static bool can_coerce(int nargs, Oid *input_typeids, Oid *func_typeids);
|
||||
static int find_inheritors(Oid relid, Oid **supervec);
|
||||
static int find_inheritors(Oid relid, Oid **supervec);
|
||||
static CandidateList func_get_candidates(char *funcname, int nargs);
|
||||
static bool func_get_detail(char *funcname,
|
||||
int nargs,
|
||||
Oid *oid_array,
|
||||
Oid *funcid, /* return value */
|
||||
Oid *rettype, /* return value */
|
||||
bool *retset, /* return value */
|
||||
Oid **true_typeids);
|
||||
static Oid * func_select_candidate(int nargs,
|
||||
Oid *input_typeids,
|
||||
CandidateList candidates);
|
||||
static Oid funcid_get_rettype(Oid funcid);
|
||||
static bool
|
||||
func_get_detail(char *funcname,
|
||||
int nargs,
|
||||
Oid *oid_array,
|
||||
Oid *funcid, /* return value */
|
||||
Oid *rettype, /* return value */
|
||||
bool *retset, /* return value */
|
||||
Oid **true_typeids);
|
||||
static Oid *
|
||||
func_select_candidate(int nargs,
|
||||
Oid *input_typeids,
|
||||
CandidateList candidates);
|
||||
static Oid funcid_get_rettype(Oid funcid);
|
||||
static Oid **gen_cross_product(InhPaths *arginh, int nargs);
|
||||
static void make_arguments(int nargs,
|
||||
List *fargs,
|
||||
Oid *input_typeids,
|
||||
Oid *function_typeids);
|
||||
static int match_argtypes(int nargs,
|
||||
Oid *input_typeids,
|
||||
CandidateList function_typeids,
|
||||
CandidateList *candidates);
|
||||
static void
|
||||
make_arguments(int nargs,
|
||||
List *fargs,
|
||||
Oid *input_typeids,
|
||||
Oid *function_typeids);
|
||||
static int
|
||||
match_argtypes(int nargs,
|
||||
Oid *input_typeids,
|
||||
CandidateList function_typeids,
|
||||
CandidateList *candidates);
|
||||
static List *setup_tlist(char *attname, Oid relid);
|
||||
static List *setup_base_tlist(Oid typeid);
|
||||
|
||||
@ -99,9 +104,9 @@ ParseNestedFuncOrColumn(ParseState *pstate, Attr *attr, int *curr_resno, int pre
|
||||
Param *param = (Param *) transformExpr(pstate, (Node *) attr->paramNo, EXPR_RELATION_FIRST);
|
||||
|
||||
retval = ParseFuncOrColumn(pstate, strVal(lfirst(attr->attrs)),
|
||||
lcons(param, NIL),
|
||||
curr_resno,
|
||||
precedence);
|
||||
lcons(param, NIL),
|
||||
curr_resno,
|
||||
precedence);
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -110,18 +115,18 @@ ParseNestedFuncOrColumn(ParseState *pstate, Attr *attr, int *curr_resno, int pre
|
||||
ident->name = attr->relname;
|
||||
ident->isRel = TRUE;
|
||||
retval = ParseFuncOrColumn(pstate, strVal(lfirst(attr->attrs)),
|
||||
lcons(ident, NIL),
|
||||
curr_resno,
|
||||
precedence);
|
||||
lcons(ident, NIL),
|
||||
curr_resno,
|
||||
precedence);
|
||||
}
|
||||
|
||||
/* Do more attributes follow this one? */
|
||||
foreach(mutator_iter, lnext(attr->attrs))
|
||||
{
|
||||
retval = ParseFuncOrColumn(pstate, strVal(lfirst(mutator_iter)),
|
||||
lcons(retval, NIL),
|
||||
curr_resno,
|
||||
precedence);
|
||||
lcons(retval, NIL),
|
||||
curr_resno,
|
||||
precedence);
|
||||
}
|
||||
|
||||
return (retval);
|
||||
@ -132,7 +137,7 @@ ParseNestedFuncOrColumn(ParseState *pstate, Attr *attr, int *curr_resno, int pre
|
||||
*/
|
||||
Node *
|
||||
ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
|
||||
int *curr_resno, int precedence)
|
||||
int *curr_resno, int precedence)
|
||||
{
|
||||
Oid rettype = (Oid) 0;
|
||||
Oid argrelid = (Oid) 0;
|
||||
@ -174,6 +179,7 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
|
||||
{
|
||||
RangeTblEntry *rte;
|
||||
Ident *ident = (Ident *) first_arg;
|
||||
|
||||
/*
|
||||
* first arg is a relation. This could be a projection.
|
||||
*/
|
||||
@ -193,9 +199,9 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
|
||||
if (get_attnum(relid, funcname) != InvalidAttrNumber)
|
||||
{
|
||||
return (Node *) make_var(pstate,
|
||||
relid,
|
||||
refname,
|
||||
funcname);
|
||||
relid,
|
||||
refname,
|
||||
funcname);
|
||||
}
|
||||
else
|
||||
{
|
||||
@ -262,8 +268,8 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
|
||||
PointerGetDatum(funcname),
|
||||
ObjectIdGetDatum(basetype),
|
||||
0, 0))
|
||||
return (Node *)ParseAgg(pstate, funcname, basetype,
|
||||
fargs, precedence);
|
||||
return (Node *) ParseAgg(pstate, funcname, basetype,
|
||||
fargs, precedence);
|
||||
}
|
||||
}
|
||||
|
||||
@ -285,6 +291,7 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
|
||||
|
||||
if (nodeTag(pair) == T_Ident && ((Ident *) pair)->isRel)
|
||||
{
|
||||
|
||||
/*
|
||||
* a relation
|
||||
*/
|
||||
@ -415,15 +422,15 @@ ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
|
||||
char *seqrel;
|
||||
text *seqname;
|
||||
int32 aclcheck_result = -1;
|
||||
extern text *lower (text *string);
|
||||
extern text *lower(text *string);
|
||||
|
||||
Assert(length(fargs) == 1);
|
||||
seq = (Const *) lfirst(fargs);
|
||||
if (!IsA((Node *) seq, Const))
|
||||
elog(ERROR, "%s: only constant sequence names are acceptable", funcname);
|
||||
seqname = lower ((text*)DatumGetPointer(seq->constvalue));
|
||||
pfree (DatumGetPointer(seq->constvalue));
|
||||
seq->constvalue = PointerGetDatum (seqname);
|
||||
seqname = lower((text *) DatumGetPointer(seq->constvalue));
|
||||
pfree(DatumGetPointer(seq->constvalue));
|
||||
seq->constvalue = PointerGetDatum(seqname);
|
||||
seqrel = textout(seqname);
|
||||
|
||||
if ((aclcheck_result = pg_aclcheck(seqrel, GetPgUserName(),
|
||||
@ -827,7 +834,8 @@ argtype_inherit(int nargs, Oid *oid_array)
|
||||
return (gen_cross_product(arginh, nargs));
|
||||
}
|
||||
|
||||
static int find_inheritors(Oid relid, Oid **supervec)
|
||||
static int
|
||||
find_inheritors(Oid relid, Oid **supervec)
|
||||
{
|
||||
Oid *relidvec;
|
||||
Relation inhrel;
|
||||
@ -1065,7 +1073,7 @@ setup_tlist(char *attname, Oid relid)
|
||||
|
||||
typeid = get_atttype(relid, attno);
|
||||
type_mod = get_atttypmod(relid, attno);
|
||||
|
||||
|
||||
resnode = makeResdom(1,
|
||||
typeid,
|
||||
type_mod,
|
||||
@ -1301,9 +1309,12 @@ func_error(char *caller, char *funcname, int nargs, Oid *argtypes)
|
||||
ptr += strlen(ptr);
|
||||
}
|
||||
|
||||
if(caller == NULL) {
|
||||
elog(ERROR, "function %s(%s) does not exist", funcname, p);
|
||||
} else {
|
||||
elog(ERROR, "%s: function %s(%s) does not exist", caller, funcname, p);
|
||||
}
|
||||
if (caller == NULL)
|
||||
{
|
||||
elog(ERROR, "function %s(%s) does not exist", funcname, p);
|
||||
}
|
||||
else
|
||||
{
|
||||
elog(ERROR, "%s: function %s(%s) does not exist", caller, funcname, p);
|
||||
}
|
||||
}
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.13 1998/02/13 19:45:43 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.14 1998/02/26 04:33:32 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -30,7 +30,8 @@
|
||||
#include "utils/lsyscache.h"
|
||||
|
||||
static void disallow_setop(char *op, Type optype, Node *operand);
|
||||
static Node *make_operand(char *opname,
|
||||
static Node *
|
||||
make_operand(char *opname,
|
||||
Node *tree,
|
||||
Oid orig_typeId,
|
||||
Oid true_typeId);
|
||||
@ -52,7 +53,7 @@ make_parsestate(ParseState *parentParseState)
|
||||
|
||||
pstate->p_last_resno = 1;
|
||||
pstate->parentParseState = parentParseState;
|
||||
|
||||
|
||||
return (pstate);
|
||||
}
|
||||
|
||||
@ -125,7 +126,7 @@ disallow_setop(char *op, Type optype, Node *operand)
|
||||
}
|
||||
}
|
||||
|
||||
Expr *
|
||||
Expr *
|
||||
make_op(char *opname, Node *ltree, Node *rtree)
|
||||
{
|
||||
Oid ltypeId,
|
||||
@ -238,9 +239,9 @@ make_op(char *opname, Node *ltree, Node *rtree)
|
||||
return result;
|
||||
}
|
||||
|
||||
Var *
|
||||
Var *
|
||||
make_var(ParseState *pstate, Oid relid, char *refname,
|
||||
char *attrname)
|
||||
char *attrname)
|
||||
{
|
||||
Var *varnode;
|
||||
int vnum,
|
||||
@ -321,6 +322,7 @@ make_array_ref(Node *expr,
|
||||
A_Indices *ind = lfirst(indirection);
|
||||
|
||||
if (ind->lidx)
|
||||
|
||||
/*
|
||||
* XXX assumes all lower indices non null in this case
|
||||
*/
|
||||
@ -426,7 +428,7 @@ make_array_set(Expr *target_expr,
|
||||
*
|
||||
* eventually, produces a "const" lisp-struct as per nodedefs.cl
|
||||
*/
|
||||
Const *
|
||||
Const *
|
||||
make_const(Value *value)
|
||||
{
|
||||
Type tp;
|
||||
@ -454,8 +456,8 @@ make_const(Value *value)
|
||||
break;
|
||||
|
||||
case T_String:
|
||||
tp = typeidType(UNKNOWNOID); /* unknown for now, will be type
|
||||
* coerced */
|
||||
tp = typeidType(UNKNOWNOID); /* unknown for now, will
|
||||
* be type coerced */
|
||||
val = PointerGetDatum(textin(strVal(value)));
|
||||
break;
|
||||
|
||||
@ -481,4 +483,3 @@ make_const(Value *value)
|
||||
|
||||
return (con);
|
||||
}
|
||||
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.8 1998/01/20 05:04:23 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.9 1998/02/26 04:33:33 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -26,21 +26,24 @@
|
||||
#include "storage/bufmgr.h"
|
||||
#include "utils/syscache.h"
|
||||
|
||||
static int binary_oper_get_candidates(char *opname,
|
||||
static int
|
||||
binary_oper_get_candidates(char *opname,
|
||||
Oid leftTypeId,
|
||||
Oid rightTypeId,
|
||||
CandidateList *candidates);
|
||||
static CandidateList binary_oper_select_candidate(Oid arg1,
|
||||
static CandidateList
|
||||
binary_oper_select_candidate(Oid arg1,
|
||||
Oid arg2,
|
||||
CandidateList candidates);
|
||||
static bool equivalentOpersAfterPromotion(CandidateList candidates);
|
||||
static void op_error(char *op, Oid arg1, Oid arg2);
|
||||
static int unary_oper_get_candidates(char *op,
|
||||
static int
|
||||
unary_oper_get_candidates(char *op,
|
||||
Oid typeId,
|
||||
CandidateList *candidates,
|
||||
char rightleft);
|
||||
|
||||
|
||||
|
||||
Oid
|
||||
any_ordering_op(int restype)
|
||||
{
|
||||
@ -577,7 +580,7 @@ op_error(char *op, Oid arg1, Oid arg2)
|
||||
op, typeTypeName(tp1), typeTypeName(tp2));
|
||||
#endif
|
||||
elog(ERROR, "There is no operator '%s' for types '%s' and '%s'"
|
||||
"\n\tYou will either have to retype this query using an explicit cast,"
|
||||
"\n\tor you will have to define the operator using CREATE OPERATOR",
|
||||
op, typeTypeName(tp1), typeTypeName(tp2));
|
||||
"\n\tYou will either have to retype this query using an explicit cast,"
|
||||
"\n\tor you will have to define the operator using CREATE OPERATOR",
|
||||
op, typeTypeName(tp1), typeTypeName(tp2));
|
||||
}
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.10 1998/02/10 04:01:56 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.11 1998/02/26 04:33:34 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -24,7 +24,8 @@
|
||||
#include "utils/builtins.h"
|
||||
#include "utils/lsyscache.h"
|
||||
|
||||
static void checkTargetTypes(ParseState *pstate, char *target_colname,
|
||||
static void
|
||||
checkTargetTypes(ParseState *pstate, char *target_colname,
|
||||
char *refname, char *colname);
|
||||
|
||||
struct
|
||||
@ -76,14 +77,15 @@ refnameRangeTableEntry(ParseState *pstate, char *refname)
|
||||
foreach(temp, pstate->p_rtable)
|
||||
{
|
||||
RangeTblEntry *rte = lfirst(temp);
|
||||
|
||||
|
||||
if (!strcmp(rte->refname, refname))
|
||||
return rte;
|
||||
}
|
||||
/* only allow correlated columns in WHERE clause */
|
||||
if (pstate->p_in_where_clause)
|
||||
pstate = pstate->parentParseState;
|
||||
else break;
|
||||
else
|
||||
break;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
@ -95,7 +97,7 @@ refnameRangeTablePosn(ParseState *pstate, char *refname, int *sublevels_up)
|
||||
int index;
|
||||
List *temp;
|
||||
|
||||
|
||||
|
||||
if (sublevels_up)
|
||||
*sublevels_up = 0;
|
||||
|
||||
@ -105,7 +107,7 @@ refnameRangeTablePosn(ParseState *pstate, char *refname, int *sublevels_up)
|
||||
foreach(temp, pstate->p_rtable)
|
||||
{
|
||||
RangeTblEntry *rte = lfirst(temp);
|
||||
|
||||
|
||||
if (!strcmp(rte->refname, refname))
|
||||
return index;
|
||||
index++;
|
||||
@ -117,7 +119,8 @@ refnameRangeTablePosn(ParseState *pstate, char *refname, int *sublevels_up)
|
||||
if (sublevels_up)
|
||||
(*sublevels_up)++;
|
||||
}
|
||||
else break;
|
||||
else
|
||||
break;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
@ -143,11 +146,11 @@ colnameRangeTableEntry(ParseState *pstate, char *colname)
|
||||
foreach(et, rtable)
|
||||
{
|
||||
RangeTblEntry *rte = lfirst(et);
|
||||
|
||||
|
||||
/* only entries on outer(non-function?) scope */
|
||||
if (!rte->inFromCl && rte != pstate->p_target_rangetblentry)
|
||||
continue;
|
||||
|
||||
|
||||
if (get_attnum(rte->relid, colname) != InvalidAttrNumber)
|
||||
{
|
||||
if (rte_result != NULL)
|
||||
@ -163,7 +166,8 @@ colnameRangeTableEntry(ParseState *pstate, char *colname)
|
||||
/* only allow correlated columns in WHERE clause */
|
||||
if (pstate->p_in_where_clause && rte_result == NULL)
|
||||
pstate = pstate->parentParseState;
|
||||
else break;
|
||||
else
|
||||
break;
|
||||
}
|
||||
return rte_result;
|
||||
}
|
||||
@ -181,31 +185,30 @@ addRangeTableEntry(ParseState *pstate,
|
||||
{
|
||||
Relation relation;
|
||||
RangeTblEntry *rte = makeNode(RangeTblEntry);
|
||||
int sublevels_up;
|
||||
int sublevels_up;
|
||||
|
||||
if (pstate != NULL)
|
||||
{
|
||||
if (refnameRangeTablePosn(pstate, refname, &sublevels_up) != 0 &&
|
||||
(!inFromCl || sublevels_up == 0))
|
||||
(!inFromCl || sublevels_up == 0))
|
||||
elog(ERROR, "Table name %s specified more than once", refname);
|
||||
}
|
||||
|
||||
|
||||
rte->relname = pstrdup(relname);
|
||||
rte->refname = pstrdup(refname);
|
||||
|
||||
relation = heap_openr(relname);
|
||||
if (relation == NULL)
|
||||
elog(ERROR, "%s: %s",
|
||||
relname, aclcheck_error_strings[ACLCHECK_NO_CLASS]);
|
||||
relname, aclcheck_error_strings[ACLCHECK_NO_CLASS]);
|
||||
|
||||
rte->relid = RelationGetRelationId(relation);
|
||||
|
||||
heap_close(relation);
|
||||
|
||||
/*
|
||||
* Flags - zero or more from inheritance,union,version or
|
||||
* recursive (transitive closure) [we don't support them all -- ay
|
||||
* 9/94 ]
|
||||
* Flags - zero or more from inheritance,union,version or recursive
|
||||
* (transitive closure) [we don't support them all -- ay 9/94 ]
|
||||
*/
|
||||
rte->inh = inh;
|
||||
|
||||
@ -225,7 +228,7 @@ addRangeTableEntry(ParseState *pstate,
|
||||
* expandAll -
|
||||
* makes a list of attributes
|
||||
*/
|
||||
List *
|
||||
List *
|
||||
expandAll(ParseState *pstate, char *relname, char *refname, int *this_resno)
|
||||
{
|
||||
Relation rdesc;
|
||||
@ -308,7 +311,7 @@ attnameAttNum(Relation rd, char *a)
|
||||
/* on failure */
|
||||
elog(ERROR, "Relation %s does not have attribute %s",
|
||||
RelationGetRelationName(rd), a);
|
||||
return 0; /* lint */
|
||||
return 0; /* lint */
|
||||
}
|
||||
|
||||
/*
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.10 1998/02/13 19:45:44 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.11 1998/02/26 04:33:35 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -29,7 +29,8 @@
|
||||
|
||||
static List *expandAllTables(ParseState *pstate);
|
||||
static char *figureColname(Node *expr, Node *resval);
|
||||
static TargetEntry *make_targetlist_expr(ParseState *pstate,
|
||||
static TargetEntry *
|
||||
make_targetlist_expr(ParseState *pstate,
|
||||
char *colname,
|
||||
Node *expr,
|
||||
List *arrayRef);
|
||||
@ -63,13 +64,14 @@ transformTargetList(ParseState *pstate, List *targetlist)
|
||||
handleTargetColname(pstate, &res->name, NULL, identname);
|
||||
|
||||
/*
|
||||
* here we want to look for column names only, not relation
|
||||
* names (even though they can be stored in Ident nodes, too)
|
||||
* here we want to look for column names only, not
|
||||
* relation names (even though they can be stored in
|
||||
* Ident nodes, too)
|
||||
*/
|
||||
expr = transformIdent(pstate, (Node *) res->val, EXPR_COLUMN_FIRST);
|
||||
type_id = exprType(expr);
|
||||
if (nodeTag(expr) == T_Var)
|
||||
type_mod = ((Var *)expr)->vartypmod;
|
||||
type_mod = ((Var *) expr)->vartypmod;
|
||||
else
|
||||
type_mod = -1;
|
||||
resname = (res->name) ? res->name : identname;
|
||||
@ -257,9 +259,10 @@ transformTargetList(ParseState *pstate, List *targetlist)
|
||||
|
||||
|
||||
/*
|
||||
* Target item is fully specified: ie. relation.attribute
|
||||
* Target item is fully specified: ie.
|
||||
* relation.attribute
|
||||
*/
|
||||
result = ParseNestedFuncOrColumn(pstate, att, &pstate->p_last_resno,EXPR_COLUMN_FIRST);
|
||||
result = ParseNestedFuncOrColumn(pstate, att, &pstate->p_last_resno, EXPR_COLUMN_FIRST);
|
||||
handleTargetColname(pstate, &res->name, att->relname, attrname);
|
||||
if (att->indirection != NIL)
|
||||
{
|
||||
@ -277,7 +280,7 @@ transformTargetList(ParseState *pstate, List *targetlist)
|
||||
}
|
||||
type_id = exprType(result);
|
||||
if (nodeTag(result) == T_Var)
|
||||
type_mod = ((Var *)result)->vartypmod;
|
||||
type_mod = ((Var *) result)->vartypmod;
|
||||
else
|
||||
type_mod = -1;
|
||||
/* move to last entry */
|
||||
@ -345,7 +348,7 @@ make_targetlist_expr(ParseState *pstate,
|
||||
|
||||
type_id = exprType(expr);
|
||||
if (nodeTag(expr) == T_Var)
|
||||
type_mod = ((Var *)expr)->vartypmod;
|
||||
type_mod = ((Var *) expr)->vartypmod;
|
||||
else
|
||||
type_mod = -1;
|
||||
|
||||
@ -395,7 +398,7 @@ make_targetlist_expr(ParseState *pstate,
|
||||
makeConst(attrtype,
|
||||
attrlen,
|
||||
(Datum) fmgr(typeidInfunc(attrtype),
|
||||
val, typeidTypElem(attrtype), -1),
|
||||
val, typeidTypElem(attrtype), -1),
|
||||
false,
|
||||
true /* Maybe correct-- 80% chance */ ,
|
||||
false, /* is not a set */
|
||||
@ -464,8 +467,8 @@ make_targetlist_expr(ParseState *pstate,
|
||||
att->relname = pstrdup(RelationGetRelationName(rd)->data);
|
||||
att->attrs = lcons(makeString(colname), NIL);
|
||||
target_expr = (Expr *) ParseNestedFuncOrColumn(pstate, att,
|
||||
&pstate->p_last_resno,
|
||||
EXPR_COLUMN_FIRST);
|
||||
&pstate->p_last_resno,
|
||||
EXPR_COLUMN_FIRST);
|
||||
while (ar != NIL)
|
||||
{
|
||||
A_Indices *ind = lfirst(ar);
|
||||
@ -556,15 +559,15 @@ makeTargetNames(ParseState *pstate, List *cols)
|
||||
{
|
||||
List *nxt;
|
||||
char *name = ((Ident *) lfirst(tl))->name;
|
||||
|
||||
|
||||
/* elog on failure */
|
||||
attnameAttNum(pstate->p_target_relation, name);
|
||||
foreach(nxt, lnext(tl))
|
||||
if (!strcmp(name, ((Ident *) lfirst(nxt))->name))
|
||||
elog(ERROR, "Attribute '%s' should be specified only once", name);
|
||||
elog(ERROR, "Attribute '%s' should be specified only once", name);
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
return cols;
|
||||
}
|
||||
|
||||
@ -643,8 +646,8 @@ figureColname(Node *expr, Node *resval)
|
||||
{
|
||||
switch (nodeTag(expr))
|
||||
{
|
||||
case T_Aggreg:
|
||||
return (char *) ((Aggreg *) expr)->aggname;
|
||||
case T_Aggreg:
|
||||
return (char *) ((Aggreg *) expr)->aggname;
|
||||
case T_Expr:
|
||||
if (((Expr *) expr)->opType == FUNC_EXPR)
|
||||
{
|
||||
|
||||
@ -7,7 +7,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.6 1998/02/13 19:45:45 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parse_type.c,v 1.7 1998/02/26 04:33:36 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -35,7 +35,7 @@ typeidIsValid(Oid id)
|
||||
}
|
||||
|
||||
/* return a type name, given a typeid */
|
||||
char *
|
||||
char *
|
||||
typeidTypeName(Oid id)
|
||||
{
|
||||
HeapTuple tup;
|
||||
@ -114,7 +114,7 @@ typeByVal(Type t)
|
||||
}
|
||||
|
||||
/* given type (as type struct), return the name of type */
|
||||
char *
|
||||
char *
|
||||
typeTypeName(Type t)
|
||||
{
|
||||
TypeTupleForm typ;
|
||||
@ -142,7 +142,8 @@ stringTypeString(Type tp, char *string, int16 atttypmod)
|
||||
Oid typelem;
|
||||
|
||||
op = ((TypeTupleForm) GETSTRUCT(tp))->typinput;
|
||||
typelem = ((TypeTupleForm) GETSTRUCT(tp))->typelem; /* XXX - used for array_in */
|
||||
typelem = ((TypeTupleForm) GETSTRUCT(tp))->typelem; /* XXX - used for
|
||||
* array_in */
|
||||
return ((char *) fmgr(op, string, typelem, atttypmod));
|
||||
}
|
||||
|
||||
|
||||
@ -6,7 +6,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parser.c,v 1.32 1998/01/19 05:06:20 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/parser.c,v 1.33 1998/02/26 04:33:37 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -58,7 +58,7 @@ parser(char *str, Oid *typev, int nargs)
|
||||
|
||||
clearerr(stdin);
|
||||
|
||||
if (yyresult) /* error */
|
||||
if (yyresult) /* error */
|
||||
return ((QueryTreeList *) NULL);
|
||||
|
||||
queryList = parse_analyze(parsetree, NULL);
|
||||
@ -175,5 +175,5 @@ define_sets(Node *clause)
|
||||
define_sets(get_rightop(clause));
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
@ -8,7 +8,7 @@
|
||||
*
|
||||
*
|
||||
* IDENTIFICATION
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/scansup.c,v 1.9 1997/11/26 01:11:40 momjian Exp $
|
||||
* $Header: /cvsroot/pgsql/src/backend/parser/scansup.c,v 1.10 1998/02/26 04:33:49 momjian Exp $
|
||||
*
|
||||
*-------------------------------------------------------------------------
|
||||
*/
|
||||
@ -38,7 +38,7 @@
|
||||
* ----------------
|
||||
*/
|
||||
|
||||
char *
|
||||
char *
|
||||
scanstr(char *s)
|
||||
{
|
||||
static char newStr[MAX_PARSE_BUFFER];
|
||||
|
||||
Reference in New Issue
Block a user