1 /*-------------------------------------------------------------------------
4 * Output functions for Postgres tree nodes.
6 * Portions Copyright (c) 2003-2008, PgPool Global Development Group
7 * Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
8 * Portions Copyright (c) 1994, Regents of the University of California
12 * $PostgreSQL: pgsql/src/backend/nodes/outfuncs.c,v 1.261.2.1 2005/11/14 23:54:34 tgl Exp $
15 * Every node type that can appear in stored rules' parsetrees *must*
16 * have an output function defined here (as well as an input function
17 * in readfuncs.c). For use in debugging, we also provide output
18 * functions for nodes that appear in raw parsetrees, path, and plan trees.
19 * These nodes however need not have input functions.
21 *-------------------------------------------------------------------------
26 #include "pool_memory.h"
28 #include "pool_string.h"
30 #include "parsenodes.h"
32 #define booltostr(x) ((x) ? "true" : "false")
34 void _outNode(String *str, void *obj);
35 static void _outList(String *str, List *node);
36 static void _outIdList(String *str, List *node);
37 static void _outAlias(String *str, Alias *node);
38 static void _outRangeVar(String *str, RangeVar *node);
39 static void _outVar(String *str, Var *node);
40 static void _outConst(String *str, Const *node);
41 static void _outParam(String *str, Param *node);
42 static void _outAggref(String *str, Aggref *node);
43 static void _outArrayRef(String *str, ArrayRef *node);
44 static void _outFuncExpr(String *str, FuncExpr *node);
45 static void _outOpExpr(String *str, OpExpr *node);
46 static void _outDistinctExpr(String *str, DistinctExpr *node);
47 static void _outScalarArrayOpExpr(String *str, ScalarArrayOpExpr *node);
48 static void _outBoolExpr(String *str, BoolExpr *node);
49 static void _outSubLink(String *str, SubLink *node);
50 static void _outSubPlan(String *str, SubPlan *node);
51 static void _outFieldSelect(String *str, FieldSelect *node);
52 static void _outFieldStore(String *str, FieldStore *node);
53 static void _outRelabelType(String *str, RelabelType *node);
54 static void _outConvertRowtypeExpr(String *str, ConvertRowtypeExpr *node);
55 static void _outCaseExpr(String *str, CaseExpr *node);
56 static void _outCaseWhen(String *str, CaseWhen *node);
57 static void _outCaseTestExpr(String *str, CaseTestExpr *node);
58 static void _outArrayExpr(String *str, ArrayExpr *node);
59 static void _outRowExpr(String *str, RowExpr *node);
60 static void _outCoalesceExpr(String *str, CoalesceExpr *node);
61 static void _outMinMaxExpr(String *str, MinMaxExpr *node);
62 static void _outNullIfExpr(String *str, NullIfExpr *node);
63 static void _outNullTest(String *str, NullTest *node);
64 static void _outBooleanTest(String *str, BooleanTest *node);
65 static void _outCoerceToDomain(String *str, CoerceToDomain *node);
66 static void _outCoerceToDomainValue(String *str, CoerceToDomainValue *node);
67 static void _outSetToDefault(String *str, SetToDefault *node);
68 static void _outTargetEntry(String *str, TargetEntry *node);
69 static void _outRangeTblRef(String *str, RangeTblRef *node);
70 static void _outJoinExpr(String *str, JoinExpr *node);
71 static void _outFromExpr(String *str, FromExpr *node);
72 static void _outCreateStmt(String *str, CreateStmt *node);
73 static void _outIndexStmt(String *str, IndexStmt *node);
74 static void _outNotifyStmt(String *str, NotifyStmt *node);
75 static void _outDeclareCursorStmt(String *str, DeclareCursorStmt *node);
76 static void _outSelectStmt(String *str, SelectStmt *node);
77 static void _outFuncCall(String *str, FuncCall *node);
78 static void _outDefElem(String *str, DefElem *node);
79 static void _outLockingClause(String *str, LockingClause *node);
80 static void _outColumnDef(String *str, ColumnDef *node);
81 static void _outTypeName(String *str, TypeName *node);
82 static void _outTypeCast(String *str, TypeCast *node);
83 static void _outIndexElem(String *str, IndexElem *node);
84 static void _outSortClause(String *str, SortClause *node);
85 static void _outGroupClause(String *str, GroupClause *node);
86 static void _outSetOperationStmt(String *str, SetOperationStmt *node);
87 static void _outAExpr(String *str, A_Expr *node);
88 static void _outValue(String *str, Value *value);
89 static void _outColumnRef(String *str, ColumnRef *node);
90 static void _outParamRef(String *str, ParamRef *node);
91 static void _outAConst(String *str, A_Const *node);
92 static void _outA_Indices(String *str, A_Indices *node);
93 static void _outA_Indirection(String *str, A_Indirection *node);
94 static void _outResTarget(String *str, ResTarget *node);
95 static void _outConstraint(String *str, Constraint *node);
96 static void _outFkConstraint(String *str, FkConstraint *node);
98 static void _outSortBy(String *str, SortBy *node);
99 static void _outInsertStmt(String *str, InsertStmt *node);
100 static void _outUpdateStmt(String *str, UpdateStmt *node);
101 static void _outDeleteStmt(String *str, DeleteStmt *node);
102 static void _outTransactionStmt(String *str, TransactionStmt *node);
103 static void _outTruncateStmt(String *str, TruncateStmt *node);
104 static void _outVacuumStmt(String *str, VacuumStmt *node);
105 static void _outExplainStmt(String *str, ExplainStmt *node);
106 static void _outClusterStmt(String *str, ClusterStmt *node);
107 static void _outCheckPointStmt(String *str, CheckPointStmt *node);
108 static void _outClosePortalStmt(String *str, ClosePortalStmt *node);
109 static void _outListenStmt(String *str, ListenStmt *node);
110 static void _outUnlistenStmt(String *str, UnlistenStmt *node);
111 static void _outLoadStmt(String *str, LoadStmt *node);
112 static void _outCopyStmt(String *str, CopyStmt *node);
113 static void _outDeallocateStmt(String *str, DeallocateStmt *node);
114 static void _outRenameStmt(String *str, RenameStmt *node);
115 static void _outCreateRoleStmt(String *str, CreateRoleStmt *node);
116 static void _outAlterRoleStmt(String *str, AlterRoleStmt *node);
117 static void _outDropRoleStmt(String *str, DropRoleStmt *node);
118 static void _outCreateSchemaStmt(String *str, CreateSchemaStmt *node);
119 static void _outVariableSetStmt(String *str, VariableSetStmt *node);
120 static void _outVariableShowStmt(String *str, VariableShowStmt *node);
121 static void _outConstraintsSetStmt(String *str, ConstraintsSetStmt *node);
122 static void _outAlterTableStmt(String *str, AlterTableStmt *node);
123 static void _outCreateSeqStmt(String *str, CreateSeqStmt *node);
124 static void _outAlterSeqStmt(String *str, AlterSeqStmt *node);
125 static void _outCreatePLangStmt(String *str, CreatePLangStmt *node);
126 static void _outDropPLangStmt(String *str, DropPLangStmt *node);
127 static void _outCreateTableSpaceStmt(String *str, CreateTableSpaceStmt *node);
128 static void _outDropTableSpaceStmt(String *str, DropTableSpaceStmt *node);
129 static void _outCreateTrigStmt(String *str, CreateTrigStmt *node);
130 static void _outDropPropertyStmt(String *str, DropPropertyStmt *node);
131 static void _outDefineStmt(String *str, DefineStmt *node);
132 static void _outCreateOpClassStmt(String *str, CreateOpClassStmt *node);
133 static void _outRemoveOpClassStmt(String *str, RemoveOpClassStmt *node);
134 static void _outDropStmt(String *str, DropStmt *node);
135 static void _outFetchStmt(String *str, FetchStmt *node);
136 static void _outGrantStmt(String *str, GrantStmt *node);
137 static void _outGrantRoleStmt(String *str, GrantRoleStmt *node);
138 static void _outCreateFunctionStmt(String *str, CreateFunctionStmt *node);
139 static void _outAlterFunctionStmt(String *str, AlterFunctionStmt *node);
140 static void _outCreateCastStmt(String *str, CreateCastStmt *node);
141 static void _outDropCastStmt(String *str, DropCastStmt *node);
142 static void _outReindexStmt(String *str, ReindexStmt *node);
143 static void _outRuleStmt(String *str, RuleStmt *node);
144 static void _outViewStmt(String *str, ViewStmt *node);
145 static void _outCreatedbStmt(String *str, CreatedbStmt *node);
146 static void _outAlterDatabaseStmt(String *str, AlterDatabaseStmt *node);
147 static void _outAlterDatabaseSetStmt(String *str, AlterDatabaseSetStmt *node);
148 static void _outDropdbStmt(String *str, DropdbStmt *node);
149 static void _outCreateDomainStmt(String *str, CreateDomainStmt *node);
150 static void _outAlterDomainStmt(String *str, AlterDomainStmt *node);
151 static void _outCreateConversionStmt(String *str, CreateConversionStmt *node);
152 static void _outPrepareStmt(String *str, PrepareStmt *node);
153 static void _outExecuteStmt(String *str, ExecuteStmt *node);
154 static void _outLockStmt(String *str, LockStmt *node);
155 static void _outCommentStmt(String *str, CommentStmt *node);
156 static void _outDiscardStmt(String *str, DiscardStmt *node);
157 static void _outCreateOpFamilyStmt(String *str, CreateOpFamilyStmt *node);
158 static void _outAlterOpFamilyStmt(String *str, AlterOpFamilyStmt *node);
159 static void _outRemoveOpFamilyStmt(String *str, RemoveOpFamilyStmt *node);
160 static void _outCreateEnumStmt(String *str, CreateEnumStmt *node);
161 static void _outDropOwnedStmt(String *str, DropOwnedStmt *node);
162 static void _outReassignOwnedStmt(String *str, ReassignOwnedStmt *node);
163 static void _outAlterTSDictionaryStmt(String *str, AlterTSDictionaryStmt *node);
164 static void _outAlterTSConfigurationStmt(String *str, AlterTSConfigurationStmt *node);
165 static void _outXmlExpr(String *str, XmlExpr *node);
166 static void _outXmlSerialize(String *str, XmlSerialize *node);
168 static void _outFuncName(String *str, List *func_name);
169 static void _outSetRest(String *str, VariableSetStmt *node);
170 static void _outSetTransactionModeList(String *str, List *list);
171 static void _outAlterTableCmd(String *str, AlterTableCmd *node);
172 static void _outOptSeqList(String *str, List *options);
173 static void _outPrivGrantee(String *str, PrivGrantee *node);
174 static void _outPrivTarget(String *str, PrivTarget *node);
175 static void _outFuncWithArgs(String *str, FuncWithArgs *node);
176 static void _outFunctionParameter(String *str, FunctionParameter *node);
177 static void _outPrivilegeList(String *str, List *list);
178 static void _outFuncOptList(String *str, List *list);
179 static void _outCreatedbOptList(String *str, List *options);
180 static void _outOperatorArgTypes(String *str, List *args);
181 static void _outRangeFunction(String *str, RangeFunction *node);
182 static void _outInhRelation(String *str, InhRelation *node);
183 static void _outWithDefinition(String *str, List *def_list);
184 static void _outCurrentOfExpr(String *str, CurrentOfExpr *node);
186 static char *escape_string(char *str)
188 int len = strlen(str), i, j;
189 char *es = palloc0(len * 2 + 1);
196 for (i = 0, j = 0; i < len; i++, j++)
202 else if (str[i] == '\\')
212 static void _outIdList(String *str, List *node)
219 Value *v = lfirst(lc);
224 string_append_char(str, ", ");
226 string_append_char(str, "\"");
227 string_append_char(str, v->val.str);
228 string_append_char(str, "\"");
232 static void _outList(String *str, List *node)
243 if (!IsA(lfirst(lc), A_Indices))
244 string_append_char(str, ",");
246 _outNode(str, lfirst(lc));
252 /*****************************************************************************
254 * Stuff from primnodes.h.
256 *****************************************************************************/
259 _outAlias(String *str, Alias *node)
261 string_append_char(str, " AS \"");
262 string_append_char(str, node->aliasname);
263 string_append_char(str, "\"");
267 string_append_char(str, "(");
268 _outNode(str, node->colnames);
269 string_append_char(str, ")");
274 _outRangeVar(String *str, RangeVar *node)
276 if (node->catalogname)
278 string_append_char(str, "\"");
279 string_append_char(str, node->catalogname);
280 string_append_char(str, "\".");
283 if (node->schemaname)
285 string_append_char(str, "\"");
286 string_append_char(str, node->schemaname);
287 string_append_char(str, "\".");
290 string_append_char(str, "\"");
291 string_append_char(str, node->relname);
292 string_append_char(str, "\"");
295 _outNode(str, node->alias);
297 if (node->inhOpt == INH_YES)
299 string_append_char(str, " * ");
304 _outVar(String *str, Var *node)
310 _outConst(String *str, Const *node)
316 _outParam(String *str, Param *node)
322 _outAggref(String *str, Aggref *node)
328 _outArrayRef(String *str, ArrayRef *node)
333 _outFuncExpr(String *str, FuncExpr *node)
339 _outOpExpr(String *str, OpExpr *node)
345 _outDistinctExpr(String *str, DistinctExpr *node)
351 _outScalarArrayOpExpr(String *str, ScalarArrayOpExpr *node)
357 _outBoolExpr(String *str, BoolExpr *node)
363 _outSubLink(String *str, SubLink *node)
365 _outNode(str, node->testexpr);
367 if (node->operName != NIL)
369 Value *v = linitial(node->operName);
370 if (strcmp(v->val.str, "=") == 0)
371 string_append_char(str, " IN ");
374 string_append_char(str, v->val.str);
378 switch (node->subLinkType)
381 string_append_char(str, " EXISTS ");
385 string_append_char(str, " ARRAY ");
389 if (node->operName != NIL)
391 Value *v = linitial(node->operName);
392 if (strcmp(v->val.str, "=") != 0)
394 string_append_char(str, v->val.str);
395 string_append_char(str, " ANY ");
401 string_append_char(str, " ALL ");
411 string_append_char(str, "(");
412 _outNode(str, node->subselect);
413 string_append_char(str, ")");
418 _outSubPlan(String *str, SubPlan *node)
424 _outFieldSelect(String *str, FieldSelect *node)
430 _outFieldStore(String *str, FieldStore *node)
436 _outRelabelType(String *str, RelabelType *node)
442 _outConvertRowtypeExpr(String *str, ConvertRowtypeExpr *node)
448 _outCaseExpr(String *str, CaseExpr *node)
452 string_append_char(str, "CASE ");
454 _outNode(str, node->arg);
456 foreach (lc, node->args)
458 _outNode(str, lfirst(lc));
463 string_append_char(str, " ELSE ");
464 _outNode(str, node->defresult);
467 string_append_char(str, " END");
471 _outCaseWhen(String *str, CaseWhen *node)
473 string_append_char(str, " WHEN ");
474 _outNode(str, node->expr);
475 string_append_char(str, " THEN ");
476 _outNode(str, node->result);
480 _outCaseTestExpr(String *str, CaseTestExpr *node)
486 _outArrayExpr(String *str, ArrayExpr *node)
488 string_append_char(str, "[");
489 _outNode(str, node->elements);
490 string_append_char(str, "]");
494 _outRowExpr(String *str, RowExpr *node)
496 if (node->args == NIL)
497 string_append_char(str, "ROW ()");
500 string_append_char(str, "ROW (");
501 _outNode(str, node->args);
502 string_append_char(str, ")");
507 _outCoalesceExpr(String *str, CoalesceExpr *node)
509 string_append_char(str, "COALESCE (");
510 _outNode(str, node->args);
511 string_append_char(str, ")");
515 _outMinMaxExpr(String *str, MinMaxExpr *node)
517 if (node->op == IS_GREATEST)
519 string_append_char(str, "GREATEST (");
520 _outNode(str, node->args);
521 string_append_char(str, ")");
523 else if (node->op == IS_LEAST)
525 string_append_char(str, "LEAST (");
526 _outNode(str, node->args);
527 string_append_char(str, ")");
532 _outNullIfExpr(String *str, NullIfExpr *node)
538 _outNullTest(String *str, NullTest *node)
540 _outNode(str, node->arg);
541 if (node->nulltesttype == IS_NOT_NULL)
542 string_append_char(str, " IS NOT NULL");
544 string_append_char(str, " IS NULL");
548 _outBooleanTest(String *str, BooleanTest *node)
550 _outNode(str, node->arg);
552 switch (node->booltesttype)
555 string_append_char(str, " IS TRUE");
559 string_append_char(str, " IS NOT TRUE");
563 string_append_char(str, " IS FALSE");
567 string_append_char(str, " IS NOT FALSE");
571 string_append_char(str, " IS UNKNOWN");
575 string_append_char(str, " IS NOT UNKNOWN");
581 _outCoerceToDomain(String *str, CoerceToDomain *node)
587 _outCoerceToDomainValue(String *str, CoerceToDomainValue *node)
593 _outSetToDefault(String *str, SetToDefault *node)
595 string_append_char(str, "DEFAULT");
599 _outTargetEntry(String *str, TargetEntry *node)
605 _outRangeTblRef(String *str, RangeTblRef *node)
611 _outJoinExpr(String *str, JoinExpr *node)
613 _outNode(str, node->larg);
615 if (node->isNatural == TRUE)
616 string_append_char(str, " NATURAL");
618 if (node->jointype == JOIN_INNER)
620 if (node->using == NIL && node->quals == NULL && !node->isNatural)
621 string_append_char(str, " CROSS JOIN ");
623 string_append_char(str, " JOIN ");
625 else if (node->jointype == JOIN_INNER)
626 string_append_char(str, " JOIN ");
627 else if (node->jointype == JOIN_LEFT)
628 string_append_char(str, " LEFT OUTER JOIN ");
629 else if (node->jointype == JOIN_FULL)
630 string_append_char(str, " FULL OUTER JOIN ");
631 else if (node->jointype == JOIN_RIGHT)
632 string_append_char(str, " RIGHT OUTER JOIN ");
634 _outNode(str, node->rarg);
636 if (node->using != NIL && IsA(node->using, List))
641 string_append_char(str, " USING(");
643 foreach (lc, node->using)
650 string_append_char(str, ",");
653 string_append_char(str, "\"");
654 string_append_char(str, value->val.str);
655 string_append_char(str, "\"");
658 string_append_char(str, ")");
663 string_append_char(str, " ON ");
664 _outNode(str, node->quals);
669 _outFromExpr(String *str, FromExpr *node)
674 /*****************************************************************************
676 * Stuff from parsenodes.h.
678 *****************************************************************************/
681 _outCreateStmt(String *str, CreateStmt *node)
683 string_append_char(str, "CREATE ");
684 if (node->relation->istemp)
685 string_append_char(str, "TEMP ");
686 string_append_char(str, "TABLE ");
687 _outNode(str, node->relation);
688 string_append_char(str, " (");
689 _outNode(str, node->tableElts);
690 string_append_char(str, ") ");
692 if (node->inhRelations != NIL)
694 string_append_char(str, "INHERITS (");
695 _outNode(str, node->inhRelations);
696 string_append_char(str, ")");
700 _outWithDefinition(str, node->options);
702 switch (node->oncommit)
705 string_append_char(str, " ON COMMIT DROP");
708 case ONCOMMIT_DELETE_ROWS:
709 string_append_char(str, " ON COMMIT DELETE ROWS");
712 case ONCOMMIT_PRESERVE_ROWS:
713 string_append_char(str, " ON COMMIT PRESERVE ROWS");
720 if (node->tablespacename)
722 string_append_char(str, " TABLESPACE \"");
723 string_append_char(str, node->tablespacename);
724 string_append_char(str, "\"");
729 _outIndexStmt(String *str, IndexStmt *node)
731 string_append_char(str, "CREATE ");
733 if (node->unique == TRUE)
734 string_append_char(str, "UNIQUE ");
736 if (node->concurrent == true)
737 string_append_char(str, "INDEX CONCURRENTLY \"");
739 string_append_char(str, "INDEX \"");
740 string_append_char(str, node->idxname);
741 string_append_char(str, "\" ON ");
742 _outNode(str, node->relation);
744 if (strcmp(node->accessMethod, DEFAULT_INDEX_TYPE))
746 string_append_char(str, " USING ");
747 string_append_char(str, node->accessMethod);
750 string_append_char(str, "(");
751 _outNode(str, node->indexParams);
752 string_append_char(str, ")");
754 if (node->tableSpace)
756 string_append_char(str, " TABLESPACE \"");
757 string_append_char(str, node->tableSpace);
758 string_append_char(str, "\"");
761 if (node->whereClause)
763 string_append_char(str, " WHERE ");
764 _outNode(str, node->whereClause);
769 _outNotifyStmt(String *str, NotifyStmt *node)
771 string_append_char(str, "NOTIFY ");
772 _outNode(str, node->relation);
776 _outDeclareCursorStmt(String *str, DeclareCursorStmt *node)
778 string_append_char(str, "DECLARE \"");
779 string_append_char(str, node->portalname);
780 string_append_char(str, "\" ");
782 if (node->options & CURSOR_OPT_SCROLL)
783 string_append_char(str, "SCROLL ");
784 if (node->options & CURSOR_OPT_BINARY)
785 string_append_char(str, "BINARY ");
786 if (node->options & CURSOR_OPT_INSENSITIVE)
787 string_append_char(str, "INSENSITIVE ");
789 string_append_char(str, "CURSOR ");
790 if (node->options & CURSOR_OPT_HOLD)
791 string_append_char(str, "WITH HOLD ");
792 string_append_char(str, "FOR");
793 _outNode(str, node->query);
797 _outSelectStmt(String *str, SelectStmt *node)
799 if (node->larg) /* SETOP */
801 string_append_char(str, "(");
802 _outNode(str, node->larg);
803 string_append_char(str, ") ");
808 string_append_char(str, " UNION ");
811 case SETOP_INTERSECT:
812 string_append_char(str, " INTERSECT ");
816 string_append_char(str, " EXCEPT ");
823 string_append_char(str, "ALL ");
827 string_append_char(str, "(");
828 _outNode(str, node->rarg);
829 string_append_char(str, ") ");
832 else if (node->valuesLists) /* VALUES ... */
837 foreach (lc, node->valuesLists)
842 string_append_char(str, ",");
844 string_append_char(str, " VALUES (");
845 _outNode(str, lfirst(lc));
846 string_append_char(str, ")");
851 if (node->intoClause)
853 IntoClause *into = (IntoClause *)node->intoClause;
854 RangeVar *rel = (RangeVar *)into->rel;
856 string_append_char(str, "CREATE ");
857 if (rel->istemp == true)
858 string_append_char(str, "TEMP ");
859 string_append_char(str, "TABLE ");
860 _outNode(str, into->rel);
864 string_append_char(str, " (");
865 _outNode(str, into->colNames);
866 string_append_char(str, ") ");
870 _outWithDefinition(str, into->options);
872 switch (into->onCommit)
875 string_append_char(str, " ON COMMIT DROP");
878 case ONCOMMIT_DELETE_ROWS:
879 string_append_char(str, " ON COMMIT DELETE ROWS");
882 case ONCOMMIT_PRESERVE_ROWS:
883 string_append_char(str, " ON COMMIT PRESERVE ROWS");
890 string_append_char(str, " AS");
893 string_append_char(str, " SELECT ");
895 if (node->distinctClause)
897 string_append_char(str, "DISTINCT ");
898 if (lfirst(list_head(node->distinctClause)) != NIL)
900 string_append_char(str, "ON (");
901 _outNode(str, node->distinctClause);
902 string_append_char(str, " ) ");
906 _outNode(str, node->targetList);
908 if (node->fromClause)
910 string_append_char(str, " FROM ");
911 _outNode(str, node->fromClause);
914 if (node->whereClause)
916 string_append_char(str, " WHERE ");
917 _outNode(str, node->whereClause);
920 if (node->groupClause)
922 string_append_char(str, " GROUP BY ");
923 _outNode(str, node->groupClause);
926 if (node->havingClause)
928 string_append_char(str, " HAVING ");
929 _outNode(str, node->havingClause);
933 if (node->sortClause)
935 string_append_char(str, " ORDER BY ");
936 _outNode(str, node->sortClause);
939 if (node->limitOffset)
941 string_append_char(str, " OFFSET ");
942 _outNode(str, node->limitOffset);
945 if (node->limitCount)
947 string_append_char(str, " LIMIT ");
948 if (IsA(node->limitCount, A_Const) &&
949 ((A_Const *)node->limitCount)->val.type == T_Null)
951 string_append_char(str, "ALL ");
955 _outNode(str, node->limitCount);
959 _outNode(str, node->lockingClause);
963 _outFuncCall(String *str, FuncCall *node)
966 _outFuncName(str, node->funcname);
968 funcname = strVal(lfirst(list_head(node->funcname)));
970 if(strcmp(funcname,"user") == 0 ||
971 strcmp(funcname,"current_user") == 0 ||
972 strcmp(funcname,"session_user") == 0 ||
973 strcmp(funcname,"current_role") == 0)
976 string_append_char(str, "(");
978 if (node->agg_distinct == TRUE)
979 string_append_char(str, "DISTINCT ");
981 if (node->agg_star == TRUE)
982 string_append_char(str, "*");
984 _outNode(str, node->args);
986 string_append_char(str, ")");
990 _outDefElem(String *str, DefElem *node)
996 _outLockingClause(String *str, LockingClause *node)
1001 if (node->forUpdate == TRUE)
1002 string_append_char(str, " FOR UPDATE");
1004 string_append_char(str, " FOR SHARED");
1006 _outNode(str, node->lockedRels);
1008 if (node->noWait == TRUE)
1009 string_append_char(str, " NOWAIT ");
1013 _outColumnDef(String *str, ColumnDef *node)
1015 string_append_char(str, "\"");
1016 string_append_char(str, node->colname);
1017 string_append_char(str, "\" ");
1018 _outNode(str, node->typename);
1019 _outNode(str, node->constraints);
1023 _outTypeName(String *str, TypeName *node)
1028 foreach (lc, node->names)
1030 Value *v = (Value *) lfirst(lc);
1031 char *typename = v->val.str;
1036 string_append_char(str, ".");
1037 if(node->typemod < 0)
1039 string_append_char(str, "\"");
1040 string_append_char(str, typename);
1041 string_append_char(str, "\"");
1043 string_append_char(str, typename);
1046 if (node->typemod > 0)
1050 string_append_char(str, "(");
1051 snprintf(buf, 16, "%d", ((node->typemod - VARHDRSZ) >> 16) & 0x00FF);
1052 string_append_char(str, buf);
1053 lower = (node->typemod-VARHDRSZ) & 0x00FF;
1058 string_append_char(str, ",");
1059 snprintf(buf2, 16, "%d",lower);
1060 string_append_char(str, buf2);
1063 string_append_char(str, ")");
1068 _outTypeCast(String *str, TypeCast *node)
1070 _outNode(str, node->arg);
1071 string_append_char(str, "::");
1072 _outNode(str, node->typename);
1077 _outIndexElem(String *str, IndexElem *node)
1081 string_append_char(str, "\"");
1082 string_append_char(str, node->name);
1083 string_append_char(str, "\"");
1084 if (node->opclass != NIL)
1085 _outNode(str, node->opclass);
1089 string_append_char(str, "(");
1090 _outNode(str, node->expr);
1091 string_append_char(str, ")");
1092 if (node->opclass != NIL)
1093 _outNode(str, node->opclass);
1099 _outSortClause(String *str, SortClause *node)
1105 _outGroupClause(String *str, GroupClause *node)
1111 _outSetOperationStmt(String *str, SetOperationStmt *node)
1118 _outAExpr(String *str, A_Expr *node)
1125 if (list_length(node->name) == 1)
1127 Value *op = (Value *) lfirst(list_head(node->name));
1129 string_append_char(str, " (");
1130 _outNode(str, node->lexpr);
1131 string_append_char(str, op->val.str);
1132 _outNode(str, node->rexpr);
1133 string_append_char(str, " )");
1138 string_append_char(str, " (");
1139 _outNode(str, node->lexpr);
1140 string_append_char(str, " AND ");
1141 _outNode(str, node->rexpr);
1142 string_append_char(str, ")");
1146 string_append_char(str, " (");
1147 _outNode(str, node->lexpr);
1148 string_append_char(str, " OR ");
1149 _outNode(str, node->rexpr);
1150 string_append_char(str, ")");
1154 string_append_char(str, " (NOT ");
1155 _outNode(str, node->rexpr);
1156 string_append_char(str, ")");
1160 _outNode(str, node->lexpr);
1161 v = linitial(node->name);
1162 string_append_char(str, v->val.str);
1163 string_append_char(str, "ANY(");
1164 _outNode(str, node->rexpr);
1165 string_append_char(str, ")");
1169 _outNode(str, node->lexpr);
1170 v = linitial(node->name);
1171 string_append_char(str, v->val.str);
1172 string_append_char(str, "ALL(");
1173 _outNode(str, node->rexpr);
1174 string_append_char(str, ")");
1177 case AEXPR_DISTINCT:
1178 string_append_char(str, " (");
1179 _outNode(str, node->lexpr);
1180 string_append_char(str, " IS DISTINCT FROM ");
1181 _outNode(str, node->rexpr);
1182 string_append_char(str, ")");
1186 string_append_char(str, " NULLIF(");
1187 _outNode(str, node->lexpr);
1188 string_append_char(str, ", ");
1189 _outNode(str, node->rexpr);
1190 string_append_char(str, ")");
1194 _outNode(str, node->lexpr);
1195 v = linitial(node->name);
1196 if (v->val.str[0] == '!')
1197 string_append_char(str, " IS NOT OF (");
1199 string_append_char(str, " IS OF (");
1200 _outNode(str, node->rexpr);
1201 string_append_char(str, ")");
1205 _outNode(str, node->lexpr);
1206 v = (Value *)lfirst(list_head(node->name));
1207 if (v->val.str[0] == '=')
1208 string_append_char(str, " IN (");
1210 string_append_char(str, " NOT IN (");
1211 _outNode(str, node->rexpr);
1212 string_append_char(str, ")");
1221 _outValue(String *str, Value *value)
1225 switch (value->type)
1228 sprintf(buf, "%ld", value->val.ival);
1229 string_append_char(str, buf);
1233 string_append_char(str, value->val.str);
1237 string_append_char(str, "'");
1238 string_append_char(str, escape_string(value->val.str));
1239 string_append_char(str, "'");
1243 string_append_char(str, "NULL");
1252 _outColumnRef(String *str, ColumnRef *node)
1257 foreach (c, node->fields)
1259 Node *n = (Node *) lfirst(c);
1263 Value *v = (Value *) lfirst(c);
1268 string_append_char(str, ".");
1270 string_append_char(str, "\"");
1271 string_append_char(str, v->val.str);
1272 string_append_char(str, "\"");
1278 _outParamRef(String *str, ParamRef *node)
1282 snprintf(buf, 16, "%d", node->number);
1283 string_append_char(str, "$");
1284 string_append_char(str, buf);
1288 _outAConst(String *str, A_Const *node)
1295 Value *v = linitial(node->typename->names);
1297 _outNode(str, node->typename);
1298 string_append_char(str, " ");
1301 switch (node->val.type)
1304 sprintf(buf, "%ld", node->val.val.ival);
1305 string_append_char(str, buf);
1309 string_append_char(str, node->val.val.str);
1313 string_append_char(str, "'");
1314 string_append_char(str, escape_string(node->val.val.str));
1315 string_append_char(str, "'");
1319 string_append_char(str, "NULL");
1326 if (name && (strcmp(name, "interval") == 0) &&
1327 node->typename->typmods)
1329 A_Const *v = linitial(node->typename->typmods);
1330 int mask = v->val.val.ival;
1332 if (mask == INTERVAL_MASK(YEAR))
1333 string_append_char(str, " YEAR");
1334 else if (mask == INTERVAL_MASK(MONTH))
1335 string_append_char(str, " MONTH");
1336 else if (mask == INTERVAL_MASK(DAY))
1337 string_append_char(str, " DAY");
1338 else if (mask == INTERVAL_MASK(HOUR))
1339 string_append_char(str, " HOUR");
1340 else if (mask == INTERVAL_MASK(MINUTE))
1341 string_append_char(str, " MINUTE");
1342 else if (mask == INTERVAL_MASK(SECOND))
1343 string_append_char(str, " SECOND");
1344 else if (mask == (INTERVAL_MASK(YEAR) | INTERVAL_MASK(MONTH)))
1345 string_append_char(str, " YEAR TO MONTH");
1346 else if (mask == (INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR)))
1347 string_append_char(str, " DAY TO HOUR");
1348 else if (mask == (INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) |
1349 INTERVAL_MASK(MINUTE)))
1350 string_append_char(str, " DAY TO MINUTE");
1351 else if (mask == (INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) |
1352 INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND)))
1353 string_append_char(str, " DAY TO SECOND");
1354 else if (mask == (INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE)))
1355 string_append_char(str, " HOUR TO MINUTE");
1356 else if (mask == (INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) |
1357 INTERVAL_MASK(SECOND)))
1358 string_append_char(str, " HOUR TO SECOND");
1363 _outA_Indices(String *str, A_Indices *node)
1365 string_append_char(str, "[");
1368 _outNode(str, node->lidx);
1369 string_append_char(str, ":");
1371 _outNode(str, node->uidx);
1372 string_append_char(str, "]");
1376 _outA_Indirection(String *str, A_Indirection *node)
1378 _outNode(str, node->arg);
1379 _outNode(str, node->indirection);
1383 _outResTarget(String *str, ResTarget *node)
1385 if (node->indirection != NIL)
1387 string_append_char(str, "\"");
1388 string_append_char(str, node->name);
1389 string_append_char(str, "\"=");
1390 _outNode(str, node->val);
1394 _outNode(str, node->val);
1398 string_append_char(str, " AS ");
1399 string_append_char(str, "\"");
1400 string_append_char(str, node->name);
1401 string_append_char(str, "\" ");
1407 _outConstraint(String *str, Constraint *node)
1411 string_append_char(str, "CONSTRAINT \"");
1412 string_append_char(str, node->name);
1413 string_append_char(str, "\"");
1416 switch (node->contype)
1419 string_append_char(str, " CHECK (");
1420 _outNode(str, node->raw_expr);
1421 string_append_char(str, ")");
1425 string_append_char(str, " UNIQUE");
1428 string_append_char(str, "(");
1429 _outIdList(str, node->keys);
1430 string_append_char(str, ")");
1435 _outWithDefinition(str, node->options);
1438 if (node->indexspace)
1440 string_append_char(str, " USING INDEX TABLESPACE \"");
1441 string_append_char(str, node->indexspace);
1442 string_append_char(str, "\"");
1446 case CONSTR_PRIMARY:
1447 string_append_char(str, " PRIMARY KEY");
1450 string_append_char(str, "(");
1451 _outIdList(str, node->keys);
1452 string_append_char(str, ")");
1457 if (node->indexspace)
1459 string_append_char(str, " USING INDEX TABLESPACE \"");
1460 string_append_char(str, node->indexspace);
1461 string_append_char(str, "\"");
1465 case CONSTR_NOTNULL:
1466 string_append_char(str, " NOT NULL");
1470 string_append_char(str, " NULL");
1473 case CONSTR_DEFAULT:
1474 string_append_char(str, "DEFAULT ");
1475 _outNode(str, node->raw_expr);
1484 _outFkConstraint(String *str, FkConstraint *node)
1486 if (node->constr_name)
1488 string_append_char(str, "CONSTRAINT \"");
1489 string_append_char(str, node->constr_name);
1490 string_append_char(str, "\"");
1493 if (node->fk_attrs != NIL)
1495 string_append_char(str, " FOREIGN KEY (");
1496 _outIdList(str, node->fk_attrs);
1497 string_append_char(str, ")" );
1500 string_append_char(str, " REFERENCES ");
1501 _outNode(str, node->pktable);
1503 if (node->pk_attrs != NIL)
1505 string_append_char(str, "(");
1506 _outIdList(str, node->pk_attrs);
1507 string_append_char(str, ")");
1510 switch (node->fk_matchtype)
1512 case FKCONSTR_MATCH_FULL:
1513 string_append_char(str, " MATCH FULL");
1516 case FKCONSTR_MATCH_PARTIAL:
1517 string_append_char(str, " MATCH PARTIAL");
1524 switch (node->fk_upd_action)
1526 case FKCONSTR_ACTION_RESTRICT:
1527 string_append_char(str, " ON UPDATE RESTRICT");
1530 case FKCONSTR_ACTION_CASCADE:
1531 string_append_char(str, " ON UPDATE CASCADE");
1534 case FKCONSTR_ACTION_SETNULL:
1535 string_append_char(str, " ON UPDATE SET NULL");
1538 case FKCONSTR_ACTION_SETDEFAULT:
1539 string_append_char(str, " ON UPDATE SET DEFAULT");
1546 switch (node->fk_del_action)
1548 case FKCONSTR_ACTION_RESTRICT:
1549 string_append_char(str, " ON DELETE RESTRICT");
1552 case FKCONSTR_ACTION_CASCADE:
1553 string_append_char(str, " ON DELETE CASCADE");
1556 case FKCONSTR_ACTION_SETNULL:
1557 string_append_char(str, " ON DELETE SET NULL");
1560 case FKCONSTR_ACTION_SETDEFAULT:
1561 string_append_char(str, " ON DELETE SET DEFAULT");
1568 if (node->deferrable)
1569 string_append_char(str, " DEFERRABLE");
1571 if (node->initdeferred)
1572 string_append_char(str, " INITIALLY DEFERRED");
1577 _outSortBy(String *str, SortBy *node)
1579 _outNode(str, node->node);
1581 if (node->sortby_dir == SORTBY_USING)
1583 string_append_char(str, " USING ");
1584 _outNode(str, node->useOp);
1586 else if (node->sortby_dir == SORTBY_DESC)
1587 string_append_char(str, " DESC ");
1589 if (node->sortby_nulls == SORTBY_NULLS_FIRST)
1590 string_append_char(str, " NULLS FIRST ");
1591 else if (node->sortby_nulls == SORTBY_NULLS_LAST)
1592 string_append_char(str, " NULLS LAST ");
1595 static void _outInsertStmt(String *str, InsertStmt *node)
1597 string_append_char(str, "INSERT INTO ");
1598 _outNode(str, node->relation);
1600 if (node->cols == NIL && node->selectStmt == NULL)
1601 string_append_char(str, " DEFAULT VALUES");
1608 string_append_char(str, "(");
1610 foreach (lc, node->cols)
1612 ResTarget *node = lfirst(lc);
1616 string_append_char(str, ", ");
1618 string_append_char(str, "\"");
1619 string_append_char(str, node->name);
1620 string_append_char(str, "\"");
1622 string_append_char(str, ")");
1625 if (node->selectStmt)
1627 _outNode(str, node->selectStmt);
1630 if (node->returningList)
1632 string_append_char(str, " RETURNING ");
1633 _outNode(str, node->returningList);
1637 static void _outUpdateStmt(String *str, UpdateStmt *node)
1642 string_append_char(str, "UPDATE ");
1644 _outNode(str, node->relation);
1646 string_append_char(str, " SET ");
1647 foreach (lc, node->targetList)
1649 ResTarget *node = lfirst(lc);
1653 string_append_char(str, ", ");
1655 string_append_char(str, "\"");
1656 string_append_char(str, node->name);
1657 string_append_char(str, "\" = ");
1658 _outNode(str, node->val);
1661 if (node->fromClause)
1663 string_append_char(str, " FROM ");
1664 _outNode(str, node->fromClause);
1667 if (node->whereClause)
1669 string_append_char(str, " WHERE ");
1670 _outNode(str, node->whereClause);
1673 if (node->returningList)
1675 string_append_char(str, " RETURNING ");
1676 _outNode(str, node->returningList);
1680 static void _outDeleteStmt(String *str, DeleteStmt *node)
1682 string_append_char(str, "DELETE FROM ");
1684 _outNode(str, node->relation);
1686 if (node->usingClause)
1688 string_append_char(str, " USING ");
1689 _outNode(str, node->usingClause);
1692 if (node->whereClause)
1694 string_append_char(str, " WHERE ");
1695 _outNode(str, node->whereClause);
1698 if (node->returningList)
1700 string_append_char(str, " RETURNING ");
1701 _outNode(str, node->returningList);
1705 static void _outTransactionStmt(String *str, TransactionStmt *node)
1709 case TRANS_STMT_BEGIN:
1710 string_append_char(str, "BEGIN ");
1713 case TRANS_STMT_START:
1714 string_append_char(str, "START TRANSACTION ");
1717 case TRANS_STMT_COMMIT:
1718 string_append_char(str, "COMMIT ");
1721 case TRANS_STMT_ROLLBACK:
1722 string_append_char(str, "ABORT ");
1725 case TRANS_STMT_SAVEPOINT:
1726 string_append_char(str, "SAVEPOINT ");
1729 case TRANS_STMT_RELEASE:
1730 string_append_char(str, "RELEASE ");
1733 case TRANS_STMT_ROLLBACK_TO:
1734 string_append_char(str, "ROLLBACK TO ");
1737 case TRANS_STMT_PREPARE:
1738 string_append_char(str, "PREPARE TRANSACTION ");
1741 case TRANS_STMT_COMMIT_PREPARED:
1742 string_append_char(str, "COMMIT PREPARED ");
1745 case TRANS_STMT_ROLLBACK_PREPARED:
1746 string_append_char(str, "ROLLBACK PREPARED ");
1754 _outSetTransactionModeList(str, node->options);
1757 string_append_char(str, node->gid);
1761 static void _outTruncateStmt(String *str, TruncateStmt *node)
1763 string_append_char(str, "TRUNCATE ");
1764 _outNode(str, node->relations);
1767 static void _outVacuumStmt(String *str, VacuumStmt *node)
1769 if (node->vacuum == true)
1770 string_append_char(str, "VACUUM ");
1772 string_append_char(str, "ANALYZE ");
1774 if (node->full == TRUE)
1775 string_append_char(str, "FULL ");
1777 if (node->freeze_min_age == 0)
1778 string_append_char(str, "FREEZE ");
1780 if (node->verbose == TRUE)
1781 string_append_char(str, "VERBOSE ");
1784 string_append_char(str, "ANALYZE ");
1786 _outNode(str, node->relation);
1789 string_append_char(str, "(");
1790 _outIdList(str, node->va_cols);
1791 string_append_char(str, ") ");
1795 static void _outExplainStmt(String *str, ExplainStmt *node)
1797 string_append_char(str, "EXPLAIN ");
1799 if (node->analyze == TRUE)
1800 string_append_char(str, "ANALYZE ");
1801 if (node->verbose == TRUE)
1802 string_append_char(str, "VERBOSE ");
1804 _outNode(str, node->query);
1807 static void _outClusterStmt(String *str, ClusterStmt *node)
1809 string_append_char(str, "CLUSTER ");
1811 if (node->indexname)
1813 string_append_char(str, "\"");
1814 string_append_char(str, node->indexname);
1815 string_append_char(str, "\" ON ");
1818 _outNode(str, node->relation);
1821 static void _outCheckPointStmt(String *str, CheckPointStmt *node)
1823 string_append_char(str, "CHECKPOINT");
1826 static void _outClosePortalStmt(String *str, ClosePortalStmt *node)
1828 string_append_char(str, "CLOSE ");
1829 string_append_char(str, "\"");
1830 string_append_char(str, node->portalname);
1831 string_append_char(str, "\"");
1834 static void _outListenStmt(String *str, ListenStmt *node)
1836 string_append_char(str, "LISTEN ");
1837 _outNode(str, node->relation);
1840 static void _outUnlistenStmt(String *str, UnlistenStmt *node)
1842 string_append_char(str, "UNLISTEN ");
1843 _outNode(str, node->relation);
1846 static void _outLoadStmt(String *str, LoadStmt *node)
1848 string_append_char(str, "LOAD '");
1849 string_append_char(str, node->filename);
1850 string_append_char(str, "'");
1853 static void _outCopyStmt(String *str, CopyStmt *node)
1857 char *delimiter = NULL;
1862 char *escape = NULL;
1863 Node *force_quote = NULL;
1864 Node *force_notnull = NULL;
1867 foreach (lc, node->options)
1869 DefElem *e = lfirst(lc);
1871 if (strcmp(e->defname, "binary") == 0)
1873 else if (strcmp(e->defname, "oids") == 0)
1875 else if (strcmp(e->defname, "delimiter") == 0)
1876 delimiter = ((Value *) e->arg)->val.str;
1877 else if (strcmp(e->defname, "null") == 0)
1878 null = ((Value *) e->arg)->val.str;
1879 else if (strcmp(e->defname, "csv") == 0)
1881 else if (strcmp(e->defname, "header") == 0)
1883 else if (strcmp(e->defname, "quote") == 0)
1884 quote = ((Value *) e->arg)->val.str;
1885 else if (strcmp(e->defname, "escape") == 0)
1886 escape = ((Value *) e->arg)->val.str;
1887 else if (strcmp(e->defname, "force_quote") == 0)
1888 force_quote = e->arg;
1889 else if (strcmp(e->defname, "force_notnull") == 0)
1890 force_notnull = e->arg;
1893 string_append_char(str, "COPY ");
1897 string_append_char(str, "(");
1898 _outNode(str, node->query);
1899 string_append_char(str, ")");
1902 _outNode(str, node->relation);
1906 string_append_char(str, "(");
1907 _outIdList(str, node->attlist);
1908 string_append_char(str, ") ");
1911 if (node->is_from == TRUE)
1912 string_append_char(str, " FROM ");
1914 string_append_char(str, " TO ");
1918 string_append_char(str, "'");
1919 string_append_char(str, node->filename);
1920 string_append_char(str, "'");
1923 string_append_char(str, node->is_from == TRUE ? "STDIN" : "STDOUT");
1926 string_append_char(str, " BINARY ");
1929 string_append_char(str, " OIDS ");
1933 string_append_char(str, " DELIMITERS '");
1934 string_append_char(str, delimiter);
1935 string_append_char(str, "'");
1940 string_append_char(str, " NULL '");
1941 string_append_char(str, null);
1942 string_append_char(str, "' ");
1946 string_append_char(str, "CSV ");
1949 string_append_char(str, "HEADER ");
1953 string_append_char(str, "QUOTE '");
1954 string_append_char(str, quote);
1955 string_append_char(str, "' ");
1960 string_append_char(str, "ESCAPE '");
1961 string_append_char(str, escape);
1962 string_append_char(str, "' ");
1967 string_append_char(str, "FORCE QUOTE ");
1968 _outNode(str, force_quote);
1973 string_append_char(str, " FORCE NOT NULL ");
1974 _outNode(str, force_notnull);
1978 static void _outDeallocateStmt(String *str, DeallocateStmt *node)
1980 string_append_char(str, "DEALLOCATE \"");
1981 string_append_char(str, node->name);
1982 string_append_char(str, "\"");
1985 static void _outRenameStmt(String *str, RenameStmt *node)
1990 string_append_char(str, "ALTER ");
1992 switch (node->renameType)
1994 case OBJECT_AGGREGATE:
1995 string_append_char(str, "AGGREGATE ");
1996 _outNode(str, node->object);
1997 string_append_char(str, " (");
1998 string_append_char(str, ") RENAME TO \"");
1999 string_append_char(str, node->newname);
2000 string_append_char(str, "\"");
2003 case OBJECT_CONVERSION:
2004 string_append_char(str, "CONVERSION ");
2005 _outNode(str, node->object);
2006 string_append_char(str, " RENAME TO \"");
2007 string_append_char(str, node->newname);
2008 string_append_char(str, "\"");
2011 case OBJECT_DATABASE:
2012 string_append_char(str, "DATABASE \"");
2013 string_append_char(str, node->subname);
2014 string_append_char(str, "\" RENAME TO \"");
2015 string_append_char(str, node->newname);
2016 string_append_char(str, "\"");
2019 case OBJECT_FUNCTION:
2020 string_append_char(str, "FUNCTION ");
2022 foreach (lc, node->object)
2024 Node *n = lfirst(lc);
2027 Value *value = (Value *) n;
2031 string_append_char(str, ".");
2032 string_append_char(str, "\"");
2033 string_append_char(str, value->val.str);
2034 string_append_char(str, "\"");
2040 string_append_char(str, "(");
2041 _outNode(str, node->objarg);
2042 string_append_char(str, ")");
2043 string_append_char(str, " RENAME TO \"");
2044 string_append_char(str, node->newname);
2045 string_append_char(str, "\"");
2049 string_append_char(str, "ROLE \"");
2050 string_append_char(str, node->subname);
2051 string_append_char(str, "\" RENAME TO \"");
2052 string_append_char(str, node->newname);
2053 string_append_char(str, "\"");
2056 case OBJECT_LANGUAGE:
2057 string_append_char(str, "LANGUAGE \"");
2058 string_append_char(str, node->subname);
2059 string_append_char(str, "\" RENAME TO \"");
2060 string_append_char(str, node->newname);
2061 string_append_char(str, "\"");
2064 case OBJECT_OPCLASS:
2065 string_append_char(str, "OPERATOR CLASS ");
2066 _outNode(str, node->object);
2067 string_append_char(str, " USING ");
2068 string_append_char(str, node->subname);
2069 string_append_char(str, " RENAME TO \"");
2070 string_append_char(str, node->newname);
2071 string_append_char(str, "\"");
2075 string_append_char(str, "SCHEMA \"");
2076 string_append_char(str, node->subname);
2077 string_append_char(str, "\" RENAME TO \"");
2078 string_append_char(str, node->newname);
2079 string_append_char(str, "\"");
2083 string_append_char(str, "TABLE ");
2084 _outNode(str, node->relation);
2085 string_append_char(str, " RENAME TO \"");
2086 string_append_char(str, node->newname);
2087 string_append_char(str, "\"");
2091 string_append_char(str, "INDEX ");
2092 _outNode(str, node->relation);
2093 string_append_char(str, " RENAME TO \"");
2094 string_append_char(str, node->newname);
2095 string_append_char(str, "\"");
2099 string_append_char(str, "TABLE ");
2100 _outNode(str, node->relation);
2101 string_append_char(str, " RENAME \"");
2102 string_append_char(str, node->subname);
2103 string_append_char(str, "\" TO \"");
2104 string_append_char(str, node->newname);
2105 string_append_char(str, "\"");
2108 case OBJECT_TRIGGER:
2109 string_append_char(str, "TRIGGER \"");
2110 string_append_char(str, node->subname);
2111 string_append_char(str, "\" ON ");
2112 _outNode(str, node->relation);
2113 string_append_char(str, " RENAME TO \"");
2114 string_append_char(str, node->newname);
2115 string_append_char(str, "\"");
2118 case OBJECT_TABLESPACE:
2119 string_append_char(str, "TABLESPACE \"");
2120 string_append_char(str, node->subname);
2121 string_append_char(str, "\" RENAME TO \"");
2122 string_append_char(str, node->newname);
2123 string_append_char(str, "\"");
2132 _outOptRoleList(String *str, List *options)
2136 foreach (lc, options)
2138 DefElem *elem = lfirst(lc);
2139 Value *value = (Value *) elem->arg;
2141 if (strcmp(elem->defname, "password") == 0)
2144 string_append_char(str, " PASSWORD NULL");
2147 string_append_char(str, " PASSWORD '");
2148 string_append_char(str, value->val.str);
2149 string_append_char(str, "'");
2152 else if (strcmp(elem->defname, "encryptedPassword") == 0)
2154 string_append_char(str, " ENCRYPTED PASSWORD '");
2155 string_append_char(str, value->val.str);
2156 string_append_char(str, "'");
2158 else if (strcmp(elem->defname, "unencryptedPassword") == 0)
2160 string_append_char(str, " UNENCRYPTED PASSWORD '");
2161 string_append_char(str, value->val.str);
2162 string_append_char(str, "'");
2164 else if (strcmp(elem->defname, "superuser") == 0)
2166 if (value->val.ival == TRUE)
2167 string_append_char(str, " SUPERUSER");
2169 string_append_char(str, " NOSUPERUSER");
2171 else if (strcmp(elem->defname, "inherit") == 0)
2173 if (value->val.ival == TRUE)
2174 string_append_char(str, " INHERIT");
2176 string_append_char(str, " NOINHERIT");
2178 else if (strcmp(elem->defname, "createdb") == 0)
2180 if (value->val.ival == TRUE)
2181 string_append_char(str, " CREATEDB");
2183 string_append_char(str, " NOCREATEDB");
2185 else if (strcmp(elem->defname, "createrole") == 0)
2187 if (value->val.ival == TRUE)
2188 string_append_char(str, " CREATEROLE");
2190 string_append_char(str, " NOCREATEROLE");
2192 else if (strcmp(elem->defname, "canlogin") == 0)
2194 if (value->val.ival == TRUE)
2195 string_append_char(str, " LOGIN");
2197 string_append_char(str, " NOLOGIN");
2199 else if (strcmp(elem->defname, "connectionlimit") == 0)
2203 string_append_char(str, " CONNECTION LIMIT ");
2204 snprintf(buf, 16, "%ld", value->val.ival);
2205 string_append_char(str, buf);
2207 else if (strcmp(elem->defname, "validUntil") == 0)
2209 string_append_char(str, " VALID UNTIL '");
2210 string_append_char(str, value->val.str);
2211 string_append_char(str, "'");
2213 else if (strcmp(elem->defname, "rolemembers") == 0)
2215 string_append_char(str, " ROLE ");
2216 _outIdList(str, (List *) elem->arg);
2218 else if (strcmp(elem->defname, "sysid") == 0)
2222 string_append_char(str, " SYSID ");
2223 snprintf(buf, 16, "%ld", value->val.ival);
2224 string_append_char(str, buf);
2226 else if (strcmp(elem->defname, "adminmembers") == 0)
2228 string_append_char(str, " ADMIN ");
2229 _outIdList(str, (List *) elem->arg);
2231 else if (strcmp(elem->defname, "addroleto") == 0)
2233 string_append_char(str, " IN ROLE ");
2234 _outIdList(str, (List *) elem->arg);
2240 _outCreateRoleStmt(String *str, CreateRoleStmt *node)
2242 string_append_char(str, "CREATE ");
2243 switch (node->stmt_type)
2246 string_append_char(str, "ROLE \"");
2250 string_append_char(str, "USER \"");
2253 case ROLESTMT_GROUP:
2254 string_append_char(str, "GROUP \"");
2257 string_append_char(str, node->role);
2258 string_append_char(str, "\"");
2260 _outOptRoleList(str, node->options);
2264 _outAlterRoleStmt(String *str, AlterRoleStmt *node)
2266 string_append_char(str, "ALTER ROLE \"");
2267 string_append_char(str, node->role);
2268 string_append_char(str, "\"");
2271 _outOptRoleList(str, node->options);
2275 _outAlterRoleSetStmt(String *str, AlterRoleSetStmt *node)
2277 string_append_char(str, "ALTER ROLE \"");
2278 string_append_char(str, node->role);
2279 string_append_char(str, "\" ");
2283 _outNode(str, node->setstmt);
2289 _outSetTransactionModeList(String *str, List *list)
2296 DefElem *elem = lfirst(lc);
2301 string_append_char(str, ",");
2303 if (strcmp(elem->defname, "transaction_isolation") == 0)
2305 A_Const *v = (A_Const *) elem->arg;
2306 string_append_char(str, " ISOLATION LEVEL ");
2307 string_append_char(str, v->val.val.str);
2309 else if (strcmp(elem->defname, "transaction_read_only") == 0)
2311 A_Const *n = (A_Const *) elem->arg;
2312 if (n->val.val.ival == TRUE)
2313 string_append_char(str, "READ ONLY ");
2315 string_append_char(str, "READ WRITE ");
2322 _outSetRest(String *str, VariableSetStmt *node)
2324 if (strcmp(node->name, "timezone") == 0)
2326 string_append_char(str, "TIME ZONE ");
2327 if (node->kind != VAR_RESET)
2328 _outNode(str, node->args);
2330 else if (strcmp(node->name, "TRANSACTION") == 0)
2332 string_append_char(str, "TRANSACTION ");
2333 _outSetTransactionModeList(str, node->args);
2335 else if (strcmp(node->name, "SESSION CHARACTERISTICS") == 0)
2337 string_append_char(str, "SESSION CHARACTERISTICS AS TRANSACTION ");
2338 _outSetTransactionModeList(str, node->args);
2340 else if (strcmp(node->name, "role") == 0)
2342 string_append_char(str, "ROLE ");
2343 if (node->kind != VAR_RESET)
2344 _outNode(str, node->args);
2346 else if (strcmp(node->name, "session_authorization") == 0)
2348 string_append_char(str, "SESSION AUTHORIZATION ");
2349 if (node->args == NIL && node->kind != VAR_RESET)
2350 string_append_char(str, "DEFAULT");
2352 _outNode(str, node->args);
2354 else if (strcmp(node->name, "transaction_isolation") == 0)
2356 string_append_char(str, "TRANSACTION ISOLATION LEVEL");
2357 if (node->kind != VAR_RESET)
2358 _outSetTransactionModeList(str, node->args);
2360 else if (strcmp(node->name, "xmloption") == 0)
2362 A_Const *v = linitial(node->args);
2363 string_append_char(str, "XML OPTOIN ");
2364 string_append_char(str, v->val.val.str);
2368 string_append_char(str, node->name);
2369 if (node->kind != VAR_RESET)
2371 if (node->kind == VAR_SET_CURRENT)
2373 string_append_char(str, " FROM CURRENT");
2377 string_append_char(str, " TO ");
2378 if (node->args == NULL)
2380 string_append_char(str, "DEFAULT");
2383 _outNode(str, node->args);
2390 _outDropRoleStmt(String *str, DropRoleStmt *node)
2392 string_append_char(str, "DROP ROLE ");
2393 if (node->missing_ok == TRUE)
2394 string_append_char(str, "IF EXISTS ");
2395 _outIdList(str, node->roles);
2399 _outCreateSchemaStmt(String *str, CreateSchemaStmt *node)
2401 string_append_char(str, "CREATE SCHEMA \"");
2402 string_append_char(str, node->schemaname);
2403 string_append_char(str, "\"");
2406 string_append_char(str, "AUTHORIZATION \"");
2407 string_append_char(str, node->authid);
2408 string_append_char(str, "\" ");
2410 _outNode(str, node->schemaElts);
2414 _outVariableSetStmt(String *str, VariableSetStmt *node)
2416 if (node->kind == VAR_RESET_ALL)
2418 string_append_char(str, "RESET ALL");
2422 if (node->kind == VAR_RESET)
2423 string_append_char(str, "RESET ");
2425 string_append_char(str, "SET ");
2428 string_append_char(str, "LOCAL ");
2430 _outSetRest(str, node);
2434 _outVariableShowStmt(String *str, VariableShowStmt *node)
2436 if (strcmp(node->name, "timezone") == 0)
2437 string_append_char(str, "SHOW TIME ZONE");
2438 else if (strcmp(node->name, "transaction_isolation") == 0)
2439 string_append_char(str, "SHOW TRANSACTION ISOLATION LEVEL");
2440 else if (strcmp(node->name, "session_authorization") == 0)
2441 string_append_char(str, "SHOW SESSION AUTHORIZATION");
2442 else if (strcmp(node->name, "all") == 0)
2443 string_append_char(str, "SHOW ALL");
2446 string_append_char(str, "SHOW ");
2447 string_append_char(str, node->name);
2452 _outConstraintsSetStmt(String *str, ConstraintsSetStmt *node)
2454 string_append_char(str, "SET CONSTRAINTS ");
2456 if (node->constraints == NIL)
2457 string_append_char(str, "ALL");
2459 _outNode(str, node->constraints);
2461 string_append_char(str, node->deferred == TRUE ? " DEFERRED" : " IMMEDIATE");
2465 _outAlterTableCmd(String *str, AlterTableCmd *node)
2469 switch (node->subtype)
2472 string_append_char(str, "ADD ");
2473 _outNode(str, node->def);
2476 case AT_ColumnDefault:
2477 string_append_char(str, "ALTER \"");
2478 string_append_char(str, node->name);
2479 string_append_char(str, "\" ");
2480 if (node->def == NULL)
2481 string_append_char(str, "DROP DEFAULT");
2484 string_append_char(str, "SET DEFAULT ");
2485 _outNode(str, node->def);
2489 case AT_DropNotNull:
2490 string_append_char(str, "ALTER \"");
2491 string_append_char(str, node->name);
2492 string_append_char(str, "\" DROP NOT NULL");
2496 string_append_char(str, "ALTER \"");
2497 string_append_char(str, node->name);
2498 string_append_char(str, "\" SET NOT NULL");
2501 case AT_SetStatistics:
2502 string_append_char(str, "ALTER \"");
2503 string_append_char(str, node->name);
2504 string_append_char(str, "\" SET STATISTICS ");
2505 snprintf(buf, 16, "%ld", ((Value *) node->def)->val.ival);
2506 string_append_char(str, buf);
2510 string_append_char(str, "ALTER \"");
2511 string_append_char(str, node->name);
2512 string_append_char(str, "\" SET STORAGE ");
2513 string_append_char(str, ((Value *) node->def)->val.str);
2517 string_append_char(str, "DROP \"");
2518 string_append_char(str, node->name);
2519 string_append_char(str, "\" ");
2520 if (node->behavior == DROP_CASCADE)
2521 string_append_char(str, "CASCADE");
2524 case AT_AlterColumnType:
2525 string_append_char(str, "ALTER \"");
2526 string_append_char(str, node->name);
2527 string_append_char(str, "\" TYPE ");
2528 _outNode(str, node->def);
2529 if (node->transform)
2531 string_append_char(str, " USING ");
2532 _outNode(str, node->transform);
2536 case AT_AddConstraint:
2537 string_append_char(str, "ADD ");
2538 _outNode(str, node->def);
2541 case AT_DropConstraint:
2542 string_append_char(str, "DROP CONSTRAINT \"");
2543 string_append_char(str, node->name);
2544 string_append_char(str, "\"");
2545 if (node->behavior == DROP_CASCADE)
2546 string_append_char(str, " CASCADE");
2550 string_append_char(str, "SET WITHOUT OIDS");
2554 string_append_char(str, "CLUSTER ON \"");
2555 string_append_char(str, node->name);
2556 string_append_char(str, "\"");
2559 case AT_DropCluster:
2560 string_append_char(str, "SET WITHOUT CLUSTER");
2564 string_append_char(str, "ENABLE TRIGGER \"");
2565 string_append_char(str, node->name);
2566 string_append_char(str, "\"");
2569 case AT_EnableAlwaysTrig:
2570 /* not implemented */
2573 case AT_EnableReplicaTrig:
2574 /* not implemented */
2577 case AT_EnableTrigAll:
2578 string_append_char(str, "ENABLE TRIGGER ALL");
2581 case AT_EnableTrigUser:
2582 string_append_char(str, "ENABLE TRIGGER USER");
2585 case AT_DisableTrig:
2586 string_append_char(str, "DISABLE TRIGGER \"");
2587 string_append_char(str, node->name);
2588 string_append_char(str, "\"");
2591 case AT_DisableTrigAll:
2592 string_append_char(str, "DISABLE TRIGGER ALL");
2595 case AT_DisableTrigUser:
2596 string_append_char(str, "DISABLE TRIGGER USER");
2600 /* not implemented */
2603 case AT_EnableReplicaRule:
2604 /* not implemented */
2607 case AT_EnableAlwaysRule:
2608 /* not implemented */
2611 case AT_DisableRule:
2612 /* not implemented */
2616 /* not implemented */
2619 case AT_ChangeOwner:
2620 string_append_char(str, "OWNER TO \"");
2621 string_append_char(str, node->name);
2622 string_append_char(str, "\"");
2625 case AT_SetTableSpace:
2626 string_append_char(str, "SET TABLESPACE \"");
2627 string_append_char(str, node->name);
2628 string_append_char(str, "\"");
2631 case AT_SetRelOptions:
2632 /* not implemented */
2635 case AT_ResetRelOptions:
2636 /* not implemented */
2645 _outAlterTableStmt(String *str, AlterTableStmt *node)
2647 if (node->relkind == OBJECT_TABLE)
2648 string_append_char(str, "ALTER TABLE ");
2650 string_append_char(str, "ALTER INDEX ");
2652 _outNode(str, node->relation);
2653 string_append_char(str, " ");
2654 _outNode(str, node->cmds);
2658 _outOptSeqList(String *str, List *options)
2662 foreach (lc, options)
2664 DefElem *e = lfirst(lc);
2665 Value *v = (Value *)e->arg;
2668 if (strcmp(e->defname, "cycle") == 0)
2670 if (v->val.ival == TRUE)
2671 string_append_char(str, " CYCLE");
2673 string_append_char(str, " NO CYCLE");
2675 else if (strcmp(e->defname, "minvalue") == 0 && !v)
2676 string_append_char(str, " NO MINVALUE");
2677 else if (strcmp(e->defname, "maxvalue") == 0 && !v)
2678 string_append_char(str, " NO MAXVALUE");
2679 else if (strcmp(e->defname, "owned_by") == 0)
2681 string_append_char(str, " OWNED BY ");
2682 _outIdList(str, (List *)e->arg);
2686 if (strcmp(e->defname, "cache") == 0)
2687 string_append_char(str, " CACHE ");
2688 else if (strcmp(e->defname, "increment") == 0)
2689 string_append_char(str, " INCREMENT ");
2690 else if (strcmp(e->defname, "maxvalue") == 0 && v)
2691 string_append_char(str, " MAXVALUE ");
2692 else if (strcmp(e->defname, "minvalue") == 0 && v)
2693 string_append_char(str, " MINVALUE ");
2694 else if (strcmp(e->defname, "start") == 0)
2695 string_append_char(str, " START ");
2696 else if (strcmp(e->defname, "restart") == 0)
2697 string_append_char(str, " RESTART ");
2699 if (IsA(e->arg, String))
2700 string_append_char(str, v->val.str);
2703 snprintf(buf, 16, "%ld", v->val.ival);
2704 string_append_char(str, buf);
2711 _outCreateSeqStmt(String *str, CreateSeqStmt *node)
2713 string_append_char(str, "CREATE ");
2714 if (node->sequence->istemp)
2715 string_append_char(str, "TEMP ");
2716 string_append_char(str, "SEQUENCE ");
2717 _outNode(str, node->sequence);
2719 _outOptSeqList(str, node->options);
2723 _outAlterSeqStmt(String *str, AlterSeqStmt *node)
2725 string_append_char(str, "ALTER SEQUENCE ");
2726 _outNode(str, node->sequence);
2727 _outOptSeqList(str, node->options);
2731 _outCreatePLangStmt(String *str, CreatePLangStmt *node)
2733 string_append_char(str, "CREATE ");
2734 if (node->pltrusted == true)
2735 string_append_char(str, "TRUSTED ");
2736 string_append_char(str, "LANGUAGE \"");
2737 string_append_char(str, node->plname);
2738 string_append_char(str, "\"");
2740 if (node->plhandler != NIL)
2745 string_append_char(str, " HANDLER ");
2746 foreach (lc, node->plhandler)
2748 Value *v = lfirst(lc);
2753 string_append_char(str, ".");
2755 string_append_char(str, "\"");
2756 string_append_char(str, v->val.str);
2757 string_append_char(str, "\"");
2761 if (node->plvalidator != NIL)
2766 string_append_char(str, " VALIDATOR ");
2767 foreach (lc, node->plvalidator)
2769 Value *v = lfirst(lc);
2774 string_append_char(str, ".");
2776 string_append_char(str, "\"");
2777 string_append_char(str, v->val.str);
2778 string_append_char(str, "\"");
2784 _outDropPLangStmt(String *str, DropPLangStmt *node)
2786 string_append_char(str, "DROP LANGUAGE \"");
2787 string_append_char(str, node->plname);
2788 string_append_char(str, "\"");
2789 if (node->behavior == DROP_CASCADE)
2790 string_append_char(str, " CASCADE");
2794 _outCreateTableSpaceStmt(String *str, CreateTableSpaceStmt *node)
2796 string_append_char(str, "CREATE TABLESPACE \"");
2797 string_append_char(str, node->tablespacename);
2798 string_append_char(str, "\" ");
2802 string_append_char(str, "OWNER \"");
2803 string_append_char(str, node->owner);
2804 string_append_char(str, "\" ");
2807 string_append_char(str, "LOCATION '");
2808 string_append_char(str, node->location);
2809 string_append_char(str, "'");
2813 _outDropTableSpaceStmt(String *str, DropTableSpaceStmt *node)
2815 string_append_char(str, "DROP TABLESPACE \"");
2816 string_append_char(str, node->tablespacename);
2817 string_append_char(str, "\"");
2821 _outFuncName(String *str, List *func_name)
2827 if (func_name == NULL)
2830 foreach (lc, func_name)
2832 v = (Value *) lfirst(lc);
2837 string_append_char(str, ".");
2841 string_append_char(str, "\"");
2842 string_append_char(str, v->val.str);
2843 string_append_char(str, "\"");
2853 _outCreateTrigStmt(String *str, CreateTrigStmt *node)
2857 if (node->isconstraint == TRUE)
2858 string_append_char(str, "CREATE CONSTRAINT TRIGGER \"");
2860 string_append_char(str, "CREATE TRIGGER \"");
2861 string_append_char(str, node->trigname);
2862 string_append_char(str, "\" ");
2864 if (node->before == TRUE)
2865 string_append_char(str, "BEFORE ");
2867 string_append_char(str, "AFTER ");
2869 len = strlen(node->actions);
2870 for (i = 0; i < len; i++)
2873 string_append_char(str, "OR ");
2875 if (node->actions[i] == 'i')
2876 string_append_char(str, "INSERT ");
2877 else if (node->actions[i] == 'd')
2878 string_append_char(str, "DELETE ");
2880 string_append_char(str, "UPDATE ");
2883 string_append_char(str, "ON ");
2884 _outNode(str, node->relation);
2886 if (node->constrrel)
2888 string_append_char(str, " FROM ");
2889 _outNode(str, node->constrrel);
2892 if (node->deferrable)
2893 string_append_char(str, " DEFERRABLE");
2894 if (node->initdeferred)
2895 string_append_char(str, " INITIALLY DEFERRED");
2897 if (node->row == TRUE)
2898 string_append_char(str, " FOR EACH ROW ");
2900 string_append_char(str, " FOR EACH STATEMENT ");
2902 string_append_char(str, "EXECUTE PROCEDURE ");
2904 _outFuncName(str, node->funcname);
2905 string_append_char(str, "(");
2906 _outNode(str, node->args);
2907 string_append_char(str, ")");
2911 _outDropPropertyStmt(String *str, DropPropertyStmt *node)
2913 switch (node->removeType)
2915 case OBJECT_TRIGGER:
2916 string_append_char(str, "DROP TRIGGER \"");
2917 string_append_char(str, node->property);
2918 string_append_char(str, "\" ON ");
2919 _outNode(str, node->relation);
2920 if (node->behavior == DROP_CASCADE)
2921 string_append_char(str, " CASCADE");
2925 string_append_char(str, "DROP RULE \"");
2926 string_append_char(str, node->property);
2927 string_append_char(str, "\" ON ");
2928 _outNode(str, node->relation);
2929 if (node->behavior == DROP_CASCADE)
2930 string_append_char(str, " CASCADE");
2939 _outDefinition(String *str, List *definition)
2944 if (definition == NIL)
2947 string_append_char(str, "(");
2948 foreach (lc, definition)
2950 DefElem *e = lfirst(lc);
2955 string_append_char(str, ", ");
2957 string_append_char(str, "\"");
2958 string_append_char(str, e->defname);
2959 string_append_char(str, "\"");
2963 string_append_char(str, "=");
2964 _outNode(str, e->arg);
2967 string_append_char(str, ")");
2971 _outDefineStmt(String *str, DefineStmt *node)
2978 case OBJECT_AGGREGATE:
2979 string_append_char(str, "CREATE AGGREGATE ");
2980 _outFuncName(str, node->defnames);
2981 string_append_char(str, " ");
2982 _outDefinition(str, node->definition);
2985 case OBJECT_OPERATOR:
2986 string_append_char(str, "CREATE OPERATOR ");
2988 foreach (lc, node->defnames)
2990 Value *v = lfirst(lc);
2995 string_append_char(str, ".");
2997 string_append_char(str, v->val.str);
3000 string_append_char(str, " ");
3001 _outDefinition(str, node->definition);
3005 string_append_char(str, "CREATE TYPE");
3006 _outFuncName(str, node->defnames);
3007 string_append_char(str, " ");
3008 _outDefinition(str, node->definition);
3011 case OBJECT_TSPARSER:
3012 string_append_char(str, "CREATE TEXT SEARCH PARSER ");
3013 _outIdList(str, node->defnames);
3014 _outDefinition(str, node->definition);
3017 case OBJECT_TSDICTIONARY:
3018 string_append_char(str, "CREATE TEXT SEARCH DICTIONARY ");
3019 _outIdList(str, node->defnames);
3020 _outDefinition(str, node->definition);
3023 case OBJECT_TSTEMPLATE:
3024 string_append_char(str, "CREATE TEXT SEARCH TEMPLATE ");
3025 _outIdList(str, node->defnames);
3026 _outDefinition(str, node->definition);
3029 case OBJECT_TSCONFIGURATION:
3030 string_append_char(str, "CREATE TEXT SEARCH CONFIGURATION ");
3031 _outIdList(str, node->defnames);
3032 _outDefinition(str, node->definition);
3041 _outOperatorName(String *str, List *list)
3048 Value *v = lfirst(lc);
3053 string_append_char(str, ".");
3055 string_append_char(str, v->val.str);
3060 _outCreateOpClassItem(String *str, CreateOpClassItem *node)
3064 switch (node->itemtype)
3066 case OPCLASS_ITEM_OPERATOR:
3067 string_append_char(str, "OPERATOR ");
3068 snprintf(buf, 16, "%d", node->number);
3069 string_append_char(str, buf);
3070 string_append_char(str, " ");
3071 _outOperatorName(str, node->name);
3073 if (node->args != NIL)
3075 string_append_char(str, "(");
3076 _outNode(str, node->args);
3077 string_append_char(str, ")");
3079 if (node->recheck == TRUE)
3080 string_append_char(str, " RECHECK");
3083 case OPCLASS_ITEM_FUNCTION:
3084 string_append_char(str, "FUNCTION ");
3085 snprintf(buf, 16, "%d", node->number);
3086 string_append_char(str, buf);
3087 string_append_char(str, " ");
3088 _outFuncName(str, node->name);
3089 string_append_char(str, "(");
3090 _outNode(str, node->args);
3091 string_append_char(str, ")");
3094 case OPCLASS_ITEM_STORAGETYPE:
3095 string_append_char(str, "STORAGE ");
3096 _outNode(str, node->storedtype);
3106 _outCreateOpClassStmt(String *str, CreateOpClassStmt *node)
3108 string_append_char(str, "CREATE OPERATOR CLASS ");
3109 _outFuncName(str, node->opclassname);
3111 if (node->isDefault == TRUE)
3112 string_append_char(str, " DEFAULT");
3114 string_append_char(str, " FOR TYPE ");
3115 _outNode(str, node->datatype);
3116 string_append_char(str, " USING ");
3117 string_append_char(str, node->amname);
3118 string_append_char(str, " AS ");
3119 _outNode(str, node->items);
3123 _outRemoveOpClassStmt(String *str, RemoveOpClassStmt *node)
3125 string_append_char(str, "DROP OPERATOR CLASS ");
3126 _outFuncName(str, node->opclassname);
3127 string_append_char(str, " USING ");
3128 string_append_char(str, node->amname);
3129 if (node->behavior == DROP_CASCADE)
3130 string_append_char(str, " CASCADE");
3134 _outDropStmt(String *str, DropStmt *node)
3139 string_append_char(str, "DROP ");
3140 switch (node->removeType)
3143 string_append_char(str, "TABLE ");
3146 case OBJECT_SEQUENCE:
3147 string_append_char(str, "SEQUENCE ");
3151 string_append_char(str, "VIEW ");
3155 string_append_char(str, "INDEX ");
3159 string_append_char(str, "TYPE ");
3163 string_append_char(str, "DOMAIN ");
3166 case OBJECT_CONVERSION:
3167 string_append_char(str, "CONVERSION ");
3171 string_append_char(str, "SCHEMA ");
3178 foreach (lc, node->objects)
3183 string_append_char(str, ", ");
3184 _outFuncName(str, lfirst(lc));
3187 if (node->behavior == DROP_CASCADE)
3188 string_append_char(str, " CASCADE");
3192 _outFetchStmt(String *str, FetchStmt *node)
3196 snprintf(buf, 16, "%ld", node->howMany);
3198 if (node->ismove == TRUE)
3199 string_append_char(str, "MOVE ");
3201 string_append_char(str, "FETCH ");
3203 switch (node->direction)
3206 string_append_char(str, "FORWARD ");
3207 if (node->howMany == FETCH_ALL)
3208 string_append_char(str, "ALL ");
3211 string_append_char(str, buf);
3212 string_append_char(str, " ");
3216 case FETCH_BACKWARD:
3217 string_append_char(str, "BACKWARD ");
3218 if (node->howMany == FETCH_ALL)
3219 string_append_char(str, "ALL ");
3222 string_append_char(str, buf);
3223 string_append_char(str, " ");
3227 case FETCH_ABSOLUTE:
3228 if (node->howMany == 1)
3229 string_append_char(str, "FIRST ");
3230 else if (node->howMany == -1)
3231 string_append_char(str, "LAST ");
3234 string_append_char(str, "ABSOLUTE ");
3235 string_append_char(str, buf);
3236 string_append_char(str, " ");
3240 case FETCH_RELATIVE:
3241 string_append_char(str, "RELATIVE ");
3242 string_append_char(str, buf);
3243 string_append_char(str, " ");
3247 string_append_char(str, "IN \"");
3248 string_append_char(str, node->portalname);
3249 string_append_char(str, "\"");
3253 _outPrivilegeList(String *str, List *list)
3259 string_append_char(str, "ALL");
3264 Value *v = lfirst(lc);
3269 string_append_char(str, ", ");
3271 string_append_char(str, v->val.str);
3277 _outFunctionParameter(String *str, FunctionParameter *node)
3281 case FUNC_PARAM_OUT:
3282 string_append_char(str, "OUT ");
3285 case FUNC_PARAM_INOUT:
3286 string_append_char(str, "INOUT ");
3296 string_append_char(str, "\"");
3297 string_append_char(str, node->name);
3298 string_append_char(str, "\" ");
3301 _outNode(str, node->argType);
3305 _outFuncWithArgs(String *str, FuncWithArgs *node)
3307 _outFuncName(str, node->funcname);
3308 string_append_char(str, "(");
3309 _outNode(str, node->funcargs);
3310 string_append_char(str, ")");
3314 _outPrivTarget(String *str, PrivTarget *node)
3316 switch (node->objtype)
3318 case ACL_OBJECT_RELATION:
3319 _outNode(str, node->objs);
3322 case ACL_OBJECT_SEQUENCE:
3323 string_append_char(str, "SEQUENCE ");
3324 _outNode(str, node->objs);
3327 case ACL_OBJECT_FUNCTION:
3328 string_append_char(str, "FUNCTION ");
3329 _outNode(str, node->objs);
3332 case ACL_OBJECT_DATABASE:
3333 string_append_char(str, "DATABASE ");
3334 _outIdList(str, node->objs);
3337 case ACL_OBJECT_LANGUAGE:
3338 string_append_char(str, "LANGUAGE ");
3339 _outIdList(str, node->objs);
3342 case ACL_OBJECT_NAMESPACE:
3343 string_append_char(str, "SCHEMA ");
3344 _outIdList(str, node->objs);
3347 case ACL_OBJECT_TABLESPACE:
3348 string_append_char(str, "TABLESPACE ");
3349 _outIdList(str, node->objs);
3355 _outPrivGrantee(String *str, PrivGrantee *node)
3357 if (node->rolname == NULL)
3358 string_append_char(str, "PUBLIC");
3361 string_append_char(str, "\"");
3362 string_append_char(str, node->rolname);
3363 string_append_char(str, "\"");
3368 _outGrantStmt(String *str, GrantStmt *node)
3372 if (node->is_grant == true)
3373 string_append_char(str, "GRANT ");
3376 string_append_char(str, "REVOKE ");
3377 if (node->grant_option == true)
3378 string_append_char(str, "GRANT OPTION FOR ");
3381 _outPrivilegeList(str, node->privileges);
3383 string_append_char(str, " ON ");
3385 n = makeNode(PrivTarget);
3386 n->objtype = node->objtype;
3387 n->objs = node->objects;
3391 if (node->is_grant == true)
3392 string_append_char(str, " TO ");
3394 string_append_char(str, " FROM ");
3395 _outNode(str, node->grantees);
3397 if (node->is_grant == true && node->grant_option == TRUE)
3398 string_append_char(str, " WITH GRANT OPTION");
3400 if (node->behavior == DROP_CASCADE)
3401 string_append_char(str, " CASCADE");
3405 _outGrantRoleStmt(String *str, GrantRoleStmt *node)
3407 if (node->is_grant == true)
3408 string_append_char(str, "GRANT ");
3411 string_append_char(str, "REVOKE ");
3412 if (node->admin_opt == true)
3413 string_append_char(str, "ADMIN OPTION FOR ");
3416 _outIdList(str, node->granted_roles);
3418 string_append_char(str, node->is_grant == true ? " TO " : " FROM ");
3420 _outIdList(str, node->grantee_roles);
3422 if (node->admin_opt == true && node->is_grant == true)
3423 string_append_char(str, " WITH ADMIN OPTION");
3425 if (node->grantor != NULL)
3427 string_append_char(str, " GRANTED BY \"");
3428 string_append_char(str, node->grantor);
3429 string_append_char(str, "\"");
3432 if (node->behavior == DROP_CASCADE)
3433 string_append_char(str, " CASCADE");
3437 _outFuncOptList(String *str, List *list)
3443 DefElem *e = lfirst(lc);
3444 Value *v = (Value *) e->arg;
3446 if (strcmp(e->defname, "strict") == 0)
3448 if (v->val.ival == TRUE)
3449 string_append_char(str, " STRICT");
3451 string_append_char(str, " CALLED ON NULL INPUT");
3453 else if (strcmp(e->defname, "volatility") == 0)
3455 char *s = v->val.str;
3456 if (strcmp(s, "immutable") == 0)
3457 string_append_char(str, " IMMUTABLE");
3458 else if (strcmp(s, "stable") == 0)
3459 string_append_char(str, " STABLE");
3460 else if (strcmp(s, "volatile") == 0)
3461 string_append_char(str, " VOLATILE");
3463 else if (strcmp(e->defname, "security") == 0)
3465 if (v->val.ival == TRUE)
3466 string_append_char(str, " SECURITY DEFINER");
3468 string_append_char(str, " SECURITY INVOKER");
3470 else if (strcmp(e->defname, "as") == 0)
3472 string_append_char(str, " AS ");
3473 _outNode(str, e->arg);
3475 else if (strcmp(e->defname, "language") == 0)
3477 string_append_char(str, " LANGUAGE '");
3478 string_append_char(str, v->val.str);
3479 string_append_char(str, "'");
3485 _outCreateFunctionStmt(String *str, CreateFunctionStmt *node)
3487 string_append_char(str, "CREATE ");
3488 if (node->replace == true)
3489 string_append_char(str, "OR REPLACE ");
3490 string_append_char(str, "FUNCTION ");
3492 _outFuncName(str, node->funcname);
3494 string_append_char(str, " (");
3495 _outNode(str, node->parameters);
3496 string_append_char(str, ")");
3498 if (node->returnType)
3500 string_append_char(str, " RETURNS ");
3501 _outNode(str, node->returnType);
3504 _outFuncOptList(str, node->options);
3506 if (node->withClause)
3508 string_append_char(str, " WITH ");
3509 _outDefinition(str, node->withClause);
3514 _outAlterFunctionStmt(String *str, AlterFunctionStmt *node)
3516 string_append_char(str, "ALTER FUNCTION ");
3517 _outNode(str, node->func);
3518 _outFuncOptList(str, node->actions);
3522 _outRemoveFuncStmt(String *str, RemoveFuncStmt *node)
3526 case OBJECT_FUNCTION:
3527 string_append_char(str, "DROP FUNCTION ");
3531 case OBJECT_AGGREGATE:
3532 string_append_char(str, "DROP AGGREGATE ");
3535 case OBJECT_OPERATOR:
3536 string_append_char(str, "DROP OPERATOR CLASS ");
3543 if (node->missing_ok)
3544 string_append_char(str, "IF EXISTS ");
3546 _outFuncName(str, node->name);
3548 string_append_char(str, " (");
3549 _outNode(str, node->args);
3550 string_append_char(str, ")");
3552 if (node->behavior == DROP_CASCADE)
3553 string_append_char(str, " CASCADE");
3557 _outCreateCastStmt(String *str, CreateCastStmt *node)
3559 string_append_char(str, "CREATE CAST (");
3560 _outNode(str, node->sourcetype);
3561 string_append_char(str, " AS ");
3562 _outNode(str, node->targettype);
3563 string_append_char(str, ") WITH FUNCTION ");
3564 _outNode(str, node->func);
3566 switch (node->context)
3568 case COERCION_IMPLICIT:
3569 string_append_char(str, " AS IMPLICIT");
3572 case COERCION_ASSIGNMENT:
3573 string_append_char(str, " AS ASSIGNMENT");
3582 _outDropCastStmt(String *str, DropCastStmt *node)
3584 string_append_char(str, "DROP CAST (");
3585 _outNode(str, node->sourcetype);
3586 string_append_char(str, " AS ");
3587 _outNode(str, node->targettype);
3588 string_append_char(str, ")");
3590 if (node->behavior == DROP_CASCADE)
3591 string_append_char(str, " CASCADE");
3595 _outReindexStmt(String *str, ReindexStmt *node)
3597 string_append_char(str, "REINDEX ");
3601 case OBJECT_DATABASE:
3602 if (node->do_system == true && node->do_user == false)
3603 string_append_char(str, "SYSTEM ");
3605 string_append_char(str, "DATABASE ");
3609 string_append_char(str, "INDEX ");
3613 string_append_char(str, "TABLE ");
3621 _outNode(str, node->relation);
3625 string_append_char(str, "\"");
3626 string_append_char(str, (char *) node->name);
3627 string_append_char(str, "\"");
3632 _outAlterObjectSchemaStmt(String *str, AlterObjectSchemaStmt *node)
3634 string_append_char(str, "ALTER ");
3636 switch (node->objectType)
3638 case OBJECT_AGGREGATE:
3639 string_append_char(str, "AGGREGATE ");
3640 _outFuncName(str, node->object);
3641 string_append_char(str, "(");
3642 if (lfirst(list_head(node->objarg)) == NULL)
3643 string_append_char(str, "*");
3645 _outNode(str, lfirst(list_head(node->objarg)));
3646 string_append_char(str, ") SET SCHAME \"");
3647 string_append_char(str, node->newschema);
3648 string_append_char(str, "\"");
3652 string_append_char(str, "DOMAIN ");
3653 _outFuncName(str, node->object);
3654 string_append_char(str, " SET SCHEMA \"");
3655 string_append_char(str, node->newschema);
3656 string_append_char(str, "\"");
3659 case OBJECT_FUNCTION:
3660 string_append_char(str, "FUNCTION ");
3661 _outFuncName(str, node->object);
3662 string_append_char(str, "(");
3663 _outNode(str, node->objarg);
3664 string_append_char(str, ") SET SCHEMA \"");
3665 string_append_char(str, node->newschema);
3666 string_append_char(str, "\"");
3669 case OBJECT_SEQUENCE:
3670 string_append_char(str, "SEQUENCE ");
3671 _outNode(str, node->relation);
3672 string_append_char(str, " SET SCHEMA \"");
3673 string_append_char(str, node->newschema);
3674 string_append_char(str, "\"");
3678 string_append_char(str, "TABLE ");
3679 _outNode(str, node->relation);
3680 string_append_char(str, " SET SCHEMA \"");
3681 string_append_char(str, node->newschema);
3682 string_append_char(str, "\"");
3686 string_append_char(str, "TYPE ");
3687 _outFuncName(str, node->object);
3688 string_append_char(str, " SET SCHEMA \"");
3689 string_append_char(str, node->newschema);
3690 string_append_char(str, "\"");
3699 _outAlterOwnerStmt(String *str, AlterOwnerStmt *node)
3701 string_append_char(str, "ALTER ");
3703 switch (node->objectType)
3705 case OBJECT_AGGREGATE:
3706 string_append_char(str, "AGGREGATE ");
3707 _outFuncName(str, node->object);
3708 string_append_char(str, "(");
3709 if (lfirst(list_head(node->objarg)) == NULL)
3710 string_append_char(str, "*");
3712 _outNode(str, lfirst(list_head(node->objarg)));
3713 string_append_char(str, ") OWNER TO \"");
3714 string_append_char(str, node->newowner);
3715 string_append_char(str, "\"");
3718 case OBJECT_CONVERSION:
3719 string_append_char(str, "CONVERSION ");
3720 _outFuncName(str, node->object);
3721 string_append_char(str, " OWNER TO \"");
3722 string_append_char(str, node->newowner);
3723 string_append_char(str, "\"");
3726 case OBJECT_DATABASE:
3727 string_append_char(str, "DATABASE \"");
3728 _outIdList(str, node->object);
3729 string_append_char(str, "\" OWNER TO \"");
3730 string_append_char(str, node->newowner);
3731 string_append_char(str, "\"");
3735 string_append_char(str, "DOMAIN ");
3736 _outFuncName(str, node->object);
3737 string_append_char(str, " OWNER TO \"");
3738 string_append_char(str, node->newowner);
3739 string_append_char(str, "\"");
3742 case OBJECT_FUNCTION:
3743 string_append_char(str, "FUNCTION ");
3744 _outFuncName(str, node->object);
3745 string_append_char(str, "(");
3746 _outNode(str, node->objarg);
3747 string_append_char(str, ") OWNER TO \"");
3748 string_append_char(str, node->newowner);
3749 string_append_char(str, "\"");
3752 case OBJECT_OPERATOR:
3753 string_append_char(str, "OPERATOR ");
3754 _outOperatorName(str, node->object);
3755 string_append_char(str, "(");
3756 _outOperatorArgTypes(str, node->objarg);
3757 string_append_char(str, ") OWNER TO \"");
3758 string_append_char(str, node->newowner);
3759 string_append_char(str, "\"");
3762 case OBJECT_OPCLASS:
3763 string_append_char(str, "OPERATOR CLASS ");
3764 _outFuncName(str, node->object);
3765 string_append_char(str, " USING ");
3766 string_append_char(str, node->addname);
3767 string_append_char(str, " OWNER TO \"");
3768 string_append_char(str, node->newowner);
3769 string_append_char(str, "\"");
3773 string_append_char(str, "SCHEMA \"");
3774 string_append_char(str, linitial(node->object));
3775 string_append_char(str, "\" OWNER TO \"");
3776 string_append_char(str, node->newowner);
3777 string_append_char(str, "\"");
3781 string_append_char(str, "TYPE ");
3782 _outFuncName(str, node->object);
3783 string_append_char(str, " OWNER TO \"");
3784 string_append_char(str, node->newowner);
3785 string_append_char(str, "\"");
3788 case OBJECT_TABLESPACE:
3789 string_append_char(str, "TABLESPACE \"");
3790 string_append_char(str, linitial(node->object));
3791 string_append_char(str, "\" OWNER TO \"");
3792 string_append_char(str, node->newowner);
3793 string_append_char(str, "\"");
3802 _outRuleStmt(String *str, RuleStmt *node)
3804 string_append_char(str, "CREATE ");
3806 string_append_char(str, "OR REPLACE ");
3807 string_append_char(str, "RULE \"");
3808 string_append_char(str, node->rulename);
3809 string_append_char(str, "\" AS ON ");
3811 switch (node->event)
3814 string_append_char(str, "SELECT");
3818 string_append_char(str, "UPDATE");
3822 string_append_char(str, "DELETE");
3826 string_append_char(str, "INSERT");
3833 string_append_char(str, " TO ");
3834 _outNode(str, node->relation);
3836 if (node->whereClause)
3838 string_append_char(str, " WHERE ");
3839 _outNode(str, node->whereClause);
3842 string_append_char(str, " DO ");
3845 string_append_char(str, "INSTEAD ");
3847 if (node->actions == NIL)
3848 string_append_char(str, "NOTHING");
3849 else if (list_length(node->actions) == 1)
3850 _outNode(str, linitial(node->actions));
3856 string_append_char(str, "(");
3858 foreach (lc, node->actions)
3863 string_append_char(str, ";");
3865 _outNode(str, lfirst(lc));
3868 string_append_char(str, ")");
3873 _outViewStmt(String *str, ViewStmt *node)
3876 string_append_char(str, "CREATE OR REPLACE ");
3878 string_append_char(str, "CREATE ");
3880 if (node->view->istemp == TRUE)
3881 string_append_char(str, "TEMP ");
3883 string_append_char(str, "VIEW ");
3884 _outNode(str, node->view);
3888 string_append_char(str, "(");
3889 _outIdList(str, node->aliases);
3890 string_append_char(str, ")");
3893 string_append_char(str, " AS");
3894 _outNode(str, node->query);
3898 _outCreatedbOptList(String *str, List *options)
3902 foreach (lc, options)
3904 DefElem *e = lfirst(lc);
3905 Value *v = (Value *) e->arg;
3909 if (strcmp(e->defname, "template") == 0)
3910 string_append_char(str, " TEMPLATE ");
3911 else if (strcmp(e->defname, "location") == 0)
3913 string_append_char(str, " LOCATION ");
3916 else if (strcmp(e->defname, "tablespace") == 0)
3917 string_append_char(str, " TABLESPACE ");
3918 else if (strcmp(e->defname, "encoding") == 0)
3920 string_append_char(str, " ENCODING ");
3923 else if (strcmp(e->defname, "owner") == 0)
3924 string_append_char(str, " OWNER ");
3925 else if (strcmp(e->defname, "connectionlimit") == 0)
3926 string_append_char(str, " CONNECTION LIMIT ");
3930 string_append_char(str, "DEFAULT");
3931 else if (IsA((Node *)v, String))
3933 string_append_char(str, sconst ? "'" : "'");
3934 string_append_char(str, v->val.str);
3935 string_append_char(str, sconst ? "'" : "'");
3940 snprintf(buf, 16, "%ld", v->val.ival);
3941 string_append_char(str, buf);
3947 _outCreatedbStmt(String *str, CreatedbStmt *node)
3949 string_append_char(str, "CREATE DATABASE \"");
3950 string_append_char(str, node->dbname);
3951 string_append_char(str, "\"");
3953 _outCreatedbOptList(str, node->options);
3957 _outAlterDatabaseStmt(String *str, AlterDatabaseStmt *node)
3959 string_append_char(str, "ALTER DATABASE \"");
3960 string_append_char(str, node->dbname);
3961 string_append_char(str, "\" ");
3963 _outCreatedbOptList(str, node->options);
3967 _outAlterDatabaseSetStmt(String *str, AlterDatabaseSetStmt *node)
3969 string_append_char(str, "ALTER DATABASE \"");
3970 string_append_char(str, node->dbname);
3971 string_append_char(str, "\" ");
3973 _outNode(str, node->setstmt);
3977 _outDropdbStmt(String *str, DropdbStmt *node)
3979 string_append_char(str, "DROP DATABASE \"");
3980 string_append_char(str, node->dbname);
3981 string_append_char(str, "\"");
3985 _outCreateDomainStmt(String *str, CreateDomainStmt *node)
3989 string_append_char(str, "CREATE DOMAIN ");
3990 _outFuncName(str, node->domainname);
3991 string_append_char(str, " ");
3992 _outNode(str, node->typename);
3995 foreach (lc, node->constraints)
3997 string_append_char(str, " ");
3998 _outNode(str, lfirst(lc));
4003 _outAlterDomainStmt(String *str, AlterDomainStmt *node)
4005 string_append_char(str, "ALTER DOMAIN ");
4006 _outFuncName(str, node->typename);
4008 switch (node->subtype)
4013 string_append_char(str, " SET DEFAULT ");
4014 _outNode(str, node->def);
4017 string_append_char(str, " DROP DEFAULT");
4021 string_append_char(str, " DROP NOT NULL");
4025 string_append_char(str, " SET NOT NULL");
4029 string_append_char(str, " ADD ");
4030 _outNode(str, node->def);
4034 string_append_char(str, " DROP CONSTRAINT \"");
4035 string_append_char(str, node->name);
4036 string_append_char(str, "\"");
4037 if (node->behavior == DROP_CASCADE)
4038 string_append_char(str, " CASCADE");
4044 _outCreateConversionStmt(String *str, CreateConversionStmt *node)
4046 string_append_char(str, "CREATE ");
4048 if (node->def == TRUE)
4049 string_append_char(str, "DEFAULT ");
4051 string_append_char(str, "CONVERSION ");
4053 _outFuncName(str, node->conversion_name);
4055 string_append_char(str, " FOR '");
4056 string_append_char(str, node->for_encoding_name);
4057 string_append_char(str, "' TO '");
4058 string_append_char(str, node->to_encoding_name);
4059 string_append_char(str, " FROM ");
4060 _outFuncName(str, node->func_name);
4064 _outPrepareStmt(String *str, PrepareStmt *node)
4066 string_append_char(str, "PREPARE \"");
4067 string_append_char(str, node->name);
4068 string_append_char(str, "\" ");
4070 if (node->argtypes != NIL)
4072 string_append_char(str, "(");
4073 _outNode(str, node->argtypes);
4074 string_append_char(str, ") ");
4077 string_append_char(str, "AS ");
4078 _outNode(str, node->query);
4082 _outExecuteStmt(String *str, ExecuteStmt *node)
4086 IntoClause *into = node->into;
4087 RangeVar *rel = into->rel;
4089 string_append_char(str, "CREATE ");
4090 if (rel->istemp == TRUE)
4091 string_append_char(str, "TEMP ");
4092 string_append_char(str, "TABLE ");
4093 _outNode(str, into->rel);
4094 string_append_char(str, " AS ");
4097 string_append_char(str, "EXECUTE \"");
4098 string_append_char(str, node->name);
4099 string_append_char(str, "\" ");
4101 if (node->params != NIL)
4103 string_append_char(str, "(");
4104 _outNode(str, node->params);
4105 string_append_char(str, ")");
4110 _outLockStmt(String *str, LockStmt *node)
4112 string_append_char(str, "LOCK TABLE ");
4113 _outNode(str, node->relations);
4115 string_append_char(str, " IN ");
4118 case AccessShareLock:
4119 string_append_char(str, "ACCESS SHARE ");
4123 string_append_char(str, "ROW SHARE ");
4126 case RowExclusiveLock:
4127 string_append_char(str, "ROW EXCLUSIVE ");
4130 case ShareUpdateExclusiveLock:
4131 string_append_char(str, "SHARE UPDATE EXCLUSIVE ");
4135 string_append_char(str, "SHARE ");
4138 case ShareRowExclusiveLock:
4139 string_append_char(str, "SHARE ROW EXCLUSIVE ");
4143 string_append_char(str, "EXCLUSIVE ");
4146 case AccessExclusiveLock:
4147 string_append_char(str, "ACCESS EXCLUSIVE ");
4150 string_append_char(str, "MODE");
4152 if (node->nowait == TRUE)
4153 string_append_char(str, " NOWAIT");
4157 _outOperatorArgTypes(String *str, List *args)
4159 TypeName *left, *right;
4161 left = linitial(args);
4162 right = lsecond(args);
4165 _outNode(str, left);
4167 string_append_char(str, "NONE");
4168 string_append_char(str, ", ");
4170 _outNode(str, right);
4172 string_append_char(str, "NONE");
4176 _outCommentStmt(String *str, CommentStmt *node)
4182 string_append_char(str, "COMMENT ON ");
4184 switch (node->objtype)
4186 case OBJECT_AGGREGATE:
4187 string_append_char(str, "AGGREGATE ");
4188 _outFuncName(str, node->objname);
4189 string_append_char(str, "(");
4191 t = linitial(node->objargs);
4195 string_append_char(str, "*");
4196 string_append_char(str, ")");
4199 case OBJECT_FUNCTION:
4200 string_append_char(str, "FUNCTION ");
4201 _outFuncName(str, node->objname);
4202 string_append_char(str, "(");
4203 _outNode(str, node->objargs);
4204 string_append_char(str, ")");
4207 case OBJECT_OPERATOR:
4208 string_append_char(str, "OPERATOR ");
4209 _outOperatorName(str, node->objname);
4210 string_append_char(str, "(");
4211 _outOperatorArgTypes(str, node->objargs);
4212 string_append_char(str, ")");
4215 case OBJECT_CONSTRAINT:
4216 string_append_char(str, "CONSTRAINT \"");
4217 v = lsecond(node->objname);
4218 string_append_char(str, v->val.str);
4219 string_append_char(str, "\" ON ");
4220 _outFuncName(str, linitial(node->objargs));
4224 string_append_char(str, "RULE \"");
4225 v = lsecond(node->objname);
4226 string_append_char(str, v->val.str);
4227 string_append_char(str, "\" ON ");
4228 _outFuncName(str, linitial(node->objargs));
4231 case OBJECT_TRIGGER:
4232 string_append_char(str, "TRIGGER \"");
4233 v = lsecond(node->objname);
4234 string_append_char(str, v->val.str);
4235 string_append_char(str, "\" ON ");
4236 _outFuncName(str, linitial(node->objargs));
4239 case OBJECT_OPCLASS:
4240 string_append_char(str, "OPERATOR CLASS ");
4241 _outFuncName(str, node->objname);
4242 string_append_char(str, " USING ");
4243 v = linitial(node->objargs);
4244 string_append_char(str, v->val.str);
4247 case OBJECT_LARGEOBJECT:
4248 string_append_char(str, "LARGE OBJECT ");
4249 v = linitial(node->objname);
4251 string_append_char(str, v->val.str);
4252 else if (IsA(v, Integer))
4254 snprintf(buf, 16, "%ld", v->val.ival);
4255 string_append_char(str, buf);
4259 string_append_char(str, "CAST (");
4260 _outNode(str, linitial(node->objname));
4261 string_append_char(str, " AS ");
4262 _outNode(str, linitial(node->objargs));
4263 string_append_char(str, ")");
4266 case OBJECT_LANGUAGE:
4267 string_append_char(str, "LANGUAGE ");
4268 _outFuncName(str, node->objname);
4272 switch (node->objtype)
4275 string_append_char(str, "COLUMN ");
4277 case OBJECT_DATABASE:
4278 string_append_char(str, "DATABASE ");
4281 string_append_char(str, "SCHEMA ");
4284 string_append_char(str, "INDEX ");
4286 case OBJECT_SEQUENCE:
4287 string_append_char(str, "SEQUENCE ");
4290 string_append_char(str, "TABLE ");
4293 string_append_char(str, "DOMAIN ");
4296 string_append_char(str, "TYPE ");
4299 string_append_char(str, "VIEW ");
4304 _outFuncName(str, node->objname);
4308 string_append_char(str, " IS ");
4311 string_append_char(str, "'");
4312 string_append_char(str, node->comment);
4313 string_append_char(str, "'");
4316 string_append_char(str, "NULL");
4320 _outRangeSubselect(String *str, RangeSubselect *node)
4322 string_append_char(str, "(");
4323 _outNode(str, node->subquery);
4324 string_append_char(str, ")");
4326 _outNode(str, node->alias);
4330 _outRangeFunction(String *str, RangeFunction *node)
4332 _outNode(str, node->funccallnode);
4335 _outNode(str, node->alias);
4338 if (node->coldeflist)
4340 string_append_char(str, " (");
4341 _outNode(str, node->coldeflist);
4342 string_append_char(str, ")");
4347 _outDiscardStmt(String *str, DiscardStmt *node)
4349 switch (node->target)
4352 string_append_char(str, "DISCARD ALL");
4356 string_append_char(str, "DISCARD TEMP");
4360 string_append_char(str, "DISCARD PLANS");
4369 _outCreateOpFamilyStmt(String *str, CreateOpFamilyStmt *node)
4371 string_append_char(str, "CREATE OPERATOR FAMILY ");
4372 _outIdList(str, node->opfamilyname);
4373 string_append_char(str, " USING \"");
4374 string_append_char(str, node->amname);
4375 string_append_char(str, "\"");
4379 _outAlterOpFamilyStmt(String *str, AlterOpFamilyStmt *node)
4384 _outRemoveOpFamilyStmt(String *str, RemoveOpFamilyStmt *node)
4386 string_append_char(str, "DROP OPERATOR FAMILY ");
4387 if (node->missing_ok)
4388 string_append_char(str, "IF EXISTS ");
4389 _outIdList(str, node->opfamilyname);
4390 string_append_char(str, " USING \"");
4391 string_append_char(str, node->amname);
4392 string_append_char(str, "\"");
4396 _outCreateEnumStmt(String *str, CreateEnumStmt *node)
4398 string_append_char(str, "CREATE TYPE ");
4399 _outIdList(str, node->typename);
4400 string_append_char(str, " AS ENUM (");
4401 _outNode(str, node->vals);
4402 string_append_char(str, ")");
4406 _outDropOwnedStmt(String *str, DropOwnedStmt *node)
4408 string_append_char(str, "DROP OWNED BY ");
4409 _outIdList(str, node->roles);
4410 if (node->behavior == DROP_CASCADE)
4411 string_append_char(str, " CASCADE");
4415 _outReassignOwnedStmt(String *str, ReassignOwnedStmt *node)
4417 string_append_char(str, "REASSIGN OWNED BY ");
4418 _outIdList(str, node->roles);
4419 string_append_char(str, " TO \"");
4420 string_append_char(str, node->newrole);
4421 string_append_char(str, "\"");
4425 _outAlterTSDictionaryStmt(String *str, AlterTSDictionaryStmt *node)
4427 string_append_char(str, "ALTER TEXT SEARCH DICTIONARY ");
4428 _outIdList(str, node->dictname);
4429 string_append_char(str, "(");
4430 _outNode(str, node->options);
4431 string_append_char(str, ")");
4435 _outAlterTSConfigurationStmt(String *str, AlterTSConfigurationStmt *node)
4437 string_append_char(str, "ALTER TEXT SEARCH CONFIGURATION ");
4438 _outIdList(str, node->cfgname);
4439 if (node->override == false && node->replace == false)
4441 string_append_char(str, "ADD MAPPING FOR ");
4442 _outIdList(str, node->tokentype);
4443 string_append_char(str, " WITH ");
4444 _outIdList(str, node->dicts);
4446 else if (node->override == true && node->replace == false)
4448 string_append_char(str, "ALTER MAPPING FOR ");
4449 _outIdList(str, node->tokentype);
4450 string_append_char(str, " WITH ");
4451 _outIdList(str, node->dicts);
4453 else if (node->override == false && node->replace == true)
4455 if (node->tokentype == NIL)
4456 string_append_char(str, "ALTER MAPPING ");
4459 string_append_char(str, "ALTER MAPPING FOR ");
4460 _outIdList(str, node->tokentype);
4462 string_append_char(str, "REPLACE ");
4463 _outNode(str, linitial(node->dicts));
4464 string_append_char(str, " WITH ");
4465 _outNode(str, lsecond(node->dicts));
4467 else if (node->missing_ok == false)
4469 string_append_char(str, " DROP MAPPING FOR ");
4470 _outIdList(str, node->tokentype);
4472 else if (node->missing_ok == true)
4474 string_append_char(str, " DROP MAPPING IF EXISTS FOR ");
4475 _outIdList(str, node->tokentype);
4480 _outXmlExpr(String *str, XmlExpr *node)
4487 _outNode(str, node->args);
4488 string_append_char(str, " IS DOCUMENT");
4492 string_append_char(str, "XMLCONCAT (");
4493 _outNode(str, node->args);
4494 string_append_char(str, ")");
4498 string_append_char(str, "XMLELEMENT (");
4501 string_append_char(str, "NAME \"");
4502 string_append_char(str, node->name);
4503 string_append_char(str, "\"");
4504 if (node->named_args != NIL)
4506 string_append_char(str, ",");
4507 _outIdList(str, node->named_args);
4510 if (node->args != NIL)
4512 string_append_char(str, ",");
4513 _outNode(str, node->args);
4515 string_append_char(str, ")");
4519 string_append_char(str, "XMLFOREST (");
4520 _outNode(str, node->named_args);
4521 string_append_char(str, ")");
4525 string_append_char(str, "XMLPARSE (");
4526 if (node->xmloption == XMLOPTION_DOCUMENT)
4527 string_append_char(str, "DOCUMENT ");
4529 string_append_char(str, "CONTENT ");
4531 _outNode(str, linitial(node->args));
4532 n = lsecond(node->args);
4533 if (n->val.val.str[0] == 't')
4534 string_append_char(str, " PRESERVE WHITESPACE");
4536 string_append_char(str, ")");
4546 _outXmlSerialize(String *str, XmlSerialize *node)
4552 _outInhRelation(String *str, InhRelation *node)
4556 string_append_char(str, "LIKE ");
4557 _outNode(str, node->relation);
4558 foreach (lc, node->options)
4560 CreateStmtLikeOption v;
4561 v = (CreateStmtLikeOption)lfirst(lc);
4565 case CREATE_TABLE_LIKE_INCLUDING_DEFAULTS:
4566 string_append_char(str, " INCLUDING DEFAULTS");
4569 case CREATE_TABLE_LIKE_EXCLUDING_DEFAULTS:
4570 string_append_char(str, " EXCLUDING DEFAULTS");
4573 case CREATE_TABLE_LIKE_INCLUDING_CONSTRAINTS:
4574 string_append_char(str, " INCLUDING CONSTRAINTS");
4577 case CREATE_TABLE_LIKE_EXCLUDING_CONSTRAINTS:
4578 string_append_char(str, " EXCLUDING CONSTRAINTS");
4581 case CREATE_TABLE_LIKE_INCLUDING_INDEXES:
4582 string_append_char(str, " INCLUDING INDEXES");
4585 case CREATE_TABLE_LIKE_EXCLUDING_INDEXES:
4586 string_append_char(str, " EXCLUDING INDEXES");
4596 _outWithDefinition(String *str, List *def_list)
4600 if (list_length(def_list) == 1)
4605 elem = linitial(def_list);
4606 v = (Value *)elem->arg;
4607 if (strcmp(elem->defname, "oids") == 0)
4609 Value *v = (Value *)elem->arg;
4610 if (v->val.ival == 1)
4611 string_append_char(str, " WITH OIDS ");
4613 string_append_char(str, " WITHOUT OIDS ");
4621 string_append_char(str, " WITH ");
4622 _outDefinition(str, def_list);
4626 _outCurrentOfExpr(String *str, CurrentOfExpr *node)
4628 string_append_char(str, "CURRENT OF ");
4629 if (node->cursor_name == NULL)
4632 snprintf(n, sizeof(n), "$%d", node->cursor_param);
4633 string_append_char(str, n);
4636 string_append_char(str, node->cursor_name);
4641 * converts a Node into ascii string and append it to 'str'
4644 _outNode(String *str, void *obj)
4648 else if (IsA(obj, List) ||IsA(obj, IntList) || IsA(obj, OidList))
4650 else if (IsA(obj, Integer) ||
4653 IsA(obj, BitString))
4655 /* nodeRead does not want to see { } around these! */
4656 _outValue(str, obj);
4660 switch (nodeTag(obj))
4663 _outAlias(str, obj);
4666 _outRangeVar(str, obj);
4672 _outConst(str, obj);
4675 _outParam(str, obj);
4678 _outAggref(str, obj);
4681 _outArrayRef(str, obj);
4684 _outFuncExpr(str, obj);
4687 _outOpExpr(str, obj);
4689 case T_DistinctExpr:
4690 _outDistinctExpr(str, obj);
4692 case T_ScalarArrayOpExpr:
4693 _outScalarArrayOpExpr(str, obj);
4696 _outBoolExpr(str, obj);
4699 _outSubLink(str, obj);
4702 _outSubPlan(str, obj);
4705 _outFieldSelect(str, obj);
4708 _outFieldStore(str, obj);
4711 _outRelabelType(str, obj);
4713 case T_ConvertRowtypeExpr:
4714 _outConvertRowtypeExpr(str, obj);
4717 _outCaseExpr(str, obj);
4720 _outCaseWhen(str, obj);
4722 case T_CaseTestExpr:
4723 _outCaseTestExpr(str, obj);
4726 _outArrayExpr(str, obj);
4729 _outRowExpr(str, obj);
4731 case T_CoalesceExpr:
4732 _outCoalesceExpr(str, obj);
4735 _outMinMaxExpr(str, obj);
4738 _outNullIfExpr(str, obj);
4741 _outNullTest(str, obj);
4744 _outBooleanTest(str, obj);
4746 case T_CoerceToDomain:
4747 _outCoerceToDomain(str, obj);
4749 case T_CoerceToDomainValue:
4750 _outCoerceToDomainValue(str, obj);
4752 case T_SetToDefault:
4753 _outSetToDefault(str, obj);
4756 _outTargetEntry(str, obj);
4759 _outRangeTblRef(str, obj);
4762 _outJoinExpr(str, obj);
4765 _outFromExpr(str, obj);
4769 _outCreateStmt(str, obj);
4772 _outIndexStmt(str, obj);
4775 _outNotifyStmt(str, obj);
4777 case T_DeclareCursorStmt:
4778 _outDeclareCursorStmt(str, obj);
4781 _outSelectStmt(str, obj);
4784 _outColumnDef(str, obj);
4787 _outTypeName(str, obj);
4790 _outTypeCast(str, obj);
4793 _outIndexElem(str, obj);
4796 _outSortClause(str, obj);
4799 _outGroupClause(str, obj);
4801 case T_SetOperationStmt:
4802 _outSetOperationStmt(str, obj);
4804 /* case T_RangeTblEntry:
4805 _outRangeTblEntry(str, obj);
4808 _outAExpr(str, obj);
4811 _outColumnRef(str, obj);
4814 _outParamRef(str, obj);
4817 _outAConst(str, obj);
4820 _outA_Indices(str, obj);
4822 case T_A_Indirection:
4823 _outA_Indirection(str, obj);
4826 _outResTarget(str, obj);
4829 _outConstraint(str, obj);
4831 case T_FkConstraint:
4832 _outFkConstraint(str, obj);
4835 _outFuncCall(str, obj);
4838 _outDefElem(str, obj);
4840 case T_LockingClause:
4841 _outLockingClause(str, obj);
4845 _outSortBy(str, obj);
4849 _outInsertStmt(str, obj);
4853 _outUpdateStmt(str, obj);
4857 _outDeleteStmt(str, obj);
4860 case T_TransactionStmt:
4861 _outTransactionStmt(str, obj);
4864 case T_TruncateStmt:
4865 _outTruncateStmt(str, obj);
4869 _outVacuumStmt(str, obj);
4873 _outExplainStmt(str, obj);
4877 _outClusterStmt(str, obj);
4880 case T_CheckPointStmt:
4881 _outCheckPointStmt(str, obj);
4884 case T_ClosePortalStmt:
4885 _outClosePortalStmt(str, obj);
4889 _outListenStmt(str, obj);
4892 case T_UnlistenStmt:
4893 _outUnlistenStmt(str, obj);
4897 _outLoadStmt(str, obj);
4901 _outCopyStmt(str, obj);
4904 case T_DeallocateStmt:
4905 _outDeallocateStmt(str, obj);
4909 _outRenameStmt(str, obj);
4912 case T_CreateRoleStmt:
4913 _outCreateRoleStmt(str, obj);
4916 case T_AlterRoleStmt:
4917 _outAlterRoleStmt(str, obj);
4920 case T_AlterRoleSetStmt:
4921 _outAlterRoleSetStmt(str, obj);
4924 case T_DropRoleStmt:
4925 _outDropRoleStmt(str, obj);
4928 case T_CreateSchemaStmt:
4929 _outCreateSchemaStmt(str, obj);
4932 case T_VariableSetStmt:
4933 _outVariableSetStmt(str, obj);
4936 case T_VariableShowStmt:
4937 _outVariableShowStmt(str, obj);
4940 case T_ConstraintsSetStmt:
4941 _outConstraintsSetStmt(str, obj);
4944 case T_AlterTableStmt:
4945 _outAlterTableStmt(str, obj);
4948 case T_AlterTableCmd:
4949 _outAlterTableCmd(str, obj);
4952 case T_CreateSeqStmt:
4953 _outCreateSeqStmt(str, obj);
4956 case T_AlterSeqStmt:
4957 _outAlterSeqStmt(str, obj);
4960 case T_CreatePLangStmt:
4961 _outCreatePLangStmt(str, obj);
4964 case T_DropPLangStmt:
4965 _outDropPLangStmt(str, obj);
4968 case T_CreateTableSpaceStmt:
4969 _outCreateTableSpaceStmt(str, obj);
4972 case T_DropTableSpaceStmt:
4973 _outDropTableSpaceStmt(str, obj);
4976 case T_CreateTrigStmt:
4977 _outCreateTrigStmt(str, obj);
4980 case T_DropPropertyStmt:
4981 _outDropPropertyStmt(str, obj);
4985 _outDefineStmt(str, obj);
4988 case T_CreateOpClassStmt:
4989 _outCreateOpClassStmt(str, obj);
4992 case T_CreateOpClassItem:
4993 _outCreateOpClassItem(str, obj);
4996 case T_RemoveOpClassStmt:
4997 _outRemoveOpClassStmt(str, obj);
5001 _outDropStmt(str, obj);
5005 _outFetchStmt(str, obj);
5009 _outGrantStmt(str, obj);
5013 _outPrivTarget(str, obj);
5016 case T_FuncWithArgs:
5017 _outFuncWithArgs(str, obj);
5020 case T_FunctionParameter:
5021 _outFunctionParameter(str, obj);
5025 _outPrivGrantee(str, obj);
5028 case T_GrantRoleStmt:
5029 _outGrantRoleStmt(str, obj);
5032 case T_CreateFunctionStmt:
5033 _outCreateFunctionStmt(str, obj);
5036 case T_AlterFunctionStmt:
5037 _outAlterFunctionStmt(str, obj);
5040 case T_RemoveFuncStmt:
5041 _outRemoveFuncStmt(str, obj);
5044 case T_CreateCastStmt:
5045 _outCreateCastStmt(str, obj);
5048 case T_DropCastStmt:
5049 _outDropCastStmt(str, obj);
5053 _outReindexStmt(str, obj);
5056 case T_AlterObjectSchemaStmt:
5057 _outAlterObjectSchemaStmt(str, obj);
5060 case T_AlterOwnerStmt:
5061 _outAlterOwnerStmt(str, obj);
5065 _outRuleStmt(str, obj);
5069 _outViewStmt(str, obj);
5072 case T_CreatedbStmt:
5073 _outCreatedbStmt(str, obj);
5076 case T_AlterDatabaseStmt:
5077 _outAlterDatabaseStmt(str, obj);
5081 case T_AlterDatabaseSetStmt:
5082 _outAlterDatabaseSetStmt(str, obj);
5086 _outDropdbStmt(str, obj);
5089 case T_CreateDomainStmt:
5090 _outCreateDomainStmt(str, obj);
5093 case T_AlterDomainStmt:
5094 _outAlterDomainStmt(str, obj);
5097 case T_CreateConversionStmt:
5098 _outCreateConversionStmt(str, obj);
5102 _outPrepareStmt(str, obj);
5106 _outExecuteStmt(str, obj);
5110 _outLockStmt(str, obj);
5114 _outCommentStmt(str, obj);
5117 case T_RangeSubselect:
5118 _outRangeSubselect(str, obj);
5121 case T_RangeFunction:
5122 _outRangeFunction(str, obj);
5126 _outDiscardStmt(str, obj);
5129 case T_CreateOpFamilyStmt:
5130 _outCreateOpFamilyStmt(str, obj);
5133 case T_AlterOpFamilyStmt:
5134 _outAlterOpFamilyStmt(str, obj);
5137 case T_RemoveOpFamilyStmt:
5138 _outRemoveOpFamilyStmt(str, obj);
5141 case T_CreateEnumStmt:
5142 _outCreateEnumStmt(str, obj);
5145 case T_DropOwnedStmt:
5146 _outDropOwnedStmt(str, obj);
5149 case T_ReassignOwnedStmt:
5150 _outReassignOwnedStmt(str, obj);
5153 case T_AlterTSDictionaryStmt:
5154 _outAlterTSDictionaryStmt(str, obj);
5157 case T_AlterTSConfigurationStmt:
5158 _outAlterTSConfigurationStmt(str, obj);
5162 _outXmlExpr(str, obj);
5165 case T_XmlSerialize:
5166 _outXmlSerialize(str, obj);
5170 _outInhRelation(str, obj);
5173 case T_CurrentOfExpr:
5174 _outCurrentOfExpr(str, obj);
5185 * returns the ascii representation of the Node as a palloc'd string
5188 nodeToString(void *obj)
5192 str = init_string("");