Add lock to i386 asm.
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.25 1998/01/19 02:37:33 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/execUtils.c,v 1.26 1998/01/20 05:03:30 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "optimizer/clauses.h"
#include "utils/palloc.h"
#include "utils/mcxt.h"
+#include "utils/lsyscache.h"
#include "commands/command.h"
#include "catalog/index.h"
#include "catalog/catname.h"
{
Var *var;
RangeTblEntry *rtentry;
- Relation rd;
var = (Var *) expr;
rtentry = rt_fetch(var->varnoold, rangeTable);
- rd = heap_open(rtentry->relid);
- /* set length to that defined in relation */
tupType->attrs[varno]->atttypmod =
- (*rd->rd_att->attrs[var->varoattno - 1]).atttypmod;
- heap_close(rd);
+ get_atttypmod(rtentry->relid, var->varoattno);
}
else
elog(ERROR, "setAtttypmodForCreateTable: can't get atttypmod for field (for length, etc.)");
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.33 1998/01/19 18:10:48 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.34 1998/01/20 05:03:40 momjian Exp $
*
*-------------------------------------------------------------------------
*/
newnode->subLinkType = from->subLinkType;
newnode->useor = from->useor;
Node_Copy(from, newnode, lefthand);
- newnode->oper = listCopy(from->oper);
+ Node_Copy(from, newnode, oper);
Node_Copy(from, newnode, subselect);
return newnode;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.24 1998/01/19 18:10:50 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/outfuncs.c,v 1.25 1998/01/20 05:03:49 momjian Exp $
*
* NOTES
* Every (plan) node in POSTGRES has an associated "out" routine which
appendStringInfo(str, " :lefthand ");
_outNode(str, node->lefthand);
appendStringInfo(str, " :oper ");
- _outIntList(str, node->oper);
+ _outNode(str, node->oper);
appendStringInfo(str, " :subselect ");
_outNode(str, node->subselect);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/print.c,v 1.13 1998/01/07 15:32:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/print.c,v 1.14 1998/01/20 05:03:54 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
break;
default:
{
- Relation r;
-
rt = rt_fetch(var->varno, rtable);
relname = rt->relname;
- r = heap_openr(relname);
if (rt->refname)
relname = rt->refname; /* table renamed */
- attname = attnumAttName(r, var->varattno);
- heap_close(r);
+ attname = get_attname(rt->relid, var->varattno);
}
break;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.20 1998/01/19 18:10:52 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.21 1998/01/20 05:03:57 momjian Exp $
*
* NOTES
* Most of the read functions for plan nodes are tested. (In fact, they
local_node->lefthand = nodeRead(true); /* now read it */
token = lsptok(NULL, &length); /* eat :oper */
- local_node->oper = toIntList(nodeRead(true)); /* now read it */
+ local_node->oper = nodeRead(true); /* now read it */
token = lsptok(NULL, &length); /* eat :subselect */
local_node->subselect = nodeRead(true); /* now read it */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.66 1998/01/19 05:06:13 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/analyze.c,v 1.67 1998/01/20 05:04:05 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{
pstate = make_parsestate(parentParseState);
result->qtrees[i++] = transformStmt(pstate, lfirst(pl));
+ if (pstate->p_target_relation != NULL)
+ heap_close(pstate->p_target_relation);
+
if (extras != NIL)
{
result->len += length(extras);
while (extras != NIL)
{
result->qtrees[i++] = transformStmt(pstate, lfirst(extras));
+ if (pstate->p_target_relation != NULL)
+ heap_close(pstate->p_target_relation);
extras = lnext(extras);
}
}
extras = NIL;
pl = lnext(pl);
- if (pstate->p_target_relation != NULL)
- heap_close(pstate->p_target_relation);
pfree(pstate);
}
switch (nodeTag(parseTree))
{
- /*------------------------
- * Non-optimizable statements
- *------------------------
- */
+ /*------------------------
+ * Non-optimizable statements
+ *------------------------
+ */
case T_CreateStmt:
result = transformCreateStmt(pstate, (CreateStmt *) parseTree);
break;
}
break;
- /*------------------------
- * Optimizable statements
- *------------------------
- */
+ /*------------------------
+ * Optimizable statements
+ *------------------------
+ */
case T_InsertStmt:
result = transformInsertStmt(pstate, (InsertStmt *) parseTree);
break;
/*
* other statments don't require any transformation-- just
- * return the original parsetree
+ * return the original parsetree, yea!
*/
result = makeNode(Query);
result->commandType = CMD_UTILITY;
qry->rtable = pstate->p_rtable;
qry->resultRelation = refnameRangeTablePosn(pstate->p_rtable, stmt->relname);
- /* make sure we don't have aggregates in the where clause */
+ qry->hasAggs = pstate->p_hasAggs;
if (pstate->p_hasAggs)
parseCheckAggregates(pstate, qry);
int ndef = pstate->p_target_relation->rd_att->constr->num_defval;
/*
- * if stmt->cols == NIL then makeTargetNames returns list of all
+ * if stmt->cols == NIL then makeTargetNames returns list of all
* attrs: have to shorter icolumns list...
*/
if (stmt->cols == NIL)
/* fix where clause */
qry->qual = transformWhereClause(pstate, stmt->whereClause);
- /* check having clause */
- if (stmt->havingClause)
- elog(NOTICE, "HAVING not yet supported; ignore clause", NULL);
-
/* now the range table will not change */
qry->rtable = pstate->p_rtable;
qry->resultRelation = refnameRangeTablePosn(pstate->p_rtable, stmt->relname);
qry->targetList,
qry->uniqueFlag);
+ qry->hasAggs = pstate->p_hasAggs;
if (pstate->p_hasAggs)
- finalizeAggregates(pstate, qry);
+ parseCheckAggregates(pstate, qry);
+ /* The INSERT INTO ... SELECT ... could have a UNION */
qry->unionall = stmt->unionall; /* in child, so unionClause may be false */
qry->unionClause = transformUnionClause(stmt->unionClause, qry->targetList);
return (Query *) qry;
}
-/* makeTableName()
- * Create a table name from a list of fields.
+/*
+ * makeTableName()
+ * Create a table name from a list of fields.
*/
-static char *
-makeTableName(void *elem,...);
-
static char *
makeTableName(void *elem,...)
{
char *name;
char buf[NAMEDATALEN+1];
- strcpy(buf,"");
+ buf[0] = '\0';
va_start(args,elem);
if ((strlen(buf)+strlen(name)) >= (sizeof(buf)-1))
return (NULL);
- if (strlen(buf) > 0) strcat(buf,"_");
+ if (strlen(buf) > 0)
+ strcat(buf,"_");
strcat(buf,name);
name = va_arg(args,void *);
strcpy(name,buf);
return (name);
-} /* makeTableName() */
-
-char *
-CreateIndexName(char *tname, char *cname, char *label, List *indices);
+}
-char *
+static char *
CreateIndexName(char *tname, char *cname, char *label, List *indices)
{
int pass = 0;
if (iname == NULL)
break;
-#if PARSEDEBUG
-printf("CreateNameIndex- check %s against indices\n",iname);
-#endif
-
ilist = indices;
while (ilist != NIL)
{
index = lfirst(ilist);
-#if PARSEDEBUG
-printf("CreateNameIndex- compare %s with existing index %s\n",iname,index->idxname);
-#endif
if (strcasecmp(iname,index->idxname) == 0)
break;
}
return (iname);
-} /* CreateIndexName() */
+}
/*
* transformCreateStmt -
{
case T_ColumnDef:
column = (ColumnDef *) element;
-#if PARSEDEBUG
-printf("transformCreateStmt- found column %s\n",column->colname);
-#endif
columns = lappend(columns,column);
if (column->constraints != NIL)
{
-#if PARSEDEBUG
-printf("transformCreateStmt- found constraint(s) on column %s\n",column->colname);
-#endif
clist = column->constraints;
while (clist != NIL)
{
switch (constraint->contype)
{
case CONSTR_NOTNULL:
-#if PARSEDEBUG
-printf("transformCreateStmt- found NOT NULL constraint on column %s\n",column->colname);
-#endif
if (column->is_not_null)
elog(ERROR,"CREATE TABLE/NOT NULL already specified"
" for %s.%s", stmt->relname, column->colname);
break;
case CONSTR_DEFAULT:
-#if PARSEDEBUG
-printf("transformCreateStmt- found DEFAULT clause on column %s\n",column->colname);
-#endif
if (column->defval != NULL)
elog(ERROR,"CREATE TABLE/DEFAULT multiple values specified"
" for %s.%s", stmt->relname, column->colname);
break;
case CONSTR_PRIMARY:
-#if PARSEDEBUG
-printf("transformCreateStmt- found PRIMARY KEY clause on column %s\n",column->colname);
-#endif
if (constraint->name == NULL)
constraint->name = makeTableName(stmt->relname, "pkey", NULL);
if (constraint->keys == NIL)
break;
case CONSTR_UNIQUE:
-#if PARSEDEBUG
-printf("transformCreateStmt- found UNIQUE clause on column %s\n",column->colname);
-#endif
if (constraint->name == NULL)
constraint->name = makeTableName(stmt->relname, column->colname, "key", NULL);
if (constraint->keys == NIL)
break;
case CONSTR_CHECK:
-#if PARSEDEBUG
-printf("transformCreateStmt- found CHECK clause on column %s\n",column->colname);
-#endif
constraints = lappend(constraints, constraint);
if (constraint->name == NULL)
constraint->name = makeTableName(stmt->relname, column->colname, NULL);
case T_Constraint:
constraint = (Constraint *) element;
-#if PARSEDEBUG
-printf("transformCreateStmt- found constraint %s\n", ((constraint->name != NULL)? constraint->name: "(unknown)"));
-#endif
switch (constraint->contype)
{
case CONSTR_PRIMARY:
-#if PARSEDEBUG
-printf("transformCreateStmt- found PRIMARY KEY clause\n");
-#endif
if (constraint->name == NULL)
constraint->name = makeTableName(stmt->relname, "pkey", NULL);
dlist = lappend(dlist, constraint);
break;
case CONSTR_UNIQUE:
-#if PARSEDEBUG
-printf("transformCreateStmt- found UNIQUE clause\n");
-#endif
#if FALSE
if (constraint->name == NULL)
constraint->name = makeTableName(stmt->relname, "key", NULL);
break;
case CONSTR_CHECK:
-#if PARSEDEBUG
-printf("transformCreateStmt- found CHECK clause\n");
-#endif
constraints = lappend(constraints, constraint);
break;
if (nodeTag(constraint) != T_Constraint)
elog(ERROR,"parser: internal error; unrecognized deferred node",NULL);
-#if PARSEDEBUG
-printf("transformCreateStmt- found deferred constraint %s\n",
- ((constraint->name != NULL)? constraint->name: "(unknown)"));
-#endif
-
if (constraint->contype == CONSTR_PRIMARY)
if (have_pkey)
elog(ERROR,"CREATE TABLE/PRIMARY KEY multiple primary keys"
else if (constraint->contype != CONSTR_UNIQUE)
elog(ERROR,"parser: internal error; unrecognized deferred constraint",NULL);
-#if PARSEDEBUG
-printf("transformCreateStmt- found deferred %s clause\n",
- (constraint->contype == CONSTR_PRIMARY? "PRIMARY KEY": "UNIQUE"));
-#endif
-
index = makeNode(IndexStmt);
index->unique = TRUE;
while (keys != NIL)
{
key = lfirst(keys);
-#if PARSEDEBUG
-printf("transformCreateStmt- check key %s for column match\n", key->name);
-#endif
columns = stmt->tableElts;
column = NULL;
while (columns != NIL)
{
column = lfirst(columns);
-#if PARSEDEBUG
-printf("transformCreateStmt- check column %s for key match\n", column->colname);
-#endif
if (strcasecmp(column->colname,key->name) == 0) break;
else column = NULL;
columns = lnext(columns);
elog(ERROR,"parser: column '%s' in key does not exist",key->name);
if (constraint->contype == CONSTR_PRIMARY)
- {
-#if PARSEDEBUG
-printf("transformCreateStmt- mark column %s as NOT NULL\n", column->colname);
-#endif
column->is_not_null = TRUE;
- }
iparam = makeNode(IndexElem);
iparam->name = strcpy(palloc(strlen(column->colname)+1), column->colname);
iparam->args = NIL;
extras = ilist;
return q;
-} /* transformCreateStmt() */
+}
/*
* transformIndexStmt -
qry->into = stmt->into;
qry->isPortal = FALSE;
- /* fix the target list */
qry->targetList = transformTargetList(pstate, stmt->targetList);
- /* fix where clause */
qry->qual = transformWhereClause(pstate, stmt->whereClause);
- /* check having clause */
- if (stmt->havingClause)
- elog(NOTICE, "HAVING not yet supported; ignore clause", NULL);
-
- /* fix order clause */
qry->sortClause = transformSortClause(pstate,
stmt->sortClause,
NIL,
qry->targetList);
qry->rtable = pstate->p_rtable;
+ qry->hasAggs = pstate->p_hasAggs;
if (pstate->p_hasAggs)
- finalizeAggregates(pstate, qry);
+ parseCheckAggregates(pstate, qry);
qry->unionall = stmt->unionall; /* in child, so unionClause may be false */
qry->unionClause = transformUnionClause(stmt->unionClause, qry->targetList);
*/
makeRangeTable(pstate, stmt->relname, stmt->fromClause);
- /* fix the target list */
qry->targetList = transformTargetList(pstate, stmt->targetList);
- /* fix where clause */
qry->qual = transformWhereClause(pstate, stmt->whereClause);
qry->rtable = pstate->p_rtable;
- qry->resultRelation = refnameRangeTablePosn(pstate->p_rtable, stmt->relname);
- if (pstate->p_hasAggs)
- finalizeAggregates(pstate, qry);
+ qry->resultRelation = refnameRangeTablePosn(pstate->p_rtable, stmt->relname);
- /* make sure we don't have aggregates in the where clause */
+ qry->hasAggs = pstate->p_hasAggs;
if (pstate->p_hasAggs)
parseCheckAggregates(pstate, qry);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 1.94 1998/01/19 05:06:15 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/gram.y,v 1.95 1998/01/20 05:04:07 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
INDEX, INHERITS, INSTEAD, ISNULL,
LANCOMPILER, LISTEN, LOAD, LOCATION, MERGE, MOVE,
NEW, NONE, NOTHING, NOTNULL, OIDS, OPERATOR, PROCEDURAL,
- RECIPE, RENAME, REPLACE, RESET, RETRIEVE, RETURNS, RULE,
+ RECIPE, RENAME, REPLACE, RESET, RETURNS, RULE,
SEQUENCE, SETOF, SHOW, STDIN, STDOUT, TRUSTED,
VACUUM, VERBOSE, VERSION
}
;
-having_clause: HAVING a_expr { $$ = $2; }
+having_clause: HAVING a_expr
+ {
+ elog(NOTICE, "HAVING not yet supported; ignore clause");
+ $$ = $2;
+ }
| /*EMPTY*/ { $$ = NULL; }
;
/*
** target list for select.
-** should get rid of the other but is still needed by the defunct retrieve into
+** should get rid of the other but is still needed by the defunct select into
** and update (uses a subset)
*/
res_target_list2: res_target_list2 ',' res_target_el2
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/keywords.c,v 1.30 1998/01/19 05:06:16 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/keywords.c,v 1.31 1998/01/20 05:04:09 momjian Exp $
*
*-------------------------------------------------------------------------
*/
{"rename", RENAME},
{"replace", REPLACE},
{"reset", RESET},
- {"retrieve", RETRIEVE},
{"returns", RETURNS},
{"revoke", REVOKE},
{"right", RIGHT},
return (NULL);
}
-
-#ifdef NOT_USED
-char *
-AtomValueGetString(int atomval)
-{
- ScanKeyword *low = &ScanKeywords[0];
- ScanKeyword *high = endof(ScanKeywords) - 1;
- int keyword_list_length = (high - low);
- int i;
-
- for (i = 0; i < keyword_list_length; i++)
- if (ScanKeywords[i].value == atomval)
- return (ScanKeywords[i].name);
-
- elog(ERROR, "AtomGetString called with bogus atom # : %d", atomval);
- return (NULL);
-}
-
-#endif
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_agg.c,v 1.7 1998/01/15 18:59:59 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_agg.c,v 1.8 1998/01/20 05:04:11 momjian Exp $
*
*-------------------------------------------------------------------------
*/
static bool exprIsAggOrGroupCol(Node *expr, List *groupClause);
static bool tleIsAggOrGroupCol(TargetEntry *tle, List *groupClause);
-/*
- * finalizeAggregates -
- * fill in hasAggs from pstate. Also checks to make sure that aggregates
- * are used in the proper place.
- */
-void
-finalizeAggregates(ParseState *pstate, Query *qry)
-{
- parseCheckAggregates(pstate, qry);
-
- qry->hasAggs = pstate->p_hasAggs;
-}
-
/*
* contain_agg_clause--
* Recursively find aggreg nodes from a clause.
ObjectIdGetDatum(basetype),
0, 0);
if (!HeapTupleIsValid(theAggTuple))
- {
elog(ERROR, "aggregate %s does not exist", aggname);
- }
/*
* We do a major hack for count(*) here.
* 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
+ */
if (nodeTag(lfirst(target)) == T_Const)
{
if (con->consttype == UNKNOWNOID && VARSIZE(con->constvalue) == VARHDRSZ)
{
- Attr *attr = makeNode(Attr);
+ Attr *attr = makeNode(Attr);
List *rtable, *rlist;
RangeTblEntry *first_valid_rte;
if (!rte->inFromCl && rte != pstate->p_target_rangetblentry)
continue;
- first_valid_rte =rte;
+ first_valid_rte = rte;
break;
}
if (first_valid_rte == NULL)
fintype = aggform->aggfinaltype;
xfn1 = aggform->aggtransfn1;
-
/* only aggregates with transfn1 need a base type */
if (OidIsValid(xfn1))
{
typeidTypeName(basetypeID));
}
}
-
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.9 1998/01/19 05:06:17 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.10 1998/01/20 05:04:12 momjian Exp $
*
*-------------------------------------------------------------------------
*/
pstate->p_target_rangetblentry = rte;
Assert(pstate->p_target_relation == NULL);
pstate->p_target_relation = heap_open(rte->relid);
- Assert(pstate->p_target_relation != NULL);
/* will close relation later */
}
Node *qual;
if (a_expr == NULL)
- return (Node *) NULL; /* no qualifiers */
+ return NULL; /* no qualifiers */
pstate->p_in_where_clause = true;
qual = transformExpr(pstate, a_expr, EXPR_COLUMN_FIRST);
pstate->p_in_where_clause = false;
+
if (exprType(qual) != BOOLOID)
{
elog(ERROR,
* range table. The range table may grow as we transform the expressions
* in the target list. (Note that this happens because in POSTQUEL, we
* allow references to relations not specified in the from-clause. We
- * also allow that in our POST-SQL)
+ * also allow now as an extension.)
*
*/
static void
char *resname = resnode->resname;
int test_rtable_pos = var->varno;
-#ifdef PARSEDEBUG
- printf("find_targetlist_entry- target name is %s, position %d, resno %d\n",
- (sortgroupby->name ? sortgroupby->name : "(null)"), target_pos + 1, sortgroupby->resno);
-#endif
-
if (!sortgroupby->name)
{
if (sortgroupby->resno == ++target_pos)
break;
}
if (i == NIL)
- {
elog(ERROR, "The field specified in the UNIQUE ON clause is not in the targetlist");
- }
- s = sortlist;
+
foreach(s, sortlist)
{
SortClause *sortcl = lfirst(s);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.10 1998/01/19 18:10:56 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.11 1998/01/20 05:04:14 momjian Exp $
*
*-------------------------------------------------------------------------
*/
Attr *att = (Attr *) expr;
Node *temp;
- /* what if att.attrs == "*"?? */
- temp = handleNestedDots(pstate, att, &pstate->p_last_resno,
+ /* what if att.attrs == "*"? */
+ temp = ParseNestedFuncOrColumn(pstate, att, &pstate->p_last_resno,
precedence);
if (att->indirection != NIL)
{
if (exprType(lexpr) != INT4OID)
elog(ERROR, "array index expressions must be int4's");
}
-#if 0
- pfree(ai->uidx);
- if (ai->lidx != NULL)
- pfree(ai->lidx);
-#endif
ai->lidx = lexpr;
ai->uidx = uexpr;
Value *val = &con->val;
if (con->typename != NULL)
- {
- result = parser_typecast(val, con->typename, -1);
- }
+ result = parser_typecast(val, con->typename, 0);
else
- {
result = (Node *) make_const(val);
- }
break;
}
case T_ParamNo:
paramno = pno->number;
toid = param_type(paramno);
if (!OidIsValid(toid))
- {
elog(ERROR, "Parameter '$%d' is out of range", paramno);
- }
param = makeNode(Param);
param->paramkind = PARAM_NUM;
param->paramid = (AttrNumber) paramno;
{
Node *lexpr = transformExpr(pstate, a->lexpr, precedence);
- result = ParseFunc(pstate,
+ result = ParseFuncOrColumn(pstate,
"nullvalue", lcons(lexpr, NIL),
&pstate->p_last_resno,
precedence);
{
Node *lexpr = transformExpr(pstate, a->lexpr, precedence);
- result = ParseFunc(pstate,
+ result = ParseFuncOrColumn(pstate,
"nonnullvalue", lcons(lexpr, NIL),
&pstate->p_last_resno,
precedence);
}
case T_Ident:
{
-
/*
* look for a column name or a relation name (the default
* behavior)
/* transform the list of arguments */
foreach(args, fn->args)
lfirst(args) = transformExpr(pstate, (Node *) lfirst(args), precedence);
- result = ParseFunc(pstate,
+ result = ParseFuncOrColumn(pstate,
fn->funcname, fn->args, &pstate->p_last_resno,
precedence);
break;
{
char *op = lfirst(sublink->oper);
List *left_expr = sublink->lefthand;
- List *right_expr = subselect->targetList;
- List *elist;
-
+ List *right_expr = subselect->targetList;
+ List *elist;
+
sublink->oper = NIL;
- foreach(elist, left_expr)
- {
+ foreach(elist, left_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);
- sublink->oper = lappendi(sublink->oper,
- ((Oper *)op_expr->oper)->opno);
- right_expr = lnext(right_expr);
- }
+ Node *rexpr = lfirst(right_expr);
+ TargetEntry *tent = (TargetEntry *)rexpr;
+ Expr *op_expr;
+
+ op_expr = make_op(op, lexpr, tent->expr);
+ sublink->oper = lappend(sublink->oper, op_expr->oper);
+ right_expr = lnext(right_expr);
+ }
result = (Node *) expr;
}
break;
att->relname = rte->refname;
att->attrs = lcons(makeString(ident->name), NIL);
column_result =
- (Node *) handleNestedDots(pstate, att, &pstate->p_last_resno,
+ (Node *) ParseNestedFuncOrColumn(pstate, att, &pstate->p_last_resno,
precedence);
}
return type;
}
-/*
- ** HandleNestedDots --
- ** Given a nested dot expression (i.e. (relation func ... attr), build up
- ** a tree with of Iter and Func nodes.
- */
-Node *
-handleNestedDots(ParseState *pstate, Attr *attr, int *curr_resno, int precedence)
-{
- List *mutator_iter;
- Node *retval = NULL;
-
- if (attr->paramNo != NULL)
- {
- Param *param = (Param *) transformExpr(pstate, (Node *) attr->paramNo, EXPR_RELATION_FIRST);
-
- retval =
- ParseFunc(pstate, strVal(lfirst(attr->attrs)),
- lcons(param, NIL),
- curr_resno,
- precedence);
- }
- else
- {
- Ident *ident = makeNode(Ident);
-
- ident->name = attr->relname;
- ident->isRel = TRUE;
- retval =
- ParseFunc(pstate, strVal(lfirst(attr->attrs)),
- lcons(ident, NIL),
- curr_resno,
- precedence);
- }
-
- foreach(mutator_iter, lnext(attr->attrs))
- {
- retval = ParseFunc(pstate, strVal(lfirst(mutator_iter)),
- lcons(retval, NIL),
- curr_resno,
- precedence);
- }
-
- return (retval);
-}
-
static Node *
parser_typecast(Value *expr, TypeName *typename, int atttypmod)
{
len = typeLen(tp);
-#if 0 /* fix me */
- switch (CInteger(lfirst(expr)))
- {
- case INT4OID: /* int4 */
- const_string = (char *) palloc(256);
- string_palloced = true;
- sprintf(const_string, "%d", ((Const *) lnext(expr))->constvalue);
- break;
-
- case NAMEOID: /* char16 */
- const_string = (char *) palloc(256);
- string_palloced = true;
- sprintf(const_string, "%s", ((Const *) lnext(expr))->constvalue);
- break;
-
- case CHAROID: /* char */
- const_string = (char *) palloc(256);
- string_palloced = true;
- sprintf(const_string, "%c", ((Const) lnext(expr))->constvalue);
- break;
-
- case FLOAT8OID: /* float8 */
- const_string = (char *) palloc(256);
- string_palloced = true;
- sprintf(const_string, "%f", ((Const) lnext(expr))->constvalue);
- break;
-
- case CASHOID: /* money */
- const_string = (char *) palloc(256);
- string_palloced = true;
- sprintf(const_string, "%d",
- (int) ((Const *) expr)->constvalue);
- break;
-
- case TEXTOID: /* text */
- const_string = DatumGetPointer(((Const) lnext(expr))->constvalue);
- const_string = (char *) textout((struct varlena *) const_string);
- break;
-
- case UNKNOWNOID: /* unknown */
- const_string = DatumGetPointer(((Const) lnext(expr))->constvalue);
- const_string = (char *) textout((struct varlena *) const_string);
- break;
-
- default:
- elog(ERROR, "unknown type %d", CInteger(lfirst(expr)));
- }
-#endif
-
cp = stringTypeString(tp, const_string, atttypmod);
if (!typeByVal(tp))
- {
-/*
- if (len >= 0 && len != PSIZE(cp)) {
- char *pp;
- pp = (char *) palloc(len);
- memmove(pp, cp, len);
- cp = pp;
- }
-*/
lcp = PointerGetDatum(cp);
- }
else
{
switch (len)
cp = stringTypeString(tp, const_string, atttypmod);
if (!typeByVal(tp))
- {
-/*
- if (len >= 0 && len != PSIZE(cp)) {
- char *pp;
- pp = (char *) palloc(len);
- memmove(pp, cp, len);
- cp = pp;
- }
-*/
lcp = PointerGetDatum(cp);
- }
else
{
switch (len)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.6 1998/01/15 19:00:02 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_func.c,v 1.7 1998/01/20 05:04:16 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "parser/parse_func.h"
#include "parser/parse_node.h"
#include "parser/parse_relation.h"
+#include "parser/parse_target.h"
#include "parser/parse_type.h"
#include "storage/bufmgr.h"
#include "storage/lmgr.h"
} SuperQE;
/*
- * parse function
+ ** ParseNestedFuncOrColumn --
+ ** Given a nested dot expression (i.e. (relation func ... attr), build up
+ ** a tree with of Iter and Func nodes.
*/
+Node *
+ParseNestedFuncOrColumn(ParseState *pstate, Attr *attr, int *curr_resno, int precedence)
+{
+ List *mutator_iter;
+ Node *retval = NULL;
+
+ if (attr->paramNo != NULL)
+ {
+ Param *param = (Param *) transformExpr(pstate, (Node *) attr->paramNo, EXPR_RELATION_FIRST);
+
+ retval = ParseFuncOrColumn(pstate, strVal(lfirst(attr->attrs)),
+ lcons(param, NIL),
+ curr_resno,
+ precedence);
+ }
+ else
+ {
+ Ident *ident = makeNode(Ident);
+
+ ident->name = attr->relname;
+ ident->isRel = TRUE;
+ retval = ParseFuncOrColumn(pstate, strVal(lfirst(attr->attrs)),
+ 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);
+ }
+
+ return (retval);
+}
+
+/*
+ * parse function
+ */
Node *
-ParseFunc(ParseState *pstate, char *funcname, List *fargs,
+ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
int *curr_resno, int precedence)
{
Oid rettype = (Oid) 0;
* that argument is a relation, param, or PQ function returning a
* complex * type, then the function could be a projection.
*/
+ /* We only have one parameter */
if (length(fargs) == 1)
{
-
+ /* Is is a plain Relation name from the parser? */
if (nodeTag(first_arg) == T_Ident && ((Ident *) first_arg)->isRel)
{
RangeTblEntry *rte;
{
Oid dummyTypeId;
- return
- ((Node *) make_var(pstate,
+ return ((Node *) make_var(pstate,
refname,
funcname,
&dummyTypeId));
Oid basetype;
/*
- * the aggregate count is a special case, ignore its base
+ * the aggregate COUNT is a special case, ignore its base
* type. Treat it as zero
*/
if (strcmp(funcname, "count") == 0)
*/
if (exprType(pair) == UNKNOWNOID &&
!IsA(pair, Const))
- {
- elog(ERROR, "ParseFunc: no function named '%s' that takes in an unknown type as argument #%d", funcname, nargs);
- }
+ elog(ERROR, "ParseFuncOrColumn: no function named '%s' that takes in an unknown type as argument #%d", funcname, nargs);
else
toid = exprType(pair);
}
palloc(8 * sizeof(Oid));
MemSet(current_candidate->args, 0, 8 * sizeof(Oid));
for (i = 0; i < nargs; i++)
- {
current_candidate->args[i] =
pgProcP->proargtypes[i];
- }
current_candidate->next = candidates;
candidates = current_candidate;
/*
** setup_tlist --
** Build a tlist that says which attribute to project to.
- ** This routine is called by ParseFunc() to set up a target list
+ ** This routine is called by ParseFuncOrColumn() to set up a target list
** on a tuple parameter or return value. Due to a bug in 4.0,
** it's not possible to refer to system attributes in this case.
*/
elog(ERROR, "%s: function %s(%s) does not exist", caller, funcname, p);
}
-
-
-
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.8 1998/01/19 05:06:19 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_node.c,v 1.9 1998/01/20 05:04:21 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "parser/parse_type.h"
#include "utils/builtins.h"
#include "utils/syscache.h"
+#include "utils/lsyscache.h"
static void disallow_setop(char *op, Type optype, Node *operand);
static Node *make_operand(char *opname,
result->oper = (Node *) newop;
if (!left)
- {
result->args = lcons(right, NIL);
- }
else if (!right)
- {
result->args = lcons(left, NIL);
- }
else
- {
result->args = lcons(left, lcons(right, NIL));
- }
return result;
}
int vnum,
attid;
Oid vartypeid;
- Relation rd;
RangeTblEntry *rte;
rte = refnameRangeTableEntry(pstate->p_rtable, refname);
vnum = refnameRangeTablePosn(pstate->p_rtable, refname);
- rd = heap_open(rte->relid);
-
- attid = attnameAttNum(rd, attrname); /* could elog(ERROR) */
- vartypeid = attnumTypeId(rd, attid);
+ attid = get_attnum(rte->relid, attrname);
+ if (attid == InvalidAttrNumber)
+ elog(ERROR, "Relation %s does not have attribute %s",
+ rte->relname, attrname);
+ vartypeid = get_atttype(rte->relid, attid);
varnode = makeVar(vnum, attid, vartypeid, vnum, attid);
-
- heap_close(rd);
-
*type_id = vartypeid;
+
return varnode;
}
type_struct_array = (TypeTupleForm) GETSTRUCT(type_tuple);
if (type_struct_array->typelem == InvalidOid)
- {
elog(ERROR, "make_array_ref: type %s is not an array",
(Name) &(type_struct_array->typname.data[0]));
- }
/* get the type tuple for the element type */
type_tuple = SearchSysCacheTuple(TYPOID,
A_Indices *ind = lfirst(indirection);
if (ind->lidx)
- {
-
/*
* XXX assumes all lower indices non null in this case
*/
lowerIndexpr = lappend(lowerIndexpr, ind->lidx);
- }
+
upperIndexpr = lappend(upperIndexpr, ind->uidx);
indirection = lnext(indirection);
}
type_struct_array = (TypeTupleForm) GETSTRUCT(type_tuple);
if (type_struct_array->typelem == InvalidOid)
- {
elog(ERROR, "make_array_ref: type %s is not an array",
(Name) &(type_struct_array->typname.data[0]));
- }
/* get the type tuple for the element type */
type_tuple = SearchSysCacheTuple(TYPOID,
ObjectIdGetDatum(type_struct_array->typelem),
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.7 1998/01/16 23:20:20 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_oper.c,v 1.8 1998/01/20 05:04:23 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return ((Operator) tup);
}
-/* Given a typename and value, returns the ascii form of the value */
-
-#ifdef NOT_USED
-char *
-outstr(char *typename, /* Name of type of value */
- char *value) /* Could be of any type */
-{
- TypeTupleForm tp;
- Oid op;
-
- tp = (TypeTupleForm) GETSTRUCT(type(typename));
- op = tp->typoutput;
- return ((char *) fmgr(op, value));
-}
-
-#endif
-
/*
* Give a somewhat useful error message when the operator for two types
* is not found.
"\n\tor you will have to define the operator using CREATE OPERATOR",
op, typeTypeName(tp1), typeTypeName(tp2));
}
-
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.6 1998/01/16 23:20:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_relation.c,v 1.7 1998/01/20 05:04:24 momjian Exp $
*
*-------------------------------------------------------------------------
*/
return index;
index++;
}
- return (0);
+ return 0;
}
/*
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
rte->inh = inh;
/* RelOID */
- rte->relid = RelationGetRelationId(relation);
-
rte->inFromCl = inFromCl;
/*
if (pstate != NULL)
pstate->p_rtable = lappend(pstate->p_rtable, rte);
- heap_close(relation);
-
return rte;
}
rdesc = heap_open(rte->relid);
if (rdesc == NULL)
- {
elog(ERROR, "Unable to expand all -- heap_open failed on %s",
rte->refname);
- return NIL;
- }
+
maxattrs = RelationGetNumberOfAttributes(rdesc);
for (varattno = 0; varattno <= maxattrs - 1; varattno++)
}
heap_close(rdesc);
+
return (te_head);
}
-/* given relation and att name, return id of variable */
+/*
+ * given relation and att name, return id of variable
+ *
+ * This should only be used if the relation is already
+ * heap_open()'ed. Use the cache version get_attnum()
+ * for access to non-opened relations.
+ */
int
attnameAttNum(Relation rd, char *a)
{
return 0; /* lint */
}
-/* Given range variable, return whether attribute of this name
+/*
+ * Given range variable, return whether attribute of this name
* is a set.
* NOTE the ASSUMPTION here that no system attributes are, or ever
* will be, sets.
+ *
+ * This should only be used if the relation is already
+ * heap_open()'ed. Use the cache version get_attisset()
+ * for access to non-opened relations.
*/
bool
attnameIsSet(Relation rd, char *name)
return (get_attisset(rd->rd_id, name));
}
-/*-------------
- * given an attribute number and a relation, return its relation name
+/*
+ * This should only be used if the relation is already
+ * heap_open()'ed. Use the cache version
+ * for access to non-opened relations.
*/
-char *
-attnumAttName(Relation rd, int attrno)
-{
- char *name;
- int i;
-
- if (attrno < 0)
- {
- for (i = 0; i < SPECIALS; i++)
- {
- if (special_attr[i].code == attrno)
- {
- name = special_attr[i].field;
- return (name);
- }
- }
- elog(ERROR, "Illegal attr no %d for relation %s",
- attrno, RelationGetRelationName(rd));
- }
- else if (attrno >= 1 && attrno <= RelationGetNumberOfAttributes(rd))
- {
- name = (rd->rd_att->attrs[attrno - 1]->attname).data;
- return (name);
- }
- else
- {
- elog(ERROR, "Illegal attr no %d for relation %s",
- attrno, RelationGetRelationName(rd));
- }
-
- /*
- * Shouldn't get here, but we want lint to be happy...
- */
-
- return (NULL);
-}
-
int
attnumAttNelems(Relation rd, int attid)
{
}
/* given attribute id, return type of that attribute */
-/* XXX Special case for pseudo-attributes is a hack */
+/*
+ * This should only be used if the relation is already
+ * heap_open()'ed. Use the cache version get_atttype()
+ * for access to non-opened relations.
+ */
Oid
attnumTypeId(Relation rd, int attid)
{
attrtype_target;
int resdomno_id,
resdomno_target;
- Relation rd;
RangeTblEntry *rte;
if (target_colname == NULL || colname == NULL)
if (pstate->p_is_insert && rte == pstate->p_target_rangetblentry)
elog(ERROR, "%s not available in this context", colname);
*/
- rd = heap_open(rte->relid);
-
- resdomno_id = attnameAttNum(rd, colname);
- attrtype_id = attnumTypeId(rd, resdomno_id);
+ resdomno_id = get_attnum(rte->relid, colname);
+ attrtype_id = get_atttype(rte->relid, resdomno_id);
resdomno_target = attnameAttNum(pstate->p_target_relation, target_colname);
attrtype_target = attnumTypeId(pstate->p_target_relation, resdomno_target);
colname, target_colname);
if (attrtype_id == BPCHAROID &&
- rd->rd_att->attrs[resdomno_id - 1]->atttypmod !=
- pstate->p_target_relation->rd_att->attrs[resdomno_target - 1]->atttypmod)
+ get_atttypmod(rte->relid, resdomno_id) !=
+ get_atttype(pstate->p_target_relation->rd_id, resdomno_target))
elog(ERROR, "Length of %s is longer than length of target column %s",
colname, target_colname);
if (attrtype_id == VARCHAROID &&
- rd->rd_att->attrs[resdomno_id - 1]->atttypmod >
- pstate->p_target_relation->rd_att->attrs[resdomno_target - 1]->atttypmod)
+ get_atttypmod(rte->relid, resdomno_id) >
+ get_atttype(pstate->p_target_relation->rd_id, resdomno_target))
elog(ERROR, "Length of %s is longer than length of target column %s",
colname, target_colname);
- heap_close(rd);
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.6 1998/01/16 23:20:22 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_target.c,v 1.7 1998/01/20 05:04:26 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "nodes/makefuncs.h"
#include "nodes/primnodes.h"
#include "parser/parse_expr.h"
+#include "parser/parse_func.h"
#include "parser/parse_node.h"
#include "parser/parse_relation.h"
#include "parser/parse_target.h"
* Target item is fully specified: ie.
* relation.attribute
*/
- result = handleNestedDots(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)
{
else
type_len = typeLen(typeidType(type_id));
- /* I have no idea what the following does! */
- /* It appears to process target columns that will be receiving results */
+ /* Processes target columns that will be receiving results */
if (pstate->p_is_insert || pstate->p_is_update)
{
/*
- * append or replace query -- append, replace work only on one
+ * insert or update query -- insert, update work only on one
* relation, so multiple occurence of same resdomno is bogus
*/
rd = pstate->p_target_relation;
att->relname = pstrdup(RelationGetRelationName(rd)->data);
att->attrs = lcons(makeString(colname), NIL);
- target_expr = (Expr *) handleNestedDots(pstate, att,
+ target_expr = (Expr *) ParseNestedFuncOrColumn(pstate, att,
&pstate->p_last_resno,
EXPR_COLUMN_FIRST);
while (ar != NIL)
{
switch (nodeTag(expr))
{
- case T_Aggreg:
- return (char *) /* XXX */
- ((Aggreg *) expr)->aggname;
+ case T_Aggreg:
+ return (char *) ((Aggreg *) expr)->aggname;
case T_Expr:
if (((Expr *) expr)->opType == FUNC_EXPR)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.9 1998/01/07 21:06:12 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/utils/cache/lsyscache.c,v 1.10 1998/01/20 05:04:32 momjian Exp $
*
* NOTES
* Eventually, the index information should go through here, too.
ObjectIdGetDatum(opno),
ObjectIdGetDatum(amopid),
0))
- return (true);
+ return true;
else
- return (false);
+ return false;
}
/* ---------- ATTRIBUTE CACHES ---------- */
get_attname(Oid relid, AttrNumber attnum)
{
FormData_pg_attribute att_tup;
- char *retval;
if (SearchSysCacheStruct(ATTNUM,
(char *) &att_tup,
ObjectIdGetDatum(relid),
UInt16GetDatum(attnum),
0, 0))
- {
- retval = pstrdup(att_tup.attname.data);
-
- return (retval);
- }
+ return pstrdup(att_tup.attname.data);
else
- return (NULL);
+ return NULL;
}
/*
ObjectIdGetDatum(relid),
PointerGetDatum(attname),
0, 0))
- return (att_tup.attnum);
+ return att_tup.attnum;
else
- return (InvalidAttrNumber);
+ return InvalidAttrNumber;
}
/*
ObjectIdGetDatum(relid),
UInt16GetDatum(attnum),
0, 0))
- return (att_tup->atttypid);
+ return att_tup->atttypid;
else
- return ((Oid) NULL);
+ return (Oid) NULL;
}
/* This routine uses the attname instead of the attnum because it
elog(ERROR, "get_attisset: no attribute %s in relation %d",
attname, relid);
if (heap_attisnull(htup, attno))
- return (false);
+ return false;
else
{
att_tup = (AttributeTupleForm) GETSTRUCT(htup);
- return (att_tup->attisset);
+ return att_tup->attisset;
}
}
+/*
+ * get_atttypmod -
+ *
+ * Given the relation id and the attribute number,
+ * return the "atttypmod" field from the attribute relation.
+ *
+ */
+int
+get_atttypmod(Oid relid, AttrNumber attnum)
+{
+ FormData_pg_attribute att_tup;
+
+ if (SearchSysCacheStruct(ATTNUM,
+ (char *) &att_tup,
+ ObjectIdGetDatum(relid),
+ UInt16GetDatum(attnum),
+ 0, 0))
+ return att_tup.atttypmod;
+ else
+ return NULL;
+}
+
/* ---------- INDEX CACHE ---------- */
/* watch this space...
if (SearchSysCacheStruct(OPROID, (char *) &optup,
ObjectIdGetDatum(opno),
0, 0, 0))
- return (optup.oprcode);
+ return optup.oprcode;
else
- return ((RegProcedure) NULL);
+ return (RegProcedure) NULL;
}
/*
if (SearchSysCacheStruct(OPROID, (char *) &optup,
ObjectIdGetDatum(opno),
0, 0, 0))
- return (pstrdup(optup.oprname.data));
+ return pstrdup(optup.oprname.data);
else
{
elog(ERROR, "can't look up operator %d\n", opno);
optup.oprcanhash &&
optup.oprleft == ltype &&
optup.oprright == rtype)
- return (opno);
+ return opno;
else
- return (InvalidOid);
+ return InvalidOid;
}
/*
if (SearchSysCacheStruct(OPROID, (char *) &optup,
ObjectIdGetDatum(opno),
0, 0, 0))
- return (optup.oprcom);
+ return optup.oprcom;
else
- return ((Oid) NULL);
+ return (Oid) NULL;
}
HeapTuple
if ((optup = SearchSysCacheTuple(OPROID,
ObjectIdGetDatum(opno),
0, 0, 0)))
- return (optup);
+ return optup;
else
- return ((HeapTuple) NULL);
+ return (HeapTuple) NULL;
}
/*
if (SearchSysCacheStruct(OPROID, (char *) &optup,
ObjectIdGetDatum(opno),
0, 0, 0))
- return (optup.oprnegate);
+ return optup.oprnegate;
else
- return ((Oid) NULL);
+ return (Oid) NULL;
}
/*
if (SearchSysCacheStruct(OPROID, (char *) &optup,
ObjectIdGetDatum(opno),
0, 0, 0))
- return (optup.oprrest);
+ return optup.oprrest;
else
- return ((RegProcedure) NULL);
+ return (RegProcedure) NULL;
}
/*
if (SearchSysCacheStruct(OPROID, (char *) &optup,
ObjectIdGetDatum(opno),
0, 0, 0))
- return (optup.oprjoin);
+ return optup.oprjoin;
else
- return ((RegProcedure) NULL);
+ return (RegProcedure) NULL;
}
/* ---------- RELATION CACHE ---------- */
if (SearchSysCacheStruct(RELOID, (char *) &reltup,
ObjectIdGetDatum(relid),
0, 0, 0))
- return (reltup.relnatts);
+ return reltup.relnatts;
else
- return (InvalidAttrNumber);
+ return InvalidAttrNumber;
}
/*
(char *) &reltup,
ObjectIdGetDatum(relid),
0, 0, 0)))
- {
- return (pstrdup(reltup.relname.data));
- }
+ return pstrdup(reltup.relname.data);
else
- return (NULL);
+ return NULL;
}
/* ---------- TYPE CACHE ---------- */
if (SearchSysCacheStruct(TYPOID, (char *) &typtup,
ObjectIdGetDatum(typid),
0, 0, 0))
- return (typtup.typlen);
+ return typtup.typlen;
else
- return ((int16) NULL);
+ return (int16) NULL;
}
/*
if (SearchSysCacheStruct(TYPOID, (char *) &typtup,
ObjectIdGetDatum(typid),
0, 0, 0))
- return ((bool) typtup.typbyval);
+ return (bool) typtup.typbyval;
else
- return (false);
+ return false;
}
/*
if (SearchSysCacheStruct(TYPOID, (char *) &typtup,
ObjectIdGetDatum(typid),
0, 0, 0))
- return (typtup.typalign);
+ return typtup.typalign;
else
- return ('i');
+ return 'i';
}
#endif
struct varlena *typdefault =
(struct varlena *) TypeDefaultRetrieve(typid);
- return (typdefault);
+ return typdefault;
}
/*
if (SearchSysCacheStruct(TYPOID, (char *) &typtup,
ObjectIdGetDatum(typid),
0, 0, 0))
- {
- return (typtup.typtype);
- }
+ return typtup.typtype;
else
- {
- return ('\0');
- }
+ return '\0';
}
#endif
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_agg.h,v 1.4 1998/01/04 04:31:39 momjian Exp $
+ * $Id: parse_agg.h,v 1.5 1998/01/20 05:04:41 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern void AddAggToParseState(ParseState *pstate, Aggreg *aggreg);
-extern void finalizeAggregates(ParseState *pstate, Query *qry);
extern void parseCheckAggregates(ParseState *pstate, Query *qry);
extern Aggreg *ParseAgg(ParseState *pstate, char *aggname, Oid basetype,
List *target, int precedence);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_expr.h,v 1.5 1998/01/16 23:21:01 momjian Exp $
+ * $Id: parse_expr.h,v 1.6 1998/01/20 05:04:47 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Node *transformExpr(ParseState *pstate, Node *expr, int precedence);
extern Node *transformIdent(ParseState *pstate, Node *expr, int precedence);
extern Oid exprType(Node *expr);
-extern Node *handleNestedDots(ParseState *pstate, Attr *attr,
- int *curr_resno, int precedence);
extern Node *parser_typecast2(Node *expr, Oid exprType, Type tp, int attypmod);
#endif /* PARSE_EXPR_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_func.h,v 1.4 1998/01/04 04:31:42 momjian Exp $
+ * $Id: parse_func.h,v 1.5 1998/01/20 05:04:51 momjian Exp $
*
*-------------------------------------------------------------------------
*/
struct _CandidateList *next;
} *CandidateList;
-extern Node *ParseFunc(ParseState *pstate, char *funcname, List *fargs,
+extern Node *ParseNestedFuncOrColumn(ParseState *pstate, Attr *attr,
+ int *curr_resno, int precedence);
+extern Node *ParseFuncOrColumn(ParseState *pstate, char *funcname, List *fargs,
int *curr_resno, int precedence);
extern void func_error(char *caller, char *funcname, int nargs, Oid *argtypes);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_relation.h,v 1.4 1998/01/04 04:31:43 momjian Exp $
+ * $Id: parse_relation.h,v 1.5 1998/01/20 05:04:56 momjian Exp $
*
*-------------------------------------------------------------------------
*/
int *this_resno);
extern int attnameAttNum(Relation rd, char *a);
extern bool attnameIsSet(Relation rd, char *name);
-extern char *attnumAttName(Relation rd, int attrno);
extern int attnumAttNelems(Relation rd, int attid);
extern Oid attnumTypeId(Relation rd, int attid);
extern void handleTargetColname(ParseState *pstate, char **resname,
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/include/storage/s_lock.h,v 1.18 1998/01/19 05:48:55 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/include/storage/s_lock.h,v 1.19 1998/01/20 05:05:02 momjian Exp $
*
*-------------------------------------------------------------------------
*/
slock_t _res; \
do \
{ \
- __asm__("xchgb %0,%1": "=q"(_res), "=m"(*lock):"0"(0x1)); \
+ __asm__("lock; xchgb %0,%1": "=q"(_res), "=m"(*lock):"0"(0x1)); \
} while (_res != 0); \
} while (0)
#endif
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: lsyscache.h,v 1.6 1997/09/08 21:55:11 momjian Exp $
+ * $Id: lsyscache.h,v 1.7 1998/01/20 05:05:08 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern AttrNumber get_attnum(Oid relid, char *attname);
extern Oid get_atttype(Oid relid, AttrNumber attnum);
extern bool get_attisset(Oid relid, char *attname);
+extern int get_atttypmod(Oid relid, AttrNumber attnum);
extern RegProcedure get_opcode(Oid opid);
extern char *get_opname(Oid opid);
extern bool
projects / postgresql.git / commitdiff