List *
pg_parse_and_plan(char *query_string, Oid *typev,
int nargs,
- QueryTreeList **queryListP,
+ List **queryListP,
CommandDest dest)
{
.
if(IsA(tree, SelectStmt))
{
- QueryTreeList *qtree;
+ List *qtrees;
/* If we get to the tree given in first_select
* return parsetree instead of performing
else
{
/* transform the unprocessed Query nodes */
- qtree =
- parse_analyze(lcons(tree, NIL), NULL);
- result = (Node *)qtree->qtrees[0];
+ qtrees = parse_analyze(lcons(tree, NIL), NULL);
+ result = (Node *) lfirst(qtrees);
}
}
if(IsA(tree,Expr))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.79 1999/05/10 04:02:03 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.80 1999/05/13 07:28:26 tgl Exp $
*
*
* INTERFACE ROUTINES
char str[MAX_PARSE_BUFFER];
char cast[2 * NAMEDATALEN] = {0};
Form_pg_attribute atp = rel->rd_att->attrs[attrdef->adnum - 1];
- QueryTreeList *queryTree_list;
- Query *query;
+ List *queryTree_list;
List *planTree_list;
+ Query *query;
TargetEntry *te;
Resdom *resdom;
Node *expr;
"select %s%s from \"%.*s\"", attrdef->adsrc, cast,
NAMEDATALEN, rel->rd_rel->relname.data);
setheapoverride(true);
- planTree_list = (List *) pg_parse_and_plan(str, NULL, 0, &queryTree_list, None, FALSE);
+ planTree_list = pg_parse_and_plan(str, NULL, 0,
+ &queryTree_list, None, FALSE);
setheapoverride(false);
- query = (Query *) (queryTree_list->qtrees[0]);
+ query = (Query *) lfirst(queryTree_list);
if (length(query->rtable) > 1 ||
flatten_tlist(query->targetList) != NIL)
StoreRelCheck(Relation rel, ConstrCheck *check)
{
char str[MAX_PARSE_BUFFER];
- QueryTreeList *queryTree_list;
- Query *query;
+ List *queryTree_list;
List *planTree_list;
+ Query *query;
Plan *plan;
List *qual;
char *ccbin;
"select 1 from \"%.*s\" where %s",
NAMEDATALEN, rel->rd_rel->relname.data, check->ccsrc);
setheapoverride(true);
- planTree_list = (List *) pg_parse_and_plan(str, NULL, 0, &queryTree_list, None, FALSE);
+ planTree_list = pg_parse_and_plan(str, NULL, 0,
+ &queryTree_list, None, FALSE);
setheapoverride(false);
- query = (Query *) (queryTree_list->qtrees[0]);
+ query = (Query *) lfirst(queryTree_list);
if (length(query->rtable) > 1)
elog(ERROR, "Only relation '%.*s' can be referenced",
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.27 1999/04/18 02:57:22 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/pg_proc.c,v 1.28 1999/05/13 07:28:27 tgl Exp $
*
*-------------------------------------------------------------------------
*/
Oid languageObjectId;
Oid typeObjectId;
List *x;
- QueryTreeList *querytree_list;
+ List *querytree_list;
List *plan_list;
Oid typev[8];
Oid relid;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/functions.c,v 1.24 1999/02/13 23:15:20 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/functions.c,v 1.25 1999/05/13 07:28:29 tgl Exp $
*
*-------------------------------------------------------------------------
*/
execution_state *newes;
execution_state *nextes;
execution_state *preves;
- QueryTreeList *queryTree_list;
- int i;
- List *planTree_list;
- int nargs;
-
- nargs = fcache->nargs;
+ List *queryTree_list,
+ *planTree_list,
+ *qtl_item;
+ int nargs = fcache->nargs;
newes = (execution_state *) palloc(sizeof(execution_state));
nextes = newes;
preves = (execution_state *) NULL;
+ planTree_list = pg_parse_and_plan(fcache->src, fcache->argOidVect,
+ nargs, &queryTree_list, None, FALSE);
- planTree_list = (List *)
- pg_parse_and_plan(fcache->src, fcache->argOidVect, nargs, &queryTree_list, None, FALSE);
-
- for (i = 0; i < queryTree_list->len; i++)
+ foreach (qtl_item, queryTree_list)
{
- EState *estate;
- Query *queryTree = (Query *) (queryTree_list->qtrees[i]);
+ Query *queryTree = lfirst(qtl_item);
Plan *planTree = lfirst(planTree_list);
+ EState *estate;
if (!nextes)
nextes = (execution_state *) palloc(sizeof(execution_state));
* spi.c
* Server Programming Interface
*
- * $Id: spi.c,v 1.36 1999/03/30 01:37:23 momjian Exp $
+ * $Id: spi.c,v 1.37 1999/05/13 07:28:30 tgl Exp $
*
*-------------------------------------------------------------------------
*/
static int
_SPI_execute(char *src, int tcount, _SPI_plan *plan)
{
- QueryTreeList *queryTree_list;
+ List *queryTree_list;
List *planTree_list;
+ List *queryTree_list_item;
List *ptlist;
QueryDesc *qdesc;
Query *queryTree;
Plan *planTree;
EState *state;
- int qlen;
int nargs = 0;
Oid *argtypes = NULL;
- int res;
- int i;
+ int res = 0;
+ bool islastquery;
/* Increment CommandCounter to see changes made by now */
CommandCounterIncrement();
nargs = plan->nargs;
argtypes = plan->argtypes;
}
- ptlist = planTree_list = (List *)
+ ptlist = planTree_list =
pg_parse_and_plan(src, argtypes, nargs, &queryTree_list, None, FALSE);
_SPI_current->qtlist = queryTree_list;
- qlen = queryTree_list->len;
- for (i = 0;; i++)
+ foreach (queryTree_list_item, queryTree_list)
{
- queryTree = (Query *) (queryTree_list->qtrees[i]);
+ queryTree = (Query *) lfirst(queryTree_list_item);
planTree = lfirst(planTree_list);
-
planTree_list = lnext(planTree_list);
+ islastquery = (planTree_list == NIL); /* assume lists are same len */
if (queryTree->commandType == CMD_UTILITY)
{
if (plan == NULL)
{
ProcessUtility(queryTree->utilityStmt, None);
- if (i < qlen - 1)
+ if (! islastquery)
CommandCounterIncrement();
else
return res;
}
- else if (i >= qlen - 1)
+ else if (islastquery)
break;
}
else if (plan == NULL)
{
qdesc = CreateQueryDesc(queryTree, planTree,
- (i < qlen - 1) ? None : SPI);
+ islastquery ? SPI : None);
state = CreateExecutorState();
- res = _SPI_pquery(qdesc, state, (i < qlen - 1) ? 0 : tcount);
- if (res < 0 || i >= qlen - 1)
+ res = _SPI_pquery(qdesc, state, islastquery ? tcount : 0);
+ if (res < 0 || islastquery)
return res;
CommandCounterIncrement();
}
else
{
qdesc = CreateQueryDesc(queryTree, planTree,
- (i < qlen - 1) ? None : SPI);
- res = _SPI_pquery(qdesc, NULL, (i < qlen - 1) ? 0 : tcount);
+ islastquery ? SPI : None);
+ res = _SPI_pquery(qdesc, NULL, islastquery ? tcount : 0);
if (res < 0)
return res;
- if (i >= qlen - 1)
+ if (islastquery)
break;
}
}
plan->ptlist = ptlist;
return res;
-
}
static int
_SPI_execute_plan(_SPI_plan *plan, Datum *Values, char *Nulls, int tcount)
{
- QueryTreeList *queryTree_list = plan->qtlist;
+ List *queryTree_list = plan->qtlist;
List *planTree_list = plan->ptlist;
+ List *queryTree_list_item;
QueryDesc *qdesc;
Query *queryTree;
Plan *planTree;
EState *state;
int nargs = plan->nargs;
- int qlen = queryTree_list->len;
- int res;
- int i,
- k;
+ int res = 0;
+ bool islastquery;
+ int k;
/* Increment CommandCounter to see changes made by now */
CommandCounterIncrement();
_SPI_current->tuptable = NULL;
_SPI_current->qtlist = NULL;
- for (i = 0;; i++)
+ foreach (queryTree_list_item, queryTree_list)
{
- queryTree = (Query *) (queryTree_list->qtrees[i]);
+ queryTree = (Query *) lfirst(queryTree_list_item);
planTree = lfirst(planTree_list);
-
planTree_list = lnext(planTree_list);
+ islastquery = (planTree_list == NIL); /* assume lists are same len */
if (queryTree->commandType == CMD_UTILITY)
{
ProcessUtility(queryTree->utilityStmt, None);
- if (i < qlen - 1)
+ if (! islastquery)
CommandCounterIncrement();
else
return SPI_OK_UTILITY;
else
{
qdesc = CreateQueryDesc(queryTree, planTree,
- (i < qlen - 1) ? None : SPI);
+ islastquery ? SPI : None);
state = CreateExecutorState();
if (nargs > 0)
{
}
else
state->es_param_list_info = NULL;
- res = _SPI_pquery(qdesc, state, (i < qlen - 1) ? 0 : tcount);
- if (res < 0 || i >= qlen - 1)
+ res = _SPI_pquery(qdesc, state, islastquery ? tcount : 0);
+ if (res < 0 || islastquery)
return res;
CommandCounterIncrement();
}
}
return res;
-
}
static int
*/
_SPI_curid--;
- if (_SPI_current->qtlist) /* free _SPI_plan allocations */
- {
- free(_SPI_current->qtlist->qtrees);
- free(_SPI_current->qtlist);
- _SPI_current->qtlist = NULL;
- }
+ _SPI_current->qtlist = NULL;
if (procmem) /* switch to the procedure memory context */
{ /* but free Executor memory before */
{
_SPI_plan *newplan;
MemoryContext oldcxt = NULL;
- int i;
if (location == _SPI_CPLAN_PROCXT)
oldcxt = MemoryContextSwitchTo((MemoryContext)
oldcxt = MemoryContextSwitchTo(TopMemoryContext);
newplan = (_SPI_plan *) palloc(sizeof(_SPI_plan));
- newplan->qtlist = (QueryTreeList *) palloc(sizeof(QueryTreeList));
- newplan->qtlist->len = plan->qtlist->len;
- newplan->qtlist->qtrees = (Query **) palloc(plan->qtlist->len *
- sizeof(Query *));
- for (i = 0; i < plan->qtlist->len; i++)
- newplan->qtlist->qtrees[i] = (Query *)
- copyObject(plan->qtlist->qtrees[i]);
-
+ newplan->qtlist = (List *) copyObject(plan->qtlist);
newplan->ptlist = (List *) copyObject(plan->ptlist);
newplan->nargs = plan->nargs;
if (plan->nargs > 0)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.51 1999/05/12 15:01:37 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.52 1999/05/13 07:28:32 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* XXX Why is this function in this module?
*/
void
-pg_checkretval(Oid rettype, QueryTreeList *queryTreeList)
+pg_checkretval(Oid rettype, List *queryTreeList)
{
Query *parse;
List *tlist;
int i;
/* find the final query */
- parse = queryTreeList->qtrees[queryTreeList->len - 1];
+ parse = (Query *) nth(length(queryTreeList)-1, queryTreeList);
/*
* test 1: if the last query is a utility invocation, then there had
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: analyze.c,v 1.102 1999/05/12 07:17:18 thomas Exp $
+ * $Id: analyze.c,v 1.103 1999/05/13 07:28:34 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* all transformed to Query while the rest stays the same.
*
*/
-QueryTreeList *
+List *
parse_analyze(List *pl, ParseState *parentParseState)
{
- QueryTreeList *result;
+ List *result = NIL;
ParseState *pstate;
Query *parsetree;
- int i = 0;
-
- result = malloc(sizeof(QueryTreeList));
- result->len = length(pl);
- result->qtrees = (Query **) malloc(result->len * sizeof(Query *));
while (pl != NIL)
{
if (pstate->p_target_relation != NULL)
heap_close(pstate->p_target_relation);
- if (extras_before != NIL)
+ while (extras_before != NIL)
{
- result->len += length(extras_before);
- result->qtrees = (Query **) realloc(result->qtrees, result->len * sizeof(Query *));
- while (extras_before != NIL)
- {
- result->qtrees[i++] = transformStmt(pstate, lfirst(extras_before));
- if (pstate->p_target_relation != NULL)
- heap_close(pstate->p_target_relation);
- extras_before = lnext(extras_before);
- }
+ result = lappend(result,
+ transformStmt(pstate, lfirst(extras_before)));
+ if (pstate->p_target_relation != NULL)
+ heap_close(pstate->p_target_relation);
+ extras_before = lnext(extras_before);
}
- extras_before = NIL;
- result->qtrees[i++] = parsetree;
+ result = lappend(result, parsetree);
- if (extras_after != NIL)
+ while (extras_after != NIL)
{
- result->len += length(extras_after);
- result->qtrees = (Query **) realloc(result->qtrees, result->len * sizeof(Query *));
- while (extras_after != NIL)
- {
- result->qtrees[i++] = transformStmt(pstate, lfirst(extras_after));
- if (pstate->p_target_relation != NULL)
- heap_close(pstate->p_target_relation);
- extras_after = lnext(extras_after);
- }
+ result = lappend(result,
+ transformStmt(pstate, lfirst(extras_after)));
+ if (pstate->p_target_relation != NULL)
+ heap_close(pstate->p_target_relation);
+ extras_after = lnext(extras_after);
}
- extras_after = NIL;
pl = lnext(pl);
pfree(pstate);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.30 1999/05/12 15:01:50 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_clause.c,v 1.31 1999/05/13 07:28:36 tgl Exp $
*
*-------------------------------------------------------------------------
*/
transformUnionClause(List *unionClause, List *targetlist)
{
List *union_list = NIL;
- QueryTreeList *qlist;
- int i;
+ List *qlist,
+ *qlist_item;
if (unionClause)
{
/* recursion */
qlist = parse_analyze(unionClause, NULL);
- for (i = 0; i < qlist->len; i++)
+ foreach (qlist_item, qlist)
{
+ Query *query = (Query *) lfirst(qlist_item);
List *prev_target = targetlist;
List *next_target;
- if (length(targetlist) != length(qlist->qtrees[i]->targetList))
+ if (length(targetlist) != length(query->targetList))
elog(ERROR, "Each UNION clause must have the same number of columns");
- foreach(next_target, qlist->qtrees[i]->targetList)
+ foreach(next_target, query->targetList)
{
Oid itype;
Oid otype;
}
prev_target = lnext(prev_target);
}
- union_list = lappend(union_list, qlist->qtrees[i]);
+ union_list = lappend(union_list, query);
}
return union_list;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.44 1999/05/12 07:14:24 thomas Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parse_expr.c,v 1.45 1999/05/13 07:28:38 tgl Exp $
*
*-------------------------------------------------------------------------
*/
case T_SubLink:
{
SubLink *sublink = (SubLink *) expr;
- QueryTreeList *qtree;
+ List *qtrees;
+ Query *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)
+ qtrees = parse_analyze(lcons(sublink->subselect, NIL), pstate);
+ if (length(qtrees) != 1)
elog(ERROR, "parser: bad query in subselect");
- sublink->subselect = (Node *) qtree->qtrees[0];
+ qtree = (Query *) lfirst(qtrees);
+ if (qtree->commandType != CMD_SELECT ||
+ qtree->resultRelation != 0)
+ elog(ERROR, "parser: bad query in subselect");
+ sublink->subselect = (Node *) qtree;
if (sublink->subLinkType != EXISTS_SUBLINK)
{
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/parser/parser.c,v 1.37 1999/02/13 23:17:10 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/parser/parser.c,v 1.38 1999/05/13 07:28:39 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include "parser/parse_node.h"
#include "parser/parser.h"
+#if defined(FLEX_SCANNER)
+extern void DeleteBuffer(void);
+#endif /* FLEX_SCANNER */
+
char *parseString; /* the char* which holds the string to be
* parsed */
-List *parsetree = NIL;
+List *parsetree; /* result of parsing is left here */
#ifdef SETS_FIXED
static void fixupsets();
static void define_sets();
-
#endif
+
/*
* parser-- returns a list of parse trees
- *
- * CALLER is responsible for free'ing the list returned
*/
-QueryTreeList *
+List *
parser(char *str, Oid *typev, int nargs)
{
- QueryTreeList *queryList;
+ List *queryList;
int yyresult;
-#if defined(FLEX_SCANNER)
- extern void DeleteBuffer(void);
-
-#endif /* FLEX_SCANNER */
-
init_io();
parseString = pstrdup(str);
+ parsetree = NIL; /* in case parser forgets to set it */
parser_init(typev, nargs);
yyresult = yyparse();
clearerr(stdin);
if (yyresult) /* error */
- return (QueryTreeList *) NULL;
+ return (List *) NULL;
queryList = parse_analyze(parsetree, NULL);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.40 1999/05/12 17:04:47 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/backend/rewrite/rewriteHandler.c,v 1.41 1999/05/13 07:28:41 tgl Exp $
*
*-------------------------------------------------------------------------
*/
* instead. */
Node *intersect_tree_analyze(Node *tree, Node *first_select, Node *parsetree)
{
- Node *result = (Node *)NIL;
- List *arg;
-
- if(IsA(tree, SelectStmt))
+ Node *result = (Node *) NIL;
+ List *arg;
+
+ if (IsA(tree, SelectStmt))
{
- QueryTreeList *qtree;
-
- /* If we get to the tree given in first_select return
- * parsetree instead of performing parse_analyze() */
- if(tree == first_select){
- result = parsetree;
- }
- else {
- /* transform the 'raw' nodes to 'cooked' Query nodes */
- qtree = parse_analyze(lcons(tree, NIL), NULL);
- result = (Node *)qtree->qtrees[0];
- }
-
+ /* If we get to the tree given in first_select return
+ * parsetree instead of performing parse_analyze() */
+ if (tree == first_select)
+ {
+ result = parsetree;
+ }
+ else
+ {
+ /* transform the 'raw' nodes to 'cooked' Query nodes */
+ List *qtree = parse_analyze(lcons(tree, NIL), NULL);
+ result = (Node *) lfirst(qtree);
+ }
}
+
if(IsA(tree,Expr))
{
/* Call recursively for every argument of the node */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.112 1999/05/11 09:06:31 wieck Exp $
+ * $Header: /cvsroot/pgsql/src/backend/tcop/postgres.c,v 1.113 1999/05/13 07:28:46 tgl Exp $
*
* NOTES
* this is the "main" module of the postgres backend and
pg_parse_and_plan(char *query_string, /* string to execute */
Oid *typev, /* argument types */
int nargs, /* number of arguments */
- QueryTreeList **queryListP, /* pointer to the parse
- * trees */
+ List **queryListP, /* returned pointer to the parse trees */
CommandDest dest, /* where results should go */
bool aclOverride)
{
- QueryTreeList *querytree_list;
- int i;
+ List *querytree_list = NIL;
List *plan_list = NIL;
- Plan *plan;
- int j;
- QueryTreeList *new_list;
- List *rewritten = NIL;
+ List *querytree_list_item;
Query *querytree;
+ Plan *plan;
+ List *new_list;
+ List *rewritten;
if (DebugPrintQuery)
{
ShowUsage();
}
- /* new_list holds the rewritten queries */
- new_list = (QueryTreeList *) malloc(sizeof(QueryTreeList));
- new_list->len = querytree_list->len;
- new_list->qtrees = (Query **) malloc(new_list->len * sizeof(Query *));
-
/* ----------------
* (2) rewrite the queries, as necessary
*
- * j counts queries output into new_list; the number of rewritten
- * queries can be different from the original number.
+ * rewritten queries are collected in new_list. Note there may be
+ * more or fewer than in the original list.
* ----------------
*/
- j = 0;
- for (i = 0; i < querytree_list->len; i++)
+ new_list = NIL;
+ foreach (querytree_list_item, querytree_list)
{
- querytree = querytree_list->qtrees[i];
+ querytree = (Query *) lfirst(querytree_list_item);
if (DebugPrintParse || DebugPPrintParse)
{
}
}
- /* don't rewrite utilites, just dump 'em into new_list */
if (querytree->commandType == CMD_UTILITY)
{
- new_list->qtrees[j++] = querytree;
- continue;
+ /* don't rewrite utilities, just dump 'em into new_list */
+ new_list = lappend(new_list, querytree);
}
-
- /* rewrite regular queries */
- rewritten = QueryRewrite(querytree);
-
- if (rewritten != NIL)
+ else
{
- int len,
- k;
-
- len = length(rewritten);
- if (len == 1)
- new_list->qtrees[j++] = (Query *) lfirst(rewritten);
- else
- {
- /* rewritten queries are longer than original query */
- /* grow the new_list to accommodate */
- new_list->len += len - 1; /* - 1 because originally
- * we allocated one space
- * for the query */
- new_list->qtrees = realloc(new_list->qtrees,
- new_list->len * sizeof(Query *));
- for (k = 0; k < len; k++)
- new_list->qtrees[j++] = (Query *) nth(k, rewritten);
- }
+ /* rewrite regular queries */
+ rewritten = QueryRewrite(querytree);
+ new_list = nconc(new_list, rewritten);
}
}
- /* Update new_list with correct final length */
- new_list->len = j;
-
- /* we're done with the original lists, free it */
- free(querytree_list->qtrees);
- free(querytree_list);
-
querytree_list = new_list;
/*
*/
if (aclOverride)
{
- for (i = 0; i < querytree_list->len; i++)
+ foreach (querytree_list_item, querytree_list)
{
- RangeTblEntry *rte;
List *l;
- querytree = querytree_list->qtrees[i];
+ querytree = (Query *) lfirst(querytree_list_item);
+
if (querytree->commandType == CMD_UTILITY)
continue;
foreach(l, querytree->rtable)
{
- rte = (RangeTblEntry *) lfirst(l);
+ RangeTblEntry *rte = (RangeTblEntry *) lfirst(l);
rte->skipAcl = TRUE;
}
if (DebugPPrintRewrittenParsetree) {
TPRINTF(TRACE_PRETTY_REWRITTEN, "after rewriting:");
- for (i = 0; i < querytree_list->len; i++)
+ foreach (querytree_list_item, querytree_list)
{
- nodeDisplay(querytree_list->qtrees[i]);
+ querytree = (Query *) lfirst(querytree_list_item);
+ nodeDisplay(querytree);
printf("\n");
}
} else {
TPRINTF(TRACE_REWRITTEN, "after rewriting:");
- for (i = 0; i < querytree_list->len; i++)
+ foreach (querytree_list_item, querytree_list)
{
- printf("\n%s\n\n", nodeToString(querytree_list->qtrees[i]));
+ querytree = (Query *) lfirst(querytree_list_item);
+ printf("\n%s\n\n", nodeToString(querytree));
}
}
}
- for (i = 0; i < querytree_list->len; i++)
+ foreach (querytree_list_item, querytree_list)
{
- querytree = querytree_list->qtrees[i];
+ querytree = (Query *) lfirst(querytree_list_item);
/*
* For each query that isn't a utility invocation, generate a
elog(NOTICE, "(transaction aborted): %s",
"queries ignored until END");
- free(querytree_list->qtrees);
- free(querytree_list);
if (queryListP)
- *queryListP = (QueryTreeList *) NULL;
- return (List *) NULL;
+ *queryListP = NIL;
+ return NIL;
}
if (ShowPlannerStats)
}
#endif
}
-#ifdef FUNC_UTIL_PATCH
-
/*
* If the command is an utility append a null plan. This is needed
* to keep the plan_list aligned with the querytree_list or the
*/
else
plan_list = lappend(plan_list, NULL);
-#endif
- }
-
- /* ----------
- * Check if the rewriting had thrown away everything
- * ----------
- */
- if (querytree_list->len == 0)
- {
- free(querytree_list->qtrees);
- free(querytree_list);
- querytree_list = NULL;
}
if (queryListP)
bool aclOverride) /* to give utility commands power
* of superusers */
{
+ List *querytree_list;
List *plan_list;
- Plan *plan;
Query *querytree;
- int i,
- j;
- QueryTreeList *querytree_list;
+ Plan *plan;
+ int j;
/* plan the queries */
- plan_list = pg_parse_and_plan(query_string, NULL, 0, &querytree_list, dest, aclOverride);
+ plan_list = pg_parse_and_plan(query_string, NULL, 0,
+ &querytree_list, dest, aclOverride);
+ /* if we got a cancel signal whilst planning, quit */
if (QueryCancel)
CancelQuery();
- /* pg_parse_and_plan could have failed */
- if (querytree_list == NULL)
- return;
-
- for (i = 0; i < querytree_list->len; i++)
- {
- querytree = querytree_list->qtrees[i];
+ /* OK, do it to it! */
-#ifdef FUNC_UTIL_PATCH
+ /* NOTE: we do not use "foreach" here because we want to be sure
+ * the list pointers have been advanced before the query is executed.
+ * We need to do that because VACUUM has a nasty little habit of doing
+ * CommitTransactionCommand at startup, and that will release the
+ * memory holding our parse/plan lists :-(. This needs a better
+ * solution --- currently, the code will crash if someone submits
+ * "vacuum; something-else" in a single query string. But memory
+ * allocation needs redesigned anyway, so this will have to do for now.
+ */
- /*
- * Advance on the plan_list in every case. Now the plan_list has
- * the same length of the querytree_list. DZ - 30-8-1996
- */
+ while (querytree_list)
+ {
+ querytree = (Query *) lfirst(querytree_list);
+ querytree_list = lnext(querytree_list);
plan = (Plan *) lfirst(plan_list);
plan_list = lnext(plan_list);
-#endif
+
if (querytree->commandType == CMD_UTILITY)
{
/* ----------------
TPRINTF(TRACE_VERBOSE, "ProcessUtility");
ProcessUtility(querytree->utilityStmt, dest);
-
}
else
{
-#ifndef FUNC_UTIL_PATCH
-
- /*
- * Moved before the if. DZ - 30-8-1996
- */
- plan = (Plan *) lfirst(plan_list);
- plan_list = lnext(plan_list);
-#endif
-
#ifdef INDEXSCAN_PATCH
/*
* visible to subsequent ones.
*/
- if (querytree_list)
- CommandCounterIncrement();
+ CommandCounterIncrement();
}
-
- free(querytree_list->qtrees);
- free(querytree_list);
}
/* --------------------------------
if (!IsUnderPostmaster)
{
puts("\nPOSTGRES backend interactive interface ");
- puts("$Revision: 1.112 $ $Date: 1999/05/11 09:06:31 $\n");
+ puts("$Revision: 1.113 $ $Date: 1999/05/13 07:28:46 $\n");
}
/* ----------------
* spi.c
* Server Programming Interface private declarations
*
- * $Header: /cvsroot/pgsql/src/include/executor/spi_priv.h,v 1.2 1999/02/13 23:21:29 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/include/executor/spi_priv.h,v 1.3 1999/05/13 07:28:58 tgl Exp $
*
*-------------------------------------------------------------------------
*/
typedef struct
{
- QueryTreeList *qtlist; /* malloced */
+ List *qtlist;
uint32 processed; /* by Executor */
SPITupleTable *tuptable;
Portal portal; /* portal per procedure */
typedef struct
{
- QueryTreeList *qtlist;
+ List *qtlist;
List *ptlist;
int nargs;
Oid *argtypes;
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: planner.h,v 1.10 1999/02/13 23:21:51 momjian Exp $
+ * $Id: planner.h,v 1.11 1999/05/13 07:29:11 tgl Exp $
*
*-------------------------------------------------------------------------
*/
extern Plan *planner(Query *parse);
extern Plan *union_planner(Query *parse);
-extern void pg_checkretval(Oid rettype, QueryTreeList *querytree_list);
+extern void pg_checkretval(Oid rettype, List *querytree_list);
#endif /* PLANNER_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: analyze.h,v 1.5 1999/01/18 00:10:11 momjian Exp $
+ * $Id: analyze.h,v 1.6 1999/05/13 07:29:17 tgl Exp $
*
*-------------------------------------------------------------------------
*/
-extern QueryTreeList *parse_analyze(List *pl, ParseState *parentParseState);
+extern List *parse_analyze(List *pl, ParseState *parentParseState);
/***S*I***/
extern void create_select_list(Node *ptr, List **select_list, bool *unionall_present);
extern Node *A_Expr_to_Expr(Node *ptr, bool *intersect_present);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parse_node.h,v 1.11 1998/09/01 04:37:35 momjian Exp $
+ * $Id: parse_node.h,v 1.12 1999/05/13 07:29:19 tgl Exp $
*
*-------------------------------------------------------------------------
*/
#include
-typedef struct QueryTreeList
-{
- int len; /* number of queries */
- Query **qtrees;
-} QueryTreeList;
-
/* state information used during parse analysis */
typedef struct ParseState
{
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: parser.h,v 1.4 1998/09/01 04:37:42 momjian Exp $
+ * $Id: parser.h,v 1.5 1999/05/13 07:29:20 tgl Exp $
*
*-------------------------------------------------------------------------
*/
-extern QueryTreeList *parser(char *str, Oid *typev, int nargs);
+extern List *parser(char *str, Oid *typev, int nargs);
#endif /* PARSER_H */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: tcopprot.h,v 1.18 1999/04/20 02:19:55 tgl Exp $
+ * $Id: tcopprot.h,v 1.19 1999/05/13 07:29:22 tgl Exp $
*
* OLD COMMENTS
* This file was created so that other c files could get the two
#ifndef BOOTSTRAP_INCLUDE
extern List *pg_parse_and_plan(char *query_string, Oid *typev, int nargs,
- QueryTreeList **queryListP, CommandDest dest,
- bool aclOverride);
+ List **queryListP, CommandDest dest,
+ bool aclOverride);
extern void pg_exec_query(char *query_string);
extern void pg_exec_query_acl_override(char *query_string);
extern void
projects / postgresql.git / commitdiff