*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.72 1999/02/03 21:15:54 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/catalog/heap.c,v 1.73 1999/02/09 17:02:42 momjian Exp $
*
*
* INTERFACE ROUTINES
* array */
} TempRelList;
-#define TEMP_REL_LIST_SIZE 32
+#define NONAME_REL_LIST_SIZE 32
static TempRelList *tempRels = NULL;
}
tempRels = (TempRelList *) malloc(sizeof(TempRelList));
- tempRels->size = TEMP_REL_LIST_SIZE;
+ tempRels->size = NONAME_REL_LIST_SIZE;
tempRels->rels = (Relation *) malloc(sizeof(Relation) * tempRels->size);
MemSet(tempRels->rels, 0, sizeof(Relation) * tempRels->size);
tempRels->num = 0;
if (tempRels->num == tempRels->size)
{
- tempRels->size += TEMP_REL_LIST_SIZE;
+ tempRels->size += NONAME_REL_LIST_SIZE;
tempRels->rels = realloc(tempRels->rels,
sizeof(Relation) * tempRels->size);
}
*
* Copyright (c) 1994-5, Regents of the University of California
*
- * $Id: explain.c,v 1.30 1998/12/18 14:45:07 wieck Exp $
+ * $Id: explain.c,v 1.31 1999/02/09 17:02:43 momjian Exp $
*
*/
#include
case T_IndexScan:
pname = "Index Scan";
break;
- case T_Temp:
- pname = "Temp Scan";
+ case T_Noname:
+ pname = "Noname Scan";
break;
case T_Sort:
pname = "Sort";
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: execAmi.c,v 1.30 1999/02/02 03:44:23 momjian Exp $
+ * $Id: execAmi.c,v 1.31 1999/02/09 17:02:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "executor/nodeAppend.h"
#include "executor/nodeSubplan.h"
#include "executor/execdebug.h"
-#include "optimizer/internal.h" /* for _TEMP_RELATION_ID_ */
+#include "optimizer/internal.h" /* for _NONAME_RELATION_ID_ */
#include "access/genam.h"
#include "access/heapam.h"
#include "catalog/heap.h"
relDesc = NULL;
- if (relationOid == _TEMP_RELATION_ID_)
+ if (relationOid == _NONAME_RELATION_ID_)
{
/* ----------------
* create a temporary relation
- * (currently the planner always puts a _TEMP_RELATION_ID
+ * (currently the planner always puts a _NONAME_RELATION_ID
* in the relation argument so we expect this to be the case although
* it's possible that someday we'll get the name from
* from the range table.. -cim 10/12/89)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeMaterial.c,v 1.19 1999/02/03 21:16:14 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeMaterial.c,v 1.20 1999/02/09 17:02:44 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "executor/nodeMaterial.h"
#include "catalog/catalog.h"
#include "catalog/heap.h"
-#include "optimizer/internal.h" /* for _TEMP_RELATION_ID_ */
+#include "optimizer/internal.h" /* for _NONAME_RELATION_ID_ */
#include "access/heapam.h"
/* ----------------------------------------------------------------
/* ----------------
* ExecCreatR wants it's second argument to be an object id of
- * a relation in the range table or a _TEMP_RELATION_ID
+ * a relation in the range table or a _NONAME_RELATION_ID
* indicating that the relation is not in the range table.
*
* In the second case ExecCreatR creates a temp relation.
* ----------------
*/
/* len = ExecTargetListLength(node->plan.targetlist); */
- tempDesc = ExecCreatR(tupType, _TEMP_RELATION_ID_);
+ tempDesc = ExecCreatR(tupType, _NONAME_RELATION_ID_);
/* ----------------
* save the relation descriptor in the sortstate
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/executor/nodeSort.c,v 1.16 1998/09/01 03:22:30 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/executor/nodeSort.c,v 1.17 1999/02/09 17:02:45 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "catalog/catalog.h"
#include "catalog/heap.h"
#include "storage/bufmgr.h"
-#include "optimizer/internal.h" /* for _TEMP_RELATION_ID_ */
+#include "optimizer/internal.h" /* for _NONAME_RELATION_ID_ */
/* ----------------------------------------------------------------
* FormSortKeys(node)
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.64 1999/02/09 03:51:12 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/copyfuncs.c,v 1.65 1999/02/09 17:02:46 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* ----------------
- * CopyTempFields
+ * CopyNonameFields
*
- * This function copies the fields of the Temp node. It is used by
- * all the copy functions for classes which inherit from Temp.
+ * This function copies the fields of the Noname node. It is used by
+ * all the copy functions for classes which inherit from Noname.
* ----------------
*/
static void
-CopyTempFields(Temp *from, Temp *newnode)
+CopyNonameFields(Noname *from, Noname *newnode)
{
- newnode->tempid = from->tempid;
+ newnode->nonameid = from->nonameid;
newnode->keycount = from->keycount;
return;
}
/* ----------------
- * _copyTemp
+ * _copyNoname
* ----------------
*/
-static Temp *
-_copyTemp(Temp *from)
+static Noname *
+_copyNoname(Noname *from)
{
- Temp *newnode = makeNode(Temp);
+ Noname *newnode = makeNode(Noname);
/* ----------------
* copy node superclass fields
* ----------------
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
- CopyTempFields(from, newnode);
+ CopyNonameFields(from, newnode);
return newnode;
}
* ----------------
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
- CopyTempFields((Temp *) from, (Temp *) newnode);
+ CopyNonameFields((Noname *) from, (Noname *) newnode);
return newnode;
}
* ----------------
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
- CopyTempFields((Temp *) from, (Temp *) newnode);
+ CopyNonameFields((Noname *) from, (Noname *) newnode);
return newnode;
}
* ----------------
*/
CopyPlanFields((Plan *) from, (Plan *) newnode);
- CopyTempFields((Temp *) from, (Temp *) newnode);
+ CopyNonameFields((Noname *) from, (Noname *) newnode);
/* ----------------
* copy remainder of node
case T_HashJoin:
retval = _copyHashJoin(from);
break;
- case T_Temp:
- retval = _copyTemp(from);
+ case T_Noname:
+ retval = _copyNoname(from);
break;
case T_Material:
retval = _copyMaterial(from);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/Attic/freefuncs.c,v 1.3 1999/02/09 03:51:12 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/Attic/freefuncs.c,v 1.4 1999/02/09 17:02:49 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* ----------------
- * FreeTempFields
+ * FreeNonameFields
*
- * This function frees the fields of the Temp node. It is used by
- * all the free functions for classes which inherit node Temp.
+ * This function frees the fields of the Noname node. It is used by
+ * all the free functions for classes which inherit node Noname.
* ----------------
*/
static void
-FreeTempFields(Temp *node)
+FreeNonameFields(Noname *node)
{
return;
}
/* ----------------
- * _freeTemp
+ * _freeNoname
* ----------------
*/
static void
-_freeTemp(Temp *node)
+_freeNoname(Noname *node)
{
/* ----------------
* free node superclass fields
* ----------------
*/
FreePlanFields((Plan *) node);
- FreeTempFields(node);
+ FreeNonameFields(node);
pfree(node);
}
* ----------------
*/
FreePlanFields((Plan *) node);
- FreeTempFields((Temp *) node);
+ FreeNonameFields((Noname *) node);
pfree(node);
}
* ----------------
*/
FreePlanFields((Plan *) node);
- FreeTempFields((Temp *) node);
+ FreeNonameFields((Noname *) node);
pfree(node);
}
* ----------------
*/
FreePlanFields((Plan *) node);
- FreeTempFields((Temp *) node);
+ FreeNonameFields((Noname *) node);
/* ----------------
* free remainder of node
case T_HashJoin:
_freeHashJoin(node);
break;
- case T_Temp:
- _freeTemp(node);
+ case T_Noname:
+ _freeNoname(node);
break;
case T_Material:
_freeMaterial(node);
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: outfuncs.c,v 1.66 1999/02/09 03:51:13 momjian Exp $
+ * $Id: outfuncs.c,v 1.67 1999/02/09 17:02:49 momjian Exp $
*
* NOTES
* Every (plan) node in POSTGRES has an associated "out" routine which
}
/*
- * Temp is a subclass of Plan
+ * Noname is a subclass of Plan
*/
static void
-_outTemp(StringInfo str, Temp *node)
+_outNoname(StringInfo str, Noname *node)
{
- appendStringInfo(str, " TEMP ");
+ appendStringInfo(str, " NONAME ");
_outPlanInfo(str, (Plan *) node);
- appendStringInfo(str, " :tempid %u :keycount %d ",
- node->tempid,
+ appendStringInfo(str, " :nonameid %u :keycount %d ",
+ node->nonameid,
node->keycount);
}
/*
- * Sort is a subclass of Temp
+ * Sort is a subclass of Noname
*/
static void
_outSort(StringInfo str, Sort *node)
appendStringInfo(str, " SORT ");
_outPlanInfo(str, (Plan *) node);
- appendStringInfo(str, " :tempid %u :keycount %d ",
- node->tempid,
+ appendStringInfo(str, " :nonameid %u :keycount %d ",
+ node->nonameid,
node->keycount);
}
}
/*
- * For some reason, unique is a subclass of Temp.
+ * For some reason, unique is a subclass of Noname.
*/
static void
_outUnique(StringInfo str, Unique *node)
appendStringInfo(str, " UNIQUE ");
_outPlanInfo(str, (Plan *) node);
- appendStringInfo(str, " :tempid %u :keycount %d ",
- node->tempid,
+ appendStringInfo(str, " :nonameid %u :keycount %d ",
+ node->nonameid,
node->keycount);
}
/*
- * Hash is a subclass of Temp
+ * Hash is a subclass of Noname
*/
static void
_outHash(StringInfo str, Hash *node)
case T_IndexScan:
_outIndexScan(str, obj);
break;
- case T_Temp:
- _outTemp(str, obj);
+ case T_Noname:
+ _outNoname(str, obj);
break;
case T_Sort:
_outSort(str, obj);
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/print.c,v 1.19 1999/01/27 00:36:28 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/print.c,v 1.20 1999/02/09 17:02:49 momjian Exp $
*
* HISTORY
* AUTHOR DATE MAJOR EVENT
case T_HashJoin:
return "HASHJOIN";
break;
- case T_Temp:
- return "TEMP";
+ case T_Noname:
+ return "NONAME";
break;
case T_Material:
return "MATERIAL";
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.51 1999/02/09 03:51:13 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/nodes/readfuncs.c,v 1.52 1999/02/09 17:02:50 momjian Exp $
*
* NOTES
* Most of the read functions for plan nodes are tested. (In fact, they
}
/* ----------------
- * _readTemp
+ * _readNoname
*
- * Temp is a subclass of Plan
+ * Noname is a subclass of Plan
* ----------------
*/
-static Temp *
-_readTemp()
+static Noname *
+_readNoname()
{
- Temp *local_node;
+ Noname *local_node;
char *token;
int length;
- local_node = makeNode(Temp);
+ local_node = makeNode(Noname);
_getPlan((Plan *) local_node);
- token = lsptok(NULL, &length); /* eat :tempid */
- token = lsptok(NULL, &length); /* get tempid */
- local_node->tempid = atol(token);
+ token = lsptok(NULL, &length); /* eat :nonameid */
+ token = lsptok(NULL, &length); /* get nonameid */
+ local_node->nonameid = atol(token);
token = lsptok(NULL, &length); /* eat :keycount */
token = lsptok(NULL, &length); /* get keycount */
/* ----------------
* _readSort
*
- * Sort is a subclass of Temp
+ * Sort is a subclass of Noname
* ----------------
*/
static Sort *
_getPlan((Plan *) local_node);
- token = lsptok(NULL, &length); /* eat :tempid */
- token = lsptok(NULL, &length); /* get tempid */
- local_node->tempid = atol(token);
+ token = lsptok(NULL, &length); /* eat :nonameid */
+ token = lsptok(NULL, &length); /* get nonameid */
+ local_node->nonameid = atol(token);
token = lsptok(NULL, &length); /* eat :keycount */
token = lsptok(NULL, &length); /* get keycount */
/* ----------------
* _readUnique
*
- * For some reason, unique is a subclass of Temp.
+ * For some reason, unique is a subclass of Noname.
*/
static Unique *
_readUnique()
_getPlan((Plan *) local_node);
- token = lsptok(NULL, &length); /* eat :tempid */
- token = lsptok(NULL, &length); /* get :tempid */
- local_node->tempid = atol(token);
+ token = lsptok(NULL, &length); /* eat :nonameid */
+ token = lsptok(NULL, &length); /* get :nonameid */
+ local_node->nonameid = atol(token);
token = lsptok(NULL, &length); /* eat :keycount */
token = lsptok(NULL, &length); /* get :keycount */
/* ----------------
* _readHash
*
- * Hash is a subclass of Temp
+ * Hash is a subclass of Noname
* ----------------
*/
static Hash *
return_value = _readSeqScan();
else if (!strncmp(token, "INDEXSCAN", length))
return_value = _readIndexScan();
- else if (!strncmp(token, "TEMP", length))
- return_value = _readTemp();
+ else if (!strncmp(token, "NONAME", length))
+ return_value = _readNoname();
else if (!strncmp(token, "SORT", length))
return_value = _readSort();
else if (!strncmp(token, "AGGREG", length))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.26 1999/02/03 20:15:32 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/costsize.c,v 1.27 1999/02/09 17:02:52 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* cost of sequentially scanning a materialized temporary relation
*/
- temp += _TEMP_SCAN_COST_;
+ temp += _NONAME_SCAN_COST_;
}
else
{
numTuples * base_log((double) pages, (double) 2.0);
if (!noread)
- temp = temp + cost_seqscan(_TEMP_RELATION_ID_, npages, tuples);
+ temp = temp + cost_seqscan(_NONAME_RELATION_ID_, npages, tuples);
Assert(temp >= 0);
return temp;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/joinutils.c,v 1.12 1999/02/09 03:51:20 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/path/Attic/joinutils.c,v 1.13 1999/02/09 17:02:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
foreach(i, outer_pathkeys)
{
outer_pathkey = lfirst(i);
- x = new_join_pathkey(outer_pathkey, NIL,
- join_rel_tlist, joinclauses);
+ x = new_join_pathkey(outer_pathkey, NIL, join_rel_tlist, joinclauses);
if (x != NIL)
t_list = lappend(t_list, x);
}
foreach(i, joinclauses)
{
joinclause = lfirst(i);
- tlist_other_var = matching_tlvar(other_join_clause_var(subkey, joinclause),
- join_rel_tlist);
+ tlist_other_var = matching_tlvar(
+ other_join_clause_var(subkey, joinclause),
+ join_rel_tlist);
if (tlist_other_var &&
!(member(tlist_other_var, considered_subkeys)))
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.39 1999/02/09 03:51:21 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/createplan.c,v 1.40 1999/02/09 17:02:55 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "optimizer/internal.h"
-#define TEMP_SORT 1
-#define TEMP_MATERIAL 2
+#define NONAME_SORT 1
+#define NONAME_MATERIAL 2
static List *switch_outer(List *clauses);
static Scan *create_scan_node(Path *best_path, List *tlist);
List *clauses, Plan *outer_node, List *outer_tlist,
Plan *inner_node, List *inner_tlist);
static Node *fix_indxqual_references(Node *clause, Path *index_path);
-static Temp *make_temp(List *tlist, List *keys, Oid *operators,
- Plan *plan_node, int temptype);
+static Noname *make_noname(List *tlist, List *keys, Oid *operators,
+ Plan *plan_node, int nonametype);
static IndexScan *make_indexscan(List *qptlist, List *qpqual, Index scanrelid,
List *indxid, List *indxqual, List *indxqualorig, Cost cost);
static NestLoop *make_nestloop(List *qptlist, List *qpqual, Plan *lefttree,
static MergeJoin *make_mergejoin(List *tlist, List *qpqual,
List *mergeclauses, Oid opcode, Oid *rightorder,
Oid *leftorder, Plan *righttree, Plan *lefttree);
-static Material *make_material(List *tlist, Oid tempid, Plan *lefttree,
+static Material *make_material(List *tlist, Oid nonameid, Plan *lefttree,
int keycount);
/*
}
else if (IsA_Join(inner_node))
{
- inner_node = (Plan *) make_temp(inner_tlist,
+ inner_node = (Plan *) make_noname(inner_tlist,
NIL,
NULL,
inner_node,
- TEMP_MATERIAL);
+ NONAME_MATERIAL);
}
join_node = make_nestloop(tlist,
*/
if (best_path->outersortkeys)
{
- Temp *sorted_outer_node = make_temp(outer_tlist,
+ Noname *sorted_outer_node = make_noname(outer_tlist,
best_path->outersortkeys,
outer_order,
outer_node,
- TEMP_SORT);
+ NONAME_SORT);
sorted_outer_node->plan.cost = outer_node->cost;
outer_node = (Plan *) sorted_outer_node;
if (best_path->innersortkeys)
{
- Temp *sorted_inner_node = make_temp(inner_tlist,
+ Noname *sorted_inner_node = make_noname(inner_tlist,
best_path->innersortkeys,
inner_order,
inner_node,
- TEMP_SORT);
+ NONAME_SORT);
sorted_inner_node->plan.cost = outer_node->cost;
inner_node = (Plan *) sorted_inner_node;
}
/*
- * set-temp-tlist-operators--
+ * set-noname-tlist-operators--
* Sets the key and keyop fields of resdom nodes in a target list.
*
* 'tlist' is the target list
* Returns the modified target list.
*/
static List *
-set_temp_tlist_operators(List *tlist, List *pathkeys, Oid *operators)
+set_noname_tlist_operators(List *tlist, List *pathkeys, Oid *operators)
{
Node *keys = NULL;
int keyno = 1;
*****************************************************************************/
/*
- * make_temp--
- * Create plan nodes to sort or materialize relations into temporaries. The
+ * make_noname--
+ * Create plan nodes to sort or materialize relations into noname. The
* result returned for a sort will look like (SEQSCAN(SORT(plan-node)))
* or (SEQSCAN(MATERIAL(plan-node)))
*
* 'operators' is the operators with which the sort or hash is to be done
* (a list of operator OIDs)
* 'plan-node' is the node which yields tuples for the sort
- * 'temptype' indicates which operation(sort or hash) to perform
+ * 'nonametype' indicates which operation(sort or hash) to perform
*/
-static Temp *
-make_temp(List *tlist,
+static Noname *
+make_noname(List *tlist,
List *keys,
Oid *operators,
Plan *plan_node,
- int temptype)
+ int nonametype)
{
- List *temp_tlist;
- Temp *retval = NULL;
+ List *noname_tlist;
+ Noname *retval = NULL;
- /* Create a new target list for the temporary, with keys set. */
- temp_tlist = set_temp_tlist_operators(new_unsorted_tlist(tlist),
+ /* Create a new target list for the noname, with keys set. */
+ noname_tlist = set_noname_tlist_operators(new_unsorted_tlist(tlist),
keys,
operators);
- switch (temptype)
+ switch (nonametype)
{
- case TEMP_SORT:
- retval = (Temp *) make_seqscan(tlist,
+ case NONAME_SORT:
+ retval = (Noname *) make_seqscan(tlist,
NIL,
- _TEMP_RELATION_ID_,
- (Plan *) make_sort(temp_tlist,
- _TEMP_RELATION_ID_,
+ _NONAME_RELATION_ID_,
+ (Plan *) make_sort(noname_tlist,
+ _NONAME_RELATION_ID_,
plan_node,
length(keys)));
break;
- case TEMP_MATERIAL:
- retval = (Temp *) make_seqscan(tlist,
+ case NONAME_MATERIAL:
+ retval = (Noname *) make_seqscan(tlist,
NIL,
- _TEMP_RELATION_ID_,
- (Plan *) make_material(temp_tlist,
- _TEMP_RELATION_ID_,
+ _NONAME_RELATION_ID_,
+ (Plan *) make_material(noname_tlist,
+ _NONAME_RELATION_ID_,
plan_node,
length(keys)));
break;
default:
- elog(ERROR, "make_temp: unknown temp type %d", temptype);
+ elog(ERROR, "make_noname: unknown noname type %d", nonametype);
}
return retval;
}
Sort *
-make_sort(List *tlist, Oid tempid, Plan *lefttree, int keycount)
+make_sort(List *tlist, Oid nonameid, Plan *lefttree, int keycount)
{
Sort *node = makeNode(Sort);
Plan *plan = &node->plan;
plan->qual = NIL;
plan->lefttree = lefttree;
plan->righttree = NULL;
- node->tempid = tempid;
+ node->nonameid = nonameid;
node->keycount = keycount;
return node;
static Material *
make_material(List *tlist,
- Oid tempid,
+ Oid nonameid,
Plan *lefttree,
int keycount)
{
plan->qual = NIL;
plan->lefttree = lefttree;
plan->righttree = NULL;
- node->tempid = tempid;
+ node->nonameid = nonameid;
node->keycount = keycount;
return node;
plan->qual = NIL;
plan->lefttree = lefttree;
plan->righttree = NULL;
- node->tempid = _TEMP_RELATION_ID_;
+ node->nonameid = _NONAME_RELATION_ID_;
node->keycount = 0;
if (strcmp(uniqueAttr, "*") == 0)
node->uniqueAttr = NULL;
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.29 1998/10/01 02:03:59 tgl Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planmain.c,v 1.30 1999/02/09 17:03:00 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
sortplan = make_sort(sort_tlist,
- _TEMP_RELATION_ID_,
+ _NONAME_RELATION_ID_,
subplan,
numCols);
sortplan->plan.cost = subplan->cost; /* XXX assume no cost */
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.42 1999/02/03 21:16:36 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/planner.c,v 1.43 1999/02/09 17:03:01 momjian Exp $
*
*-------------------------------------------------------------------------
*/
}
sortplan = (Plan *) make_sort(temp_tlist,
- _TEMP_RELATION_ID_,
+ _NONAME_RELATION_ID_,
(Plan *) plannode,
length(sortcls));
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.37 1999/02/03 21:16:38 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/plan/setrefs.c,v 1.38 1999/02/09 17:03:01 momjian Exp $
*
*-------------------------------------------------------------------------
*/
#include "optimizer/tlist.h"
static void set_join_tlist_references(Join *join);
-static void set_tempscan_tlist_references(SeqScan *tempscan);
-static void set_temp_tlist_references(Temp *temp);
+static void set_nonamescan_tlist_references(SeqScan *nonamescan);
+static void set_noname_tlist_references(Noname *noname);
static List *replace_clause_joinvar_refs(Expr *clause,
List *outer_tlist, List *inner_tlist);
static List *replace_subclause_joinvar_refs(List *clauses,
List *outer_tlist, List *inner_tlist);
static Var *replace_joinvar_refs(Var *var, List *outer_tlist, List *inner_tlist);
-static List *tlist_temp_references(Oid tempid, List *tlist);
+static List *tlist_noname_references(Oid nonameid, List *tlist);
static void replace_result_clause(Node *clause, List *subplanTargetList);
static bool OperandIsInner(Node *opnd, int inner_relid);
static List *replace_agg_clause(Node *expr, List *targetlist);
if (IsA_Join(plan))
set_join_tlist_references((Join *) plan);
else if (IsA(plan, SeqScan) &&plan->lefttree &&
- IsA_Temp(plan->lefttree))
- set_tempscan_tlist_references((SeqScan *) plan);
+ IsA_Noname(plan->lefttree))
+ set_nonamescan_tlist_references((SeqScan *) plan);
else if (IsA(plan, Sort))
- set_temp_tlist_references((Temp *) plan);
+ set_noname_tlist_references((Noname *) plan);
else if (IsA(plan, Result))
set_result_tlist_references((Result *) plan);
else if (IsA(plan, Hash))
}
/*
- * set-tempscan-tlist-references--
- * Modifies the target list of a node that scans a temp relation (i.e., a
- * sort or hash node) so that the varnos refer to the child temporary.
+ * set-nonamescan-tlist-references--
+ * Modifies the target list of a node that scans a noname relation (i.e., a
+ * sort or hash node) so that the varnos refer to the child noname.
*
- * 'tempscan' is a seqscan node
+ * 'nonamescan' is a seqscan node
*
* Returns nothing of interest, but modifies internal fields of nodes.
*
*/
static void
-set_tempscan_tlist_references(SeqScan *tempscan)
+set_nonamescan_tlist_references(SeqScan *nonamescan)
{
- Temp *temp = (Temp *) ((Plan *) tempscan)->lefttree;
+ Noname *noname = (Noname *) ((Plan *) nonamescan)->lefttree;
- ((Plan *) tempscan)->targetlist = tlist_temp_references(temp->tempid,
- ((Plan *) tempscan)->targetlist);
- set_temp_tlist_references(temp);
+ ((Plan *) nonamescan)->targetlist = tlist_noname_references(noname->nonameid,
+ ((Plan *) nonamescan)->targetlist);
+ set_noname_tlist_references(noname);
}
/*
- * set-temp-tlist-references--
- * The temp's vars are made consistent with (actually, identical to) the
- * modified version of the target list of the node from which temp node
+ * set-noname-tlist-references--
+ * The noname's vars are made consistent with (actually, identical to) the
+ * modified version of the target list of the node from which noname node
* receives its tuples.
*
- * 'temp' is a temp (e.g., sort, hash) plan node
+ * 'noname' is a noname (e.g., sort, hash) plan node
*
* Returns nothing of interest, but modifies internal fields of nodes.
*
*/
static void
-set_temp_tlist_references(Temp *temp)
+set_noname_tlist_references(Noname *noname)
{
- Plan *source = ((Plan *) temp)->lefttree;
+ Plan *source = ((Plan *) noname)->lefttree;
if (source != NULL)
{
set_tlist_references(source);
- ((Plan *) temp)->targetlist = copy_vars(((Plan *) temp)->targetlist,
+ ((Plan *) noname)->targetlist = copy_vars(((Plan *) noname)->targetlist,
(source)->targetlist);
}
else
- elog(ERROR, "calling set_temp_tlist_references with empty lefttree");
+ elog(ERROR, "calling set_noname_tlist_references with empty lefttree");
}
/*
}
/*
- * tlist-temp-references--
- * Creates a new target list for a node that scans a temp relation,
- * setting the varnos to the id of the temp relation and setting varids
+ * tlist-noname-references--
+ * Creates a new target list for a node that scans a noname relation,
+ * setting the varnos to the id of the noname relation and setting varids
* if necessary (varids are only needed if this is a targetlist internal
* to the tree, in which case the targetlist entry always contains a var
- * node, so we can just copy it from the temp).
+ * node, so we can just copy it from the noname).
*
- * 'tempid' is the id of the temp relation
+ * 'nonameid' is the id of the noname relation
* 'tlist' is the target list to be modified
*
* Returns new target list
*
*/
static List *
-tlist_temp_references(Oid tempid,
+tlist_noname_references(Oid nonameid,
List *tlist)
{
List *t_list = NIL;
- TargetEntry *temp = (TargetEntry *) NULL;
+ TargetEntry *noname = (TargetEntry *) NULL;
TargetEntry *xtl = NULL;
List *entry;
else
oattno = 0;
- temp = makeTargetEntry(xtl->resdom,
- (Node *) makeVar(tempid,
+ noname = makeTargetEntry(xtl->resdom,
+ (Node *) makeVar(nonameid,
xtl->resdom->resno,
xtl->resdom->restype,
xtl->resdom->restypmod,
0,
- tempid,
+ nonameid,
oattno));
- t_list = lappend(t_list, temp);
+ t_list = lappend(t_list, noname);
}
return t_list;
}
*
*
* IDENTIFICATION
- * $Header: /cvsroot/pgsql/src/backend/optimizer/util/relnode.c,v 1.10 1999/02/03 20:15:43 momjian Exp $
+ * $Header: /cvsroot/pgsql/src/backend/optimizer/util/relnode.c,v 1.11 1999/02/09 17:03:01 momjian Exp $
*
*-------------------------------------------------------------------------
*/
* If the relation is a materialized relation, assume
* constants for sizes.
*/
- rel->pages = _TEMP_RELATION_PAGES_;
- rel->tuples = _TEMP_RELATION_TUPLES_;
+ rel->pages = _NONAME_RELATION_PAGES_;
+ rel->tuples = _NONAME_RELATION_TUPLES_;
}
else
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: nodes.h,v 1.40 1999/02/09 03:51:41 momjian Exp $
+ * $Id: nodes.h,v 1.41 1999/02/09 17:03:11 momjian Exp $
*
*-------------------------------------------------------------------------
*/
T_NestLoop,
T_MergeJoin,
T_HashJoin,
- T_Temp,
+ T_Noname,
T_Material,
T_Sort,
T_Agg,
(nodeTag(j)==T_Join || nodeTag(j)==T_NestLoop || \
nodeTag(j)==T_MergeJoin || nodeTag(j)==T_HashJoin)
-#define IsA_Temp(t) \
- (nodeTag(t)==T_Temp || nodeTag(t)==T_Material || nodeTag(t)==T_Sort || \
+#define IsA_Noname(t) \
+ (nodeTag(t)==T_Noname || nodeTag(t)==T_Material || nodeTag(t)==T_Sort || \
nodeTag(t)==T_Unique)
/* ----------------------------------------------------------------
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: plannodes.h,v 1.20 1999/01/23 23:28:09 momjian Exp $
+ * $Id: plannodes.h,v 1.21 1999/02/09 17:03:12 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/*
* ==========
- * Temp nodes
+ * Noname nodes
* ==========
*/
-typedef struct Temp
+typedef struct Noname
{
Plan plan;
- Oid tempid;
+ Oid nonameid;
int keycount;
-} Temp;
+} Noname;
/* ----------------
* materialization node
*/
typedef struct Material
{
- Plan plan; /* temp node flattened out */
- Oid tempid;
+ Plan plan; /* noname node flattened out */
+ Oid nonameid;
int keycount;
MaterialState *matstate;
} Material;
*/
typedef struct Sort
{
- Plan plan; /* temp node flattened out */
- Oid tempid;
+ Plan plan; /* noname node flattened out */
+ Oid nonameid;
int keycount;
SortState *sortstate;
void *psortstate;
*/
typedef struct Unique
{
- Plan plan; /* temp node flattened out */
- Oid tempid;
+ Plan plan; /* noname node flattened out */
+ Oid nonameid;
int keycount;
char *uniqueAttr; /* NULL if all attrs, or unique attribute
* name */
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: internal.h,v 1.12 1999/02/02 03:45:24 momjian Exp $
+ * $Id: internal.h,v 1.13 1999/02/09 17:03:14 momjian Exp $
*
*-------------------------------------------------------------------------
*/
/* The cost of sequentially scanning a materialized temporary relation
*/
-#define _TEMP_SCAN_COST_ 10
+#define _NONAME_SCAN_COST_ 10
/* The number of pages and tuples in a materialized relation
*/
-#define _TEMP_RELATION_PAGES_ 1
-#define _TEMP_RELATION_TUPLES_ 10
+#define _NONAME_RELATION_PAGES_ 1
+#define _NONAME_RELATION_TUPLES_ 10
/* The length of a variable-length field in bytes
*/
/* Identifier for (sort) temp relations */
/* used to be -1 */
-#define _TEMP_RELATION_ID_ InvalidOid
+#define _NONAME_RELATION_ID_ InvalidOid
/* Identifier for invalid relation OIDs and attribute numbers for use by
* selectivity functions
*
* Copyright (c) 1994, Regents of the University of California
*
- * $Id: planmain.h,v 1.19 1999/02/02 17:46:16 momjian Exp $
+ * $Id: planmain.h,v 1.20 1999/02/09 17:03:14 momjian Exp $
*
*-------------------------------------------------------------------------
*/
extern Plan *create_plan(Path *best_path);
extern SeqScan *make_seqscan(List *qptlist, List *qpqual, Index scanrelid,
Plan *lefttree);
-extern Sort *make_sort(List *tlist, Oid tempid, Plan *lefttree,
+extern Sort *make_sort(List *tlist, Oid nonameid, Plan *lefttree,
int keycount);
extern Agg *make_agg(List *tlist, Plan *lefttree);
extern Group *make_group(List *tlist, bool tuplePerGroup, int ngrp,
projects / postgresql.git / commitdiff