* outfuncs.c
* Output functions for Postgres tree nodes.
*
- * Portions Copyright (c) 1996-2006, PostgreSQL Global Development Group
+ * Portions Copyright (c) 1996-2007, PostgreSQL Global Development Group
* Portions Copyright (c) 1994, Regents of the University of California
*
*
* IDENTIFICATION
- * $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.288 2006/12/23 00:43:10 tgl Exp $
+ * $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.310 2007/06/11 01:16:22 tgl Exp $
*
* NOTES
* Every node type that can appear in stored rules' parsetrees *must*
* Stuff from plannodes.h
*/
+static void
+_outPlannedStmt(StringInfo str, PlannedStmt *node)
+{
+ WRITE_NODE_TYPE("PLANNEDSTMT");
+
+ WRITE_ENUM_FIELD(commandType, CmdType);
+ WRITE_BOOL_FIELD(canSetTag);
+ WRITE_NODE_FIELD(planTree);
+ WRITE_NODE_FIELD(rtable);
+ WRITE_NODE_FIELD(resultRelations);
+ WRITE_NODE_FIELD(utilityStmt);
+ WRITE_NODE_FIELD(intoClause);
+ WRITE_NODE_FIELD(subplans);
+ WRITE_BITMAPSET_FIELD(rewindPlanIDs);
+ WRITE_NODE_FIELD(returningLists);
+ WRITE_NODE_FIELD(rowMarks);
+ WRITE_INT_FIELD(nParamExec);
+}
+
/*
* print the basic stuff of all nodes that inherit from Plan
*/
WRITE_NODE_FIELD(initPlan);
WRITE_BITMAPSET_FIELD(extParam);
WRITE_BITMAPSET_FIELD(allParam);
- WRITE_INT_FIELD(nParamExec);
}
/*
_outScanInfo(str, (Scan *) node);
WRITE_NODE_FIELD(subplan);
+ WRITE_NODE_FIELD(subrtable);
}
static void
WRITE_NODE_TYPE("FUNCTIONSCAN");
_outScanInfo(str, (Scan *) node);
+
+ WRITE_NODE_FIELD(funcexpr);
+ WRITE_NODE_FIELD(funccolnames);
+ WRITE_NODE_FIELD(funccoltypes);
+ WRITE_NODE_FIELD(funccoltypmods);
}
static void
WRITE_NODE_TYPE("VALUESSCAN");
_outScanInfo(str, (Scan *) node);
+
+ WRITE_NODE_FIELD(values_lists);
}
static void
static void
_outMergeJoin(StringInfo str, MergeJoin *node)
{
+ int numCols;
+ int i;
+
WRITE_NODE_TYPE("MERGEJOIN");
_outJoinPlanInfo(str, (Join *) node);
WRITE_NODE_FIELD(mergeclauses);
- WRITE_NODE_FIELD(mergefamilies);
- WRITE_NODE_FIELD(mergestrategies);
+
+ numCols = list_length(node->mergeclauses);
+
+ appendStringInfo(str, " :mergeFamilies");
+ for (i = 0; i < numCols; i++)
+ appendStringInfo(str, " %u", node->mergeFamilies[i]);
+
+ appendStringInfo(str, " :mergeStrategies");
+ for (i = 0; i < numCols; i++)
+ appendStringInfo(str, " %d", node->mergeStrategies[i]);
+
+ appendStringInfo(str, " :mergeNullsFirst");
+ for (i = 0; i < numCols; i++)
+ appendStringInfo(str, " %d", (int) node->mergeNullsFirst[i]);
}
static void
appendStringInfo(str, " :grpColIdx");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %d", node->grpColIdx[i]);
+
+ appendStringInfo(str, " :grpOperators");
+ for (i = 0; i < node->numCols; i++)
+ appendStringInfo(str, " %u", node->grpOperators[i]);
}
static void
appendStringInfo(str, " :sortOperators");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %u", node->sortOperators[i]);
+
+ appendStringInfo(str, " :nullsFirst");
+ for (i = 0; i < node->numCols; i++)
+ appendStringInfo(str, " %s", booltostr(node->nullsFirst[i]));
}
static void
appendStringInfo(str, " :uniqColIdx");
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %d", node->uniqColIdx[i]);
+
+ appendStringInfo(str, " :uniqOperators");
+ for (i = 0; i < node->numCols; i++)
+ appendStringInfo(str, " %u", node->uniqOperators[i]);
}
static void
for (i = 0; i < node->numCols; i++)
appendStringInfo(str, " %d", node->dupColIdx[i]);
+ appendStringInfo(str, " :dupOperators");
+ for (i = 0; i < node->numCols; i++)
+ appendStringInfo(str, " %d", node->dupOperators[i]);
+
WRITE_INT_FIELD(flagColIdx);
}
WRITE_NODE_FIELD(alias);
}
+static void
+_outIntoClause(StringInfo str, IntoClause *node)
+{
+ WRITE_NODE_TYPE("INTOCLAUSE");
+
+ WRITE_NODE_FIELD(rel);
+ WRITE_NODE_FIELD(colNames);
+ WRITE_NODE_FIELD(options);
+ WRITE_ENUM_FIELD(onCommit, OnCommitAction);
+ WRITE_STRING_FIELD(tableSpaceName);
+}
+
static void
_outVar(StringInfo str, Var *node)
{
WRITE_NODE_TYPE("CONST");
WRITE_OID_FIELD(consttype);
+ WRITE_INT_FIELD(consttypmod);
WRITE_INT_FIELD(constlen);
WRITE_BOOL_FIELD(constbyval);
WRITE_BOOL_FIELD(constisnull);
{
WRITE_NODE_TYPE("ARRAYREF");
- WRITE_OID_FIELD(refrestype);
WRITE_OID_FIELD(refarraytype);
WRITE_OID_FIELD(refelemtype);
+ WRITE_INT_FIELD(reftypmod);
WRITE_NODE_FIELD(refupperindexpr);
WRITE_NODE_FIELD(reflowerindexpr);
WRITE_NODE_FIELD(refexpr);
WRITE_ENUM_FIELD(subLinkType, SubLinkType);
WRITE_NODE_FIELD(testexpr);
WRITE_NODE_FIELD(paramIds);
- WRITE_NODE_FIELD(plan);
WRITE_INT_FIELD(plan_id);
- WRITE_NODE_FIELD(rtable);
+ WRITE_OID_FIELD(firstColType);
WRITE_BOOL_FIELD(useHashTable);
WRITE_BOOL_FIELD(unknownEqFalse);
WRITE_NODE_FIELD(setParam);
WRITE_ENUM_FIELD(relabelformat, CoercionForm);
}
+static void
+_outCoerceViaIO(StringInfo str, CoerceViaIO *node)
+{
+ WRITE_NODE_TYPE("COERCEVIAIO");
+
+ WRITE_NODE_FIELD(arg);
+ WRITE_OID_FIELD(resulttype);
+ WRITE_ENUM_FIELD(coerceformat, CoercionForm);
+}
+
+static void
+_outArrayCoerceExpr(StringInfo str, ArrayCoerceExpr *node)
+{
+ WRITE_NODE_TYPE("ARRAYCOERCEEXPR");
+
+ WRITE_NODE_FIELD(arg);
+ WRITE_OID_FIELD(elemfuncid);
+ WRITE_OID_FIELD(resulttype);
+ WRITE_INT_FIELD(resulttypmod);
+ WRITE_BOOL_FIELD(isExplicit);
+ WRITE_ENUM_FIELD(coerceformat, CoercionForm);
+}
+
static void
_outConvertRowtypeExpr(StringInfo str, ConvertRowtypeExpr *node)
{
WRITE_NODE_FIELD(args);
}
+static void
+_outXmlExpr(StringInfo str, XmlExpr *node)
+{
+ WRITE_NODE_TYPE("XMLEXPR");
+
+ WRITE_ENUM_FIELD(op, XmlExprOp);
+ WRITE_STRING_FIELD(name);
+ WRITE_NODE_FIELD(named_args);
+ WRITE_NODE_FIELD(arg_names);
+ WRITE_NODE_FIELD(args);
+ WRITE_ENUM_FIELD(xmloption, XmlOptionType);
+ WRITE_OID_FIELD(type);
+ WRITE_INT_FIELD(typmod);
+}
+
static void
_outNullIfExpr(StringInfo str, NullIfExpr *node)
{
WRITE_ENUM_FIELD(booltesttype, BoolTestType);
}
-static void
-_outXmlExpr(StringInfo str, XmlExpr *node)
-{
- WRITE_NODE_TYPE("XMLEXPR");
-
- WRITE_ENUM_FIELD(op, XmlExprOp);
- WRITE_STRING_FIELD(name);
- WRITE_NODE_FIELD(named_args);
- WRITE_NODE_FIELD(args);
-}
-
static void
_outCoerceToDomain(StringInfo str, CoerceToDomain *node)
{
WRITE_INT_FIELD(typeMod);
}
+static void
+_outCurrentOfExpr(StringInfo str, CurrentOfExpr *node)
+{
+ WRITE_NODE_TYPE("CURRENTOFEXPR");
+
+ WRITE_UINT_FIELD(cvarno);
+ WRITE_STRING_FIELD(cursor_name);
+}
+
static void
_outTargetEntry(StringInfo str, TargetEntry *node)
{
_outJoinPathInfo(str, (JoinPath *) node);
WRITE_NODE_FIELD(path_mergeclauses);
- WRITE_NODE_FIELD(path_mergefamilies);
- WRITE_NODE_FIELD(path_mergestrategies);
WRITE_NODE_FIELD(outersortkeys);
WRITE_NODE_FIELD(innersortkeys);
}
WRITE_NODE_FIELD(path_hashclauses);
}
+static void
+_outPlannerGlobal(StringInfo str, PlannerGlobal *node)
+{
+ WRITE_NODE_TYPE("PLANNERGLOBAL");
+
+ /* NB: this isn't a complete set of fields */
+ WRITE_NODE_FIELD(paramlist);
+ WRITE_NODE_FIELD(subplans);
+ WRITE_NODE_FIELD(subrtables);
+ WRITE_BITMAPSET_FIELD(rewindPlanIDs);
+ WRITE_NODE_FIELD(finalrtable);
+}
+
static void
_outPlannerInfo(StringInfo str, PlannerInfo *node)
{
/* NB: this isn't a complete set of fields */
WRITE_NODE_FIELD(parse);
+ WRITE_NODE_FIELD(glob);
+ WRITE_UINT_FIELD(query_level);
WRITE_NODE_FIELD(join_rel_list);
- WRITE_NODE_FIELD(equi_key_list);
+ WRITE_NODE_FIELD(resultRelations);
+ WRITE_NODE_FIELD(returningLists);
+ WRITE_NODE_FIELD(init_plans);
+ WRITE_NODE_FIELD(eq_classes);
+ WRITE_NODE_FIELD(canon_pathkeys);
WRITE_NODE_FIELD(left_join_clauses);
WRITE_NODE_FIELD(right_join_clauses);
WRITE_NODE_FIELD(full_join_clauses);
WRITE_UINT_FIELD(pages);
WRITE_FLOAT_FIELD(tuples, "%.0f");
WRITE_NODE_FIELD(subplan);
+ WRITE_NODE_FIELD(subrtable);
WRITE_NODE_FIELD(baserestrictinfo);
WRITE_NODE_FIELD(joininfo);
+ WRITE_BOOL_FIELD(has_eclass_joins);
WRITE_BITMAPSET_FIELD(index_outer_relids);
WRITE_NODE_FIELD(index_inner_paths);
}
}
static void
-_outPathKeyItem(StringInfo str, PathKeyItem *node)
+_outEquivalenceClass(StringInfo str, EquivalenceClass *node)
{
- WRITE_NODE_TYPE("PATHKEYITEM");
+ /*
+ * To simplify reading, we just chase up to the topmost merged EC and
+ * print that, without bothering to show the merge-ees separately.
+ */
+ while (node->ec_merged)
+ node = node->ec_merged;
- WRITE_NODE_FIELD(key);
- WRITE_OID_FIELD(sortop);
+ WRITE_NODE_TYPE("EQUIVALENCECLASS");
+
+ WRITE_NODE_FIELD(ec_opfamilies);
+ WRITE_NODE_FIELD(ec_members);
+ WRITE_NODE_FIELD(ec_sources);
+ WRITE_NODE_FIELD(ec_derives);
+ WRITE_BITMAPSET_FIELD(ec_relids);
+ WRITE_BOOL_FIELD(ec_has_const);
+ WRITE_BOOL_FIELD(ec_has_volatile);
+ WRITE_BOOL_FIELD(ec_below_outer_join);
+ WRITE_BOOL_FIELD(ec_broken);
+}
+
+static void
+_outEquivalenceMember(StringInfo str, EquivalenceMember *node)
+{
+ WRITE_NODE_TYPE("EQUIVALENCEMEMBER");
+
+ WRITE_NODE_FIELD(em_expr);
+ WRITE_BITMAPSET_FIELD(em_relids);
+ WRITE_BOOL_FIELD(em_is_const);
+ WRITE_BOOL_FIELD(em_is_child);
+ WRITE_OID_FIELD(em_datatype);
+}
+
+static void
+_outPathKey(StringInfo str, PathKey *node)
+{
+ WRITE_NODE_TYPE("PATHKEY");
+
+ WRITE_NODE_FIELD(pk_eclass);
+ WRITE_OID_FIELD(pk_opfamily);
+ WRITE_INT_FIELD(pk_strategy);
+ WRITE_BOOL_FIELD(pk_nulls_first);
}
static void
WRITE_BITMAPSET_FIELD(left_relids);
WRITE_BITMAPSET_FIELD(right_relids);
WRITE_NODE_FIELD(orclause);
- WRITE_OID_FIELD(mergejoinoperator);
- WRITE_OID_FIELD(left_sortop);
- WRITE_OID_FIELD(right_sortop);
- WRITE_OID_FIELD(mergeopfamily);
- WRITE_NODE_FIELD(left_pathkey);
- WRITE_NODE_FIELD(right_pathkey);
+ /* don't write parent_ec, leads to infinite recursion in plan tree dump */
+ WRITE_NODE_FIELD(mergeopfamilies);
+ /* don't write left_ec, leads to infinite recursion in plan tree dump */
+ /* don't write right_ec, leads to infinite recursion in plan tree dump */
+ WRITE_NODE_FIELD(left_em);
+ WRITE_NODE_FIELD(right_em);
+ WRITE_BOOL_FIELD(outer_is_left);
WRITE_OID_FIELD(hashjoinoperator);
}
WRITE_NODE_TYPE("INNERINDEXSCANINFO");
WRITE_BITMAPSET_FIELD(other_relids);
WRITE_BOOL_FIELD(isouterjoin);
- WRITE_NODE_FIELD(best_innerpath);
+ WRITE_NODE_FIELD(cheapest_startup_innerpath);
+ WRITE_NODE_FIELD(cheapest_total_innerpath);
}
static void
WRITE_BITMAPSET_FIELD(min_righthand);
WRITE_BOOL_FIELD(is_full_join);
WRITE_BOOL_FIELD(lhs_strict);
+ WRITE_BOOL_FIELD(delay_upper_joins);
}
static void
WRITE_BITMAPSET_FIELD(lefthand);
WRITE_BITMAPSET_FIELD(righthand);
WRITE_NODE_FIELD(sub_targetlist);
+ WRITE_NODE_FIELD(in_operators);
}
static void
WRITE_OID_FIELD(parent_reloid);
}
+static void
+_outPlannerParamItem(StringInfo str, PlannerParamItem *node)
+{
+ WRITE_NODE_TYPE("PLANNERPARAMITEM");
+
+ WRITE_NODE_FIELD(item);
+ WRITE_UINT_FIELD(abslevel);
+}
+
/*****************************************************************************
*
* Stuff from parsenodes.h.
WRITE_NODE_FIELD(indexParams);
WRITE_NODE_FIELD(options);
WRITE_NODE_FIELD(whereClause);
- WRITE_NODE_FIELD(rangetable);
WRITE_BOOL_FIELD(unique);
WRITE_BOOL_FIELD(primary);
WRITE_BOOL_FIELD(isconstraint);
WRITE_NODE_TYPE("SELECT");
WRITE_NODE_FIELD(distinctClause);
- WRITE_NODE_FIELD(into);
- WRITE_NODE_FIELD(intoColNames);
- WRITE_NODE_FIELD(intoOptions);
- WRITE_ENUM_FIELD(intoOnCommit, OnCommitAction);
- WRITE_STRING_FIELD(intoTableSpaceName);
+ WRITE_NODE_FIELD(intoClause);
WRITE_NODE_FIELD(targetList);
WRITE_NODE_FIELD(fromClause);
WRITE_NODE_FIELD(whereClause);
WRITE_BOOL_FIELD(noWait);
}
+static void
+_outXmlSerialize(StringInfo str, XmlSerialize *node)
+{
+ WRITE_NODE_TYPE("XMLSERIALIZE");
+
+ WRITE_ENUM_FIELD(xmloption, XmlOptionType);
+ WRITE_NODE_FIELD(expr);
+ WRITE_NODE_FIELD(typename);
+}
+
static void
_outColumnDef(StringInfo str, ColumnDef *node)
{
WRITE_BOOL_FIELD(timezone);
WRITE_BOOL_FIELD(setof);
WRITE_BOOL_FIELD(pct_type);
- WRITE_INT_FIELD(typmod);
+ WRITE_NODE_FIELD(typmods);
+ WRITE_INT_FIELD(typemod);
WRITE_NODE_FIELD(arrayBounds);
WRITE_INT_FIELD(location);
}
WRITE_STRING_FIELD(name);
WRITE_NODE_FIELD(expr);
WRITE_NODE_FIELD(opclass);
+ WRITE_ENUM_FIELD(ordering, SortByDir);
+ WRITE_ENUM_FIELD(nulls_ordering, SortByNulls);
}
static void
appendStringInfo(str, " :utilityStmt <>");
WRITE_INT_FIELD(resultRelation);
- WRITE_NODE_FIELD(into);
- WRITE_NODE_FIELD(intoOptions);
- WRITE_ENUM_FIELD(intoOnCommit, OnCommitAction);
- WRITE_STRING_FIELD(intoTableSpaceName);
+ WRITE_NODE_FIELD(intoClause);
WRITE_BOOL_FIELD(hasAggs);
WRITE_BOOL_FIELD(hasSubLinks);
WRITE_NODE_FIELD(rtable);
WRITE_NODE_FIELD(limitCount);
WRITE_NODE_FIELD(rowMarks);
WRITE_NODE_FIELD(setOperations);
- WRITE_NODE_FIELD(resultRelations);
- WRITE_NODE_FIELD(returningLists);
}
static void
WRITE_UINT_FIELD(tleSortGroupRef);
WRITE_OID_FIELD(sortop);
+ WRITE_BOOL_FIELD(nulls_first);
}
static void
WRITE_UINT_FIELD(tleSortGroupRef);
WRITE_OID_FIELD(sortop);
+ WRITE_BOOL_FIELD(nulls_first);
}
static void
appendStringInfoChar(str, '{');
switch (nodeTag(obj))
{
+ case T_PlannedStmt:
+ _outPlannedStmt(str, obj);
+ break;
case T_Plan:
_outPlan(str, obj);
break;
case T_RangeVar:
_outRangeVar(str, obj);
break;
+ case T_IntoClause:
+ _outIntoClause(str, obj);
+ break;
case T_Var:
_outVar(str, obj);
break;
case T_RelabelType:
_outRelabelType(str, obj);
break;
+ case T_CoerceViaIO:
+ _outCoerceViaIO(str, obj);
+ break;
+ case T_ArrayCoerceExpr:
+ _outArrayCoerceExpr(str, obj);
+ break;
case T_ConvertRowtypeExpr:
_outConvertRowtypeExpr(str, obj);
break;
case T_MinMaxExpr:
_outMinMaxExpr(str, obj);
break;
+ case T_XmlExpr:
+ _outXmlExpr(str, obj);
+ break;
case T_NullIfExpr:
_outNullIfExpr(str, obj);
break;
case T_BooleanTest:
_outBooleanTest(str, obj);
break;
- case T_XmlExpr:
- _outXmlExpr(str, obj);
- break;
case T_CoerceToDomain:
_outCoerceToDomain(str, obj);
break;
case T_SetToDefault:
_outSetToDefault(str, obj);
break;
+ case T_CurrentOfExpr:
+ _outCurrentOfExpr(str, obj);
+ break;
case T_TargetEntry:
_outTargetEntry(str, obj);
break;
case T_HashPath:
_outHashPath(str, obj);
break;
+ case T_PlannerGlobal:
+ _outPlannerGlobal(str, obj);
+ break;
case T_PlannerInfo:
_outPlannerInfo(str, obj);
break;
case T_IndexOptInfo:
_outIndexOptInfo(str, obj);
break;
- case T_PathKeyItem:
- _outPathKeyItem(str, obj);
+ case T_EquivalenceClass:
+ _outEquivalenceClass(str, obj);
+ break;
+ case T_EquivalenceMember:
+ _outEquivalenceMember(str, obj);
+ break;
+ case T_PathKey:
+ _outPathKey(str, obj);
break;
case T_RestrictInfo:
_outRestrictInfo(str, obj);
case T_AppendRelInfo:
_outAppendRelInfo(str, obj);
break;
+ case T_PlannerParamItem:
+ _outPlannerParamItem(str, obj);
+ break;
case T_CreateStmt:
_outCreateStmt(str, obj);
case T_LockingClause:
_outLockingClause(str, obj);
break;
+ case T_XmlSerialize:
+ _outXmlSerialize(str, obj);
+ break;
default:
projects / postgresql / blobdiff