1 /*-------------------------------------------------------------------------
4 * Output functions for Postgres tree nodes.
6 * Portions Copyright (c) 1996-2005, PostgreSQL Global Development Group
7 * Portions Copyright (c) 1994, Regents of the University of California
11 * $PostgreSQL: pgsql/src/dblink/nodes/outfuncs.c,v 1.261.2.1 2005/11/14 23:54:34 tgl Exp $
14 * Every node type that can appear in stored rules' parsetrees *must*
15 * have an output function defined here (as well as an input function
16 * in readfuncs.c). For use in debugging, we also provide output
17 * functions for nodes that appear in raw parsetrees, path, and plan trees.
18 * These nodes however need not have input functions.
20 *-------------------------------------------------------------------------
26 #include "parser/parser.h"
27 #include "parser/pool_string.h"
28 #include "parser/pg_list.h"
29 #include "parser/parsenodes.h"
30 #include "pool_rewrite_query.h"
32 #define booltostr(x) ((x) ? "true" : "false")
35 extern void _outNode(String *str, void *obj);
36 static void _rewriteNode(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, void *obj);
37 static void _rewriteList(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *node);
38 static void _rewriteIdList(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *node);
39 static void _rewriteAlias(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, Alias *node);
40 static void _rewriteRangeVar(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RangeVar *node);
41 static void _rewriteVar(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, Var *node);
42 static void _rewriteConst(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, Const *node);
43 static void _rewriteParam(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, Param *node);
44 static void _rewriteAggref(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, Aggref *node);
45 static void _rewriteArrayRef(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ArrayRef *node);
46 static void _rewriteFuncExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FuncExpr *node);
47 static void _rewriteOpExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, OpExpr *node);
48 static void _rewriteDistinctExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DistinctExpr *node);
49 static void _rewriteScalarArrayOpExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ScalarArrayOpExpr *node);
50 static void _rewriteBoolExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, BoolExpr *node);
51 static void _rewriteSubLink(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, SubLink *node);
52 static void _rewriteSubPlan(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, SubPlan *node);
53 static void _rewriteFieldSelect(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FieldSelect *node);
54 static void _rewriteFieldStore(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FieldStore *node);
55 static void _rewriteRelabelType(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RelabelType *node);
56 static void _rewriteConvertRowtypeExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ConvertRowtypeExpr *node);
57 static void _rewriteCaseExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CaseExpr *node);
58 static void _rewriteCaseWhen(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CaseWhen *node);
59 static void _rewriteCaseTestExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CaseTestExpr *node);
60 static void _rewriteArrayExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ArrayExpr *node);
61 static void _rewriteRowExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RowExpr *node);
62 static void _rewriteCoalesceExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CoalesceExpr *node);
63 static void _rewriteMinMaxExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, MinMaxExpr *node);
64 static void _rewriteNullIfExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, NullIfExpr *node);
65 static void _rewriteNullTest(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, NullTest *node);
66 static void _rewriteBooleanTest(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, BooleanTest *node);
67 static void _rewriteCoerceToDomain(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CoerceToDomain *node);
68 static void _rewriteCoerceToDomainValue(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CoerceToDomainValue *node);
69 static void _rewriteSetToDefault(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, SetToDefault *node);
70 static void _rewriteTargetEntry(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, TargetEntry *node);
71 static void _rewriteRangeTblRef(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RangeTblRef *node);
72 static void _rewriteJoinExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, JoinExpr *node);
73 static void _rewriteFromExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FromExpr *node);
74 static void _rewriteCreateStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateStmt *node);
75 static void _rewriteIndexStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, IndexStmt *node);
76 static void _rewriteNotifyStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, NotifyStmt *node);
77 static void _rewriteDeclareCursorStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DeclareCursorStmt *node);
78 static void _rewriteSelectStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, SelectStmt *node);
79 static void _rewriteFuncCall(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FuncCall *node);
80 static void _rewriteDefElem(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DefElem *node);
81 static void _rewriteLockingClause(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, LockingClause *node);
82 static void _rewriteColumnDef(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ColumnDef *node);
83 static void _rewriteTypeName(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, TypeName *node);
84 static void _rewriteTypeCast(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, TypeCast *node);
85 static void _rewriteIndexElem(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, IndexElem *node);
86 static void _rewriteSortClause(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, SortClause *node);
87 static void _rewriteGroupClause(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, GroupClause *node);
88 static void _rewriteSetOperationStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, SetOperationStmt *node);
89 static void _rewriteAExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, A_Expr *node);
90 static void _rewriteValue(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, Value *value);
91 static void _rewriteColumnRef(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ColumnRef *node);
92 static void _rewriteParamRef(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ParamRef *node);
93 static void _rewriteAConst(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, A_Const *node);
94 static void _rewriteA_Indices(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, A_Indices *node);
95 static void _rewriteA_Indirection(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, A_Indirection *node);
96 static void _rewriteResTarget(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ResTarget *node);
97 static void _rewriteConstraint(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, Constraint *node);
98 static void _rewriteFkConstraint(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FkConstraint *node);
100 static void _rewriteSortBy(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, SortBy *node);
101 static void _rewriteInsertStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, InsertStmt *node);
102 static void _rewriteUpdateStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, UpdateStmt *node);
103 static void _rewriteDeleteStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DeleteStmt *node);
104 static void _rewriteTransactionStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, TransactionStmt *node);
105 static void _rewriteTruncateStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, TruncateStmt *node);
106 static void _rewriteVacuumStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, VacuumStmt *node);
107 static void _rewriteExplainStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ExplainStmt *node);
108 static void _rewriteClusterStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ClusterStmt *node);
109 static void _rewriteCheckPointStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CheckPointStmt *node);
110 static void _rewriteClosePortalStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ClosePortalStmt *node);
111 static void _rewriteListenStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ListenStmt *node);
112 static void _rewriteUnlistenStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, UnlistenStmt *node);
113 static void _rewriteLoadStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, LoadStmt *node);
114 static void _rewriteCopyStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CopyStmt *node);
115 static void _rewriteDeallocateStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DeallocateStmt *node);
116 static void _rewriteRenameStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RenameStmt *node);
117 static void _rewriteCreateRoleStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateRoleStmt *node);
118 static void _rewriteAlterRoleStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterRoleStmt *node);
119 static void _rewriteDropRoleStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DropRoleStmt *node);
120 static void _rewriteCreateSchemaStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateSchemaStmt *node);
121 static void _rewriteVariableSetStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, VariableSetStmt *node);
122 static void _rewriteVariableShowStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, VariableShowStmt *node);
123 static void _rewriteConstraintsSetStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ConstraintsSetStmt *node);
124 static void _rewriteAlterTableStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterTableStmt *node);
125 static void _rewriteCreateSeqStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateSeqStmt *node);
126 static void _rewriteAlterSeqStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterSeqStmt *node);
127 static void _rewriteCreatePLangStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreatePLangStmt *node);
128 static void _rewriteDropPLangStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DropPLangStmt *node);
129 static void _rewriteCreateTableSpaceStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateTableSpaceStmt *node);
130 static void _rewriteDropTableSpaceStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DropTableSpaceStmt *node);
131 static void _rewriteCreateTrigStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateTrigStmt *node);
132 static void _rewriteDropPropertyStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DropPropertyStmt *node);
133 static void _rewriteDefineStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DefineStmt *node);
134 static void _rewriteCreateOpClassStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateOpClassStmt *node);
135 static void _rewriteRemoveOpClassStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RemoveOpClassStmt *node);
136 static void _rewriteDropStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DropStmt *node);
137 static void _rewriteFetchStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FetchStmt *node);
138 static void _rewriteGrantStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, GrantStmt *node);
139 static void _rewriteGrantRoleStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, GrantRoleStmt *node);
140 static void _rewriteCreateFunctionStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateFunctionStmt *node);
141 static void _rewriteAlterFunctionStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterFunctionStmt *node);
142 static void _rewriteRemoveFuncStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RemoveFuncStmt *node);
143 static void _rewriteCreateCastStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateCastStmt *node);
144 static void _rewriteDropCastStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DropCastStmt *node);
145 static void _rewriteReindexStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ReindexStmt *node);
146 static void _rewriteRuleStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RuleStmt *node);
147 static void _rewriteViewStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ViewStmt *node);
148 static void _rewriteCreatedbStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreatedbStmt *node);
149 static void _rewriteAlterDatabaseStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterDatabaseStmt *node);
150 static void _rewriteAlterDatabaseSetStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterDatabaseSetStmt *node);
151 static void _rewriteDropdbStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DropdbStmt *node);
152 static void _rewriteCreateDomainStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateDomainStmt *node);
153 static void _rewriteAlterDomainStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterDomainStmt *node);
154 static void _rewriteCreateConversionStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateConversionStmt *node);
155 static void _rewritePrepareStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, PrepareStmt *node);
156 static void _rewriteExecuteStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ExecuteStmt *node);
157 static void _rewriteLockStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, LockStmt *node);
158 static void _rewriteCommentStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CommentStmt *node);
160 static void _rewriteFuncName(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *func_name);
161 static void _rewriteSetRest(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, VariableSetStmt *node);
162 static void _rewriteSetTransactionModeList(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *list);
163 static void _rewriteAlterTableCmd(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterTableCmd *node);
164 static void _rewriteOptSeqList(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *options);
165 static void _rewritePrivGrantee(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, PrivGrantee *node);
166 static void _rewritePrivTarget(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, PrivTarget *node);
167 static void _rewriteFuncWithArgs(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FuncWithArgs *node);
168 static void _rewriteFunctionParameter(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FunctionParameter *node);
169 static void _rewritePrivilegeList(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *list);
170 static void _rewriteFuncOptList(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *list);
171 static void _rewriteCreatedbOptList(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *options);
172 static void _rewriteOperatorArgTypes(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *args);
173 static void _rewriteRangeFunction(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RangeFunction *node);
174 static void _rewriteWithDefinition(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *def_list);
177 static void KeepRewriteQueryCode(RewriteQuery *message, int current_select);
178 static void KeepMessages(RewriteQuery *message,int current_select,int part);
179 static int CheckWhereCaluse(Node *BaseSelect,RewriteQuery *message,ConInfoTodblink *dblink,String *str,int true_count);
180 static int _writewhereClause(A_Expr *expr,RewriteQuery *message,ConInfoTodblink *dblink, String *str,int true_count);
181 static char *escape_string(char *str);
182 static void delay_string_append_char(RewriteQuery *message,String *str, char *parts);
183 static void build_range_info(RewriteQuery *message,DistDefInfo *info,RepliDefInfo *info2,SelectDefInfo *info3,char *alias,int select_num,int i_num);
184 static void AnalyzeReturnRecord(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *list);
185 static void build_virtual_table(RewriteQuery *message,void *obj, int next);
186 static char *search_type_from_virtual(VirtualTable *virtual,char *table,char *col);
187 static int _checkVirtualColumn(ColumnRef *col,RewriteQuery *message);
188 static void SeekColumnName(Aggexpr *agg,ColumnRef *node,int state);
190 static void writeSelectHeader(RewriteQuery *message,ConInfoTodblink *dblink, String *str,int parallel,int state);
191 static void writeSelectFooter(RewriteQuery *message,String *str,AnalyzeSelect *analyze,int state);
192 static void KeepRewriteQueryReturnCode(RewriteQuery *message, int r_code);
193 static void writeRangeHeader(RewriteQuery *message,ConInfoTodblink *dblink, String *str,DistDefInfo *info, RepliDefInfo *info2,char *alias);
194 static void writeRangeFooter(RewriteQuery *message,ConInfoTodblink *dblink, String *str,DistDefInfo *info, RepliDefInfo *info2,char *alias);
195 static bool CheckAggOpt(RewriteQuery *message);
196 static char *GetNameFromColumnRef(ColumnRef *node,bool state);
197 static void AvgFuncCall(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FuncCall *node);
199 /* under define is used in _rewritejoinExpr */
202 #define JNATURAL_INNER 2
203 #define JNATURAL_LEFT 3
204 #define JNATURAL_RIGHT 4
205 #define JNATURAL_FULL 5
212 #define LOADBALANCE false
213 #define PARALLEL true
215 #define SELECT_START -1
216 #define SELECT_FROMCLAUSE 0
217 #define SELECT_TARGETLIST 1
218 #define SELECT_WHERECLAUSE 2
219 #define SELECT_GROUPBYCLAUSE 3
220 #define SELECT_HAVINGCLAUSE 4
221 #define SELECT_SORTCLAUSE 5
222 #define SELECT_OFFSETCLAUSE 6
223 #define SELECT_LIMITCLAUSE 7
224 #define SELECT_OTHER 8
226 static char *escape_string(char *str)
228 int len = strlen(str), i, j;
229 char *es = palloc0(len * 2 + 1);
236 for (i = 0, j = 0; i < len; i++, j++)
242 else if (str[i] == '\\')
253 delay_string_append_char(RewriteQuery *message,String *str, char *parts)
255 if(message->r_code == SELECT_DEFAULT && message->ignore_rewrite == -1)
259 string_append_char( str, parts);
261 pool_debug("debug Rewrite Query %s", str->data);
265 message->r_code = SELECT_RELATION_ERROR;
271 * Is this column member of table (message->table_relname) ?
273 * return 0 or -1 -- not mmeber
276 _checkVirtualColumn(ColumnRef *col,RewriteQuery *message)
280 VirtualTable *virtual = NULL;
281 AnalyzeSelect *analyze = NULL;
283 char *tmp_table = NULL;
284 char *colname = NULL;
287 int no = message->current_select;
292 analyze = message->analyze[no];
294 if(list->length > 2 || list->length == 0)
296 /* send error message */
300 foreach (c, col->fields)
302 Node *n = (Node *) lfirst(c);
306 Value *v = (Value *) lfirst(c);
307 if(list->length == 2 && first == 0)
310 tmp_table = v->val.str;
313 colname = v->val.str;
317 if(analyze->partstate[SELECT_FROMCLAUSE] == 'S')
319 if (message->table_relname)
321 if(tmp_table && strcmp(message->table_relname,tmp_table) != 0)
325 table = message->table_relname;
332 virtual = analyze->virtual;
333 v_colnum = virtual->col_num;
335 for(i = 0; i < v_colnum; i++)
337 if(!strcmp(virtual->table_list[i],table) &&
338 !strcmp(virtual->col_list[i],colname))
345 virtual = analyze->virtual;
346 v_colnum = virtual->col_num;
348 for(i = 0; i < v_colnum; i++)
352 if(!strcmp(virtual->table_list[i],tmp_table) &&
353 !strcmp(virtual->col_list[i],colname))
361 if(!strcmp(virtual->col_list[i],colname))
372 static void KeepMessages(RewriteQuery *message,int current_select,int part)
374 message->current_select = current_select;
375 message->part = part;
378 static void KeepRewriteQueryCode(RewriteQuery *message, int current_select)
380 message->current_select = current_select;
383 static void KeepRewriteQueryReturnCode(RewriteQuery *message, int r_code)
385 if((message->r_code != SELECT_RELATION_ERROR)
386 && (message->r_code != SELECT_PGCATALOG))
387 message->r_code = r_code;
392 * if A_Expr-tree use subquery,function,or other table member
393 * rewrite expression as "TRUE"
395 * return value is counter of rewriting query.
398 _writewhereClause(A_Expr *expr,RewriteQuery *message,ConInfoTodblink *dblink, String *str,int true_count)
400 int message_r_code = message->r_code;
405 if (list_length(expr->name) == 1)
407 KeepRewriteQueryReturnCode(message, SELECT_AEXPR);
408 _rewriteNode(NULL, message, dblink, str, expr->lexpr);
409 if(message->r_code == SELECT_AEXPR)
411 _rewriteNode(NULL, message, dblink, str, expr->rexpr);
412 if(message->r_code == SELECT_AEXPR)
414 Value *op = (Value *) lfirst(list_head(expr->name));
415 KeepRewriteQueryReturnCode(message, message_r_code);
416 _rewriteNode(NULL, message, dblink, str, expr->lexpr);
417 delay_string_append_char(message, str, op->val.str);
418 _rewriteNode(NULL, message, dblink, str, expr->rexpr);
419 KeepRewriteQueryReturnCode(message, message_r_code);
421 KeepRewriteQueryReturnCode(message, message_r_code);
422 delay_string_append_char(message, str,"TRUE");
427 KeepRewriteQueryReturnCode(message, message_r_code);
428 delay_string_append_char(message, str,"TRUE");
435 delay_string_append_char(message, str,"TRUE");
441 delay_string_append_char(message, str, " (");
442 true_count = true_count + CheckWhereCaluse(expr->lexpr,message,dblink,str,true_count);
443 delay_string_append_char(message, str, " AND ");
444 true_count = true_count + CheckWhereCaluse(expr->rexpr,message,dblink,str,true_count);
445 delay_string_append_char(message, str, ")");
449 delay_string_append_char(message, str, " (");
450 true_count = true_count + CheckWhereCaluse(expr->lexpr,message,dblink,str,true_count);
451 delay_string_append_char(message, str, " OR ");
452 true_count = true_count + CheckWhereCaluse(expr->rexpr,message,dblink,str,true_count);
453 delay_string_append_char(message, str, ")");
457 /* not implemented yet */
461 /* not implemented yet */
466 delay_string_append_char(message, str, " (NOT ");
467 CheckWhereCaluse(expr->rexpr,str,tablename,dbname, schemaname,aliasname);
468 delay_string_append_char(message, str, ")");
472 delay_string_append_char(message, str, " (");
473 _rewriteNode(BaseSelect, message, dblink, str, node->lexpr);
474 delay_string_append_char(message, str, " IS DISTINCT FROM ");
475 _rewriteNode(BaseSelect, message, dblink, str, node->rexpr);
476 delay_string_append_char(message, str, ")");
480 delay_string_append_char(message, str, " NULLIF(");
481 _rewriteNode(BaseSelect, message, dblink, str, node->lexpr);
482 delay_string_append_char(message, str, ", ");
483 _rewriteNode(BaseSelect, message, dblink, str, node->rexpr);
484 delay_string_append_char(message, str, ")");
488 _rewriteNode(BaseSelect, message, dblink, str, node->lexpr);
489 if (*(char *)lfirst(list_head(node->name)) == '!')
490 delay_string_append_char(message, str, " IS NOT OF (");
492 delay_string_append_char(message, str, " IS OF (");
493 _rewriteNode(BaseSelect, message, dblink, str, node->rexpr);
494 delay_string_append_char(message, str, ")");
498 delay_string_append_char(message, str,"TRUE");
506 * Start whereClasue check
507 * call _writewherelause();
509 * if messgae->r_code is SELECT DEFAULT,
510 * write down whereClause
514 * return value is counter of rewriting query
515 * if return value is zero, all whereclause can insert dblink function.
518 CheckWhereCaluse(Node *BaseSelect,RewriteQuery *message,ConInfoTodblink *dblink,String *str,int true_count)
522 if(!IsA(BaseSelect, A_Expr))
524 delay_string_append_char(message, str, "TRUE");
529 expr = (A_Expr *) BaseSelect;
531 if(expr->kind == AEXPR_NOT)
533 delay_string_append_char(message, str, "TRUE");
537 true_count = _writewhereClause(expr,message,dblink,str,true_count);
541 static void _rewriteIdList(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *node)
548 Value *v = lfirst(lc);
553 delay_string_append_char(message, str, ", ");
555 delay_string_append_char(message, str, "\"");
556 delay_string_append_char(message, str, v->val.str);
557 delay_string_append_char(message, str, "\"");
561 static void _rewriteList(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *node)
565 char state = (char)0;
568 int current_select = message->current_select;
571 AnalyzeSelect *analyze;
573 analyze = message->analyze[current_select];
575 if(message->r_code == SELECT_DEFAULT && message->ignore_rewrite == -1 &&
576 analyze->part == SELECT_TARGETLIST)
578 if(analyze->retlock == false)
581 analyze->retlock = true;
587 next = message->analyze_num;
594 if(lfirst(lc) && !IsA(lfirst(lc),A_Indices))
595 delay_string_append_char(message, str, ",");
599 if(message->r_code == SELECT_ANALYZE && message->fromClause)
601 if(lfirst(lc) && IsA(lfirst(lc),JoinExpr))
605 analyze->join = (JoinTable *) palloc(sizeof(JoinTable));
607 analyze->join->col_num = 0;
608 analyze->join->col_list = NULL;
609 analyze->join->type_list = NULL;
610 analyze->join->table_list = NULL;
611 analyze->join->using_list = NULL;
612 analyze->join->using_length = 0;
613 analyze->join->state = (char)0;
617 from = message->fromClause;
618 _rewriteNode(BaseSelect, message, dblink, str, lfirst(lc));
619 message->current_select = current_select;
620 message->fromClause = from;
622 if(message->r_code == SELECT_ANALYZE && message->fromClause)
627 if(IsA(lfirst(lc),JoinExpr))
629 JoinExpr *join = lfirst(lc);
632 _rewriteNode(BaseSelect, message, dblink, str, join->quals);
640 state = message->table_state;
644 if(state =='L' && message->table_state == 'L')
646 message->table_state = 'L';
648 else if (state == 'L' && message->table_state == 'P')
650 message->table_state = 'P';
652 else if (state == 'P' && message->table_state == 'L')
654 message->table_state = 'P';
659 message->table_state = 'S';
665 if(message->r_code == SELECT_DEFAULT && message->ignore_rewrite == -1 &&
666 analyze->part == SELECT_TARGETLIST)
668 pool_debug("_rewriteList select=%d,count=%d", current_select,message->analyze[current_select]->ret_count);
670 message->analyze[current_select]->ret_count++;
674 if(message->r_code == SELECT_DEFAULT && message->ignore_rewrite == -1 &&
675 analyze->part == SELECT_TARGETLIST)
677 if(analyze->retlock && lock)
679 analyze->retlock = false;
685 /*****************************************************************************
687 * Stuff from primnodes.h.
689 *****************************************************************************/
692 _rewriteAlias(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, Alias *node)
694 delay_string_append_char(message, str, " AS ");
695 delay_string_append_char(message, str, node->aliasname);
696 delay_string_append_char(message, str, " ");
700 delay_string_append_char(message, str, "(");
701 _rewriteNode(BaseSelect, message, dblink, str, node->colnames);
702 delay_string_append_char(message, str, ")");
707 append_all_virtual(AnalyzeSelect *analyze,char *table)
709 VirtualTable *virtual;
710 SelectDefInfo *select_ret;
717 virtual = analyze->virtual;
718 test_num = virtual->col_num;
719 select_ret = analyze->select_ret;
720 base = select_ret->col_num;
729 for(i = 0; i< test_num; i++)
731 if(!strcmp(virtual->table_list[i],table))
738 select_ret->col_list = (char **) palloc(num * sizeof(char *));
739 select_ret->type_list = (char **) palloc(num * sizeof(char *));
740 select_ret->return_list = (int *) palloc(num * sizeof(int));
744 select_ret->col_list = (char **) repalloc(select_ret->col_list,(base + num) * sizeof(char *));
745 select_ret->type_list = (char **) repalloc(select_ret->type_list,(base + num) * sizeof(char *));
746 select_ret->return_list = (int *) repalloc(select_ret->return_list,(base + num) * sizeof(int));
749 for(i = 0; i< test_num;i++)
751 if(table && strcmp(virtual->table_list[i],table))
755 select_ret->col_list[base + counter] = virtual->col_list[i];
756 select_ret->type_list[base + counter] = virtual->type_list[i];
757 select_ret->return_list[base + counter] = -1;
758 pool_debug("append_all_virtual: analyze[%d] col=%s,type=%s", analyze->now_select,
759 select_ret->col_list[base + counter],select_ret->type_list[base + counter]);
762 select_ret->col_num = base + num;
766 append_select_def_info(SelectDefInfo *select_ret,char *col,char *type)
770 base = select_ret->col_num;
771 pool_debug("append_select_def_info: base=%d",base);
775 type = (char *)palloc(sizeof(char) * strlen("text") + 1);
781 select_ret->col_list = (char **) palloc(sizeof(char *));
782 select_ret->type_list = (char **) palloc(sizeof(char *));
783 select_ret->return_list = (int *) palloc(sizeof(int));
787 select_ret->col_list = (char **) repalloc(select_ret->col_list,(base + 1) * sizeof(char *));
788 select_ret->type_list = (char **) repalloc(select_ret->type_list,(base + 1) * sizeof(char *));
789 select_ret->return_list = (int *) repalloc(select_ret->return_list,(base + 1) * sizeof(int));
792 select_ret->col_list[base] = col;
793 select_ret->type_list[base] = type;
794 select_ret->return_list[base] = -1;
796 select_ret->col_num++;
797 pool_debug("append_select_def_info: col=%s,type=%s base=%d",
798 select_ret->col_list[base],select_ret->type_list[base],select_ret->col_num);
801 static char *search_type_from_virtual(VirtualTable *virtual,char *table,char *col)
803 int num = virtual->col_num;
806 for(i = 0; i < num; i++)
810 if(!strcmp(virtual->table_list[i],table)
811 && !strcmp(virtual->col_list[i],col))
812 return virtual->type_list[i];
816 if(!strcmp(virtual->col_list[i],col))
817 return virtual->type_list[i];
825 AnalyzeReturnRecord(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *list)
829 AnalyzeSelect *analyze;
831 VirtualTable *virtual;
836 select_num = message->current_select;
838 analyze=message->analyze[select_num];
840 virtual = analyze->virtual;
842 /* get range table info */
843 range_num = analyze->rangeinfo_num;
845 /* "range = 0" means that this select stmt have no table */
846 range = analyze->range;
848 analyze->select_ret = (SelectDefInfo *) palloc(sizeof(SelectDefInfo));
850 analyze->select_ret->valid = false;
851 analyze->select_ret->col_num = 0;
853 pool_debug("AnalyzeReturnRecord: current_select=%d",select_num);
857 ResTarget *target = NULL;
858 Node *n = lfirst(lc);
861 char *typecast = NULL;
862 char *colname = NULL;
863 char *table_name = NULL;
864 char *gettype = NULL;
866 target = (ResTarget *) n;
870 alias = target->name;
873 if(IsA(target->val, TypeCast))
875 TypeCast *type = (TypeCast *) target->val;
876 TypeName *typename = (TypeName *)type->typename;
878 typecast = strVal(lfirst(list_head(typename->names)));
882 if(typecast && alias)
884 append_select_def_info(analyze->select_ret,alias,typecast);
889 if (obj && (IsA(obj, ColumnRef)))
893 ColumnRef *col = NULL;
895 col = (ColumnRef *) obj;
896 foreach (c, col->fields)
898 Node *n = (Node *) lfirst(c);
902 Value *v = (Value *) lfirst(c);
903 if(col->fields->length == 2 && first == 0)
906 table_name = v->val.str;
909 colname = v->val.str;
913 else if(obj && (IsA(obj, A_Expr)))
916 append_select_def_info(analyze->select_ret,alias,typecast);
920 colname = (char *)palloc(sizeof(char) * strlen("\"?column?\"") + 1);
921 strcpy(colname,"\"?column?\"");
922 append_select_def_info(analyze->select_ret,colname,typecast);
926 else if(obj && (IsA(obj, FuncCall)))
930 append_select_def_info(analyze->select_ret,alias,typecast);
934 FuncCall *func = NULL;
936 func = (FuncCall *) obj;
937 funcname = strVal(lfirst(list_head(func->funcname)));
938 append_select_def_info(analyze->select_ret,funcname,typecast);
942 else if (obj && (IsA(obj,SubLink)))
945 int max = message->analyze_num;
946 AnalyzeSelect *sublink = NULL;
948 for(i = select_num + 1; i < max;i++)
950 sublink = message->analyze[i];
952 if(sublink->last_select == select_num
953 && sublink->part == 1 && c_sublink == n_sublink)
958 if(sublink && (sublink->select_ret->col_num == 1))
962 append_select_def_info(analyze->select_ret,alias,sublink->select_ret->type_list[0]);
968 column = (char *)palloc(sizeof(char) * strlen("\"?column?\"") + 1);
969 strcpy(column,"\"?column?\"");
970 append_select_def_info(analyze->select_ret,column,sublink->select_ret->type_list[0]);
975 else if(obj && (IsA(obj,A_Const)))
977 A_Const *cst = (A_Const *) obj;
980 if(!typecast && cst->typename)
982 Value *v = linitial(cst->typename->names);
983 typecast = v->val.str;
988 column = (char *)palloc(sizeof(char) * strlen("\"?column?\"") + 1);
989 strcpy(column,"\"?column?\"");
993 append_select_def_info(analyze->select_ret,alias,typecast);
997 if(colname && !strcmp(colname,"*"))
999 append_all_virtual(analyze,table_name);
1004 gettype = search_type_from_virtual(virtual,table_name,colname);
1007 char *column = NULL;
1008 column = (char *)palloc(sizeof(char) * strlen("\"?column?\"") + 1);
1009 strcpy(column,"\"?column?\"");
1010 append_select_def_info(analyze->select_ret,column,NULL);
1028 append_select_def_info(analyze->select_ret,t_n,t_t);
1034 append_virtual_table(RewriteQuery *message,VirtualTable *virtual,char **col_list,char **type_list,int col_num,char *table_name,char state,int next)
1039 if(virtual->col_num == 0)
1042 virtual->col_list = (char**) palloc(sizeof(char*) * col_num);
1043 virtual->type_list = (char**) palloc(sizeof(char*) * col_num);
1044 virtual->table_list = (char**) palloc(sizeof(char*) * col_num);
1045 virtual->state_list = (char*) palloc(sizeof(char) * col_num);
1046 virtual->column_no = (int*) palloc(sizeof(int) * col_num);
1047 virtual->valid = (int*) palloc(sizeof(int) * col_num);
1051 base = virtual->col_num;
1052 virtual->col_list = (char**) repalloc(virtual->col_list,sizeof(char*) * (base + col_num));
1053 virtual->type_list = (char**) repalloc(virtual->type_list,sizeof(char*) * (base + col_num));
1054 virtual->table_list = (char**) repalloc(virtual->table_list,sizeof(char*)* (base + col_num));
1055 virtual->state_list = (char*) repalloc(virtual->state_list,sizeof(char) * (base + col_num));
1056 virtual->column_no = (int*) repalloc(virtual->column_no,sizeof(int) * (base + col_num));
1057 virtual->valid = (int*) repalloc(virtual->valid,sizeof(int) * (base + col_num));
1060 for(i = 0; i< col_num; i++)
1064 virtual->col_list[j] = col_list[i];
1065 virtual->type_list[j] = type_list[i];
1066 virtual->table_list[j] = table_name;
1067 virtual->state_list[j] = state;
1069 /* (next > 0) means this function call from RangeSubselect */
1072 AnalyzeSelect *analyze = message->analyze[next];
1073 SelectDefInfo *select_ret;
1074 select_ret = analyze->select_ret;
1075 select_ret->return_list[i] = message->column;
1076 pool_debug("append_virtual_table return_list[%d]=%d,analyze[%d]",i,message->column,next);
1078 virtual->column_no[j] = message->column;
1080 virtual->valid[j] = -1;
1081 pool_debug("append_virtual_table select=%d, no=%d,col=%s,type=%s,table=%s,state=%c,valid=%d",
1082 message->current_select,
1083 virtual->column_no[j],virtual->col_list[j],virtual->type_list[j]
1084 ,virtual->table_list[j],virtual->state_list[j],virtual->valid[j]);
1086 virtual->col_num = base + col_num;
1090 static void append_join_using(AnalyzeSelect *analyze,char **col_list,char **type_list,int col_num,char *table_name)
1093 int same[analyze->join->col_num];
1094 int lvalid[analyze->join->col_num];
1095 int rvalid[col_num];
1101 JoinTable *join = analyze->join;
1102 JoinTable *new = (JoinTable *) palloc(sizeof(JoinTable));
1104 using = join->using_list;
1105 num = join->using_length;
1107 for(i = 0; i < join->col_num; i++)
1109 char *colname = join->col_list[i];
1110 for(j = 0; j < num; j++)
1112 if(!strcmp(colname, using[j]))
1124 for(i = 0; i < col_num; i++)
1126 char *colname = col_list[i];
1127 for(j = 0; j < num; j++)
1129 if(strcmp(colname, using[j]))
1137 total= sc + lc + rc;
1138 new->col_num = total;
1139 new->col_list = (char**) palloc(sizeof(char*) * (total));
1140 new->type_list = (char**) palloc(sizeof(char*) * (total));
1141 new->table_list = (char**) palloc(sizeof(char*) * (total));
1143 for(k = 0; k < sc; k++)
1145 new->col_list[k] = join->col_list[same[k]];
1146 new->type_list[k] = join->type_list[same[k]];
1147 new->table_list[k] = join->table_list[same[k]];
1150 for(k = sc; k < sc + lc; k++)
1152 new->col_list[k] = join->col_list[lvalid[k - sc]];
1153 new->type_list[k] = join->type_list[lvalid[k - sc]];
1154 new->table_list[k] = join->table_list[lvalid[k - sc]];
1156 for(k = sc + lc; k < sc + lc + rc; k++)
1158 new->col_list[k] = col_list[rvalid[k - lc - sc]];
1159 new->type_list[k] = type_list[rvalid[k - lc - sc]];
1162 new->table_list[k] = table_name;
1165 new->table_list[k] = NULL;
1168 analyze->join = new;
1170 for(i = 0; i< analyze->join->col_num; i++)
1172 pool_debug("append_join_using no = %d ,col=%s,type=%s,table=%s",
1173 i,new->col_list[i],new->type_list[i],new->table_list[i]);
1177 static void append_join_natural(AnalyzeSelect *analyze,char **col_list,char **type_list,int base,int col_num,char *table_name)
1180 int rvalid[base + 1];
1181 int linvalid[col_num + 1];
1182 int lvalid[col_num +1];
1189 JoinTable *join = analyze->join;
1190 JoinTable *new = (JoinTable *) palloc(sizeof(JoinTable));
1192 for(i = 0; i < base; i++)
1194 char *colname = join->col_list[i];
1197 for(j = 0; j < col_num; j++)
1199 if(!strcmp(colname, col_list[j]))
1214 linvalid[ic] = array;
1224 total=sc + vc + (col_num - ic);
1225 new->col_num = total;
1226 new->col_list = (char**) palloc(sizeof(char*) * (total));
1227 new->type_list = (char**) palloc(sizeof(char*) * (total));
1228 new->table_list = (char**) palloc(sizeof(char*) * (total));
1230 for(k = 0; k < sc; k++)
1232 new->col_list[k] = join->col_list[same[k]];
1233 new->type_list[k] = join->type_list[same[k]];
1236 new->table_list[k] = table_name;
1239 new->table_list[k] = join->table_list[same[k]];
1242 for(k = sc; k < sc + vc; k++)
1244 new->col_list[k] = join->col_list[rvalid[k - sc]];
1245 new->type_list[k] = join->type_list[rvalid[k - sc]];
1248 new->table_list[k] = table_name;
1251 new->table_list[k] = join->table_list[rvalid[k - sc]];
1255 for(k = 0; k <col_num ; k++)
1259 for(l = 0; l< ic; l++)
1261 if(k == linvalid[l])
1271 for(k = sc + vc; k < sc + vc + count; k++)
1273 new->col_list[k] = col_list[lvalid[k - sc - vc]];
1274 new->type_list[k] = type_list[lvalid[k - sc - vc]];
1277 new->table_list[k] = table_name;
1280 new->table_list[k] = NULL;
1282 analyze->join = new;
1284 for(i = 0; i< analyze->join->col_num; i++)
1286 pool_debug("append_join_natural no = %d ,col=%s,type=%s,table=%s",
1287 i,new->col_list[i],new->type_list[i],new->table_list[i]);
1291 static void append_join_simple(JoinTable *join,char **col_list,char **type_list,int col_num,char *table_name)
1295 pool_debug("append_join_table start");
1297 if(join->col_num == 0)
1300 join->col_list = (char**) palloc(sizeof(char*) * col_num);
1301 join->type_list = (char**) palloc(sizeof(char*) * col_num);
1302 join->table_list = (char**) palloc(sizeof(char*) * col_num);
1306 base = join->col_num;
1307 join->col_list = (char**) repalloc(join->col_list,sizeof(char*) * (base + col_num));
1308 join->type_list = (char**) repalloc(join->type_list,sizeof(char*) * (base + col_num));
1309 join->table_list = (char**) repalloc(join->table_list,sizeof(char*) * (base + col_num));
1312 for(i = 0; i< col_num; i++)
1314 join->col_list[base + i] = col_list[i];
1315 join->type_list[base + i] = type_list[i];
1316 join->table_list[base + i] = table_name;
1317 pool_debug("append_join_table no = %d ,col=%s,type=%s,table=%s",
1318 base + i,join->col_list[base + i],join->type_list[base + i],join->table_list[base + i]);
1320 join->col_num = base + col_num;
1323 static void build_join_table(RewriteQuery *message,char *alias, int type)
1325 char *table_name = NULL;
1328 int left_num,right_num,range_num,select_num;
1329 DistDefInfo *distinfo = NULL;
1330 RepliDefInfo *repliinfo = NULL;
1331 SelectDefInfo *selectinfo = NULL;
1334 AnalyzeSelect *analyze;
1336 select_num = message->current_select;
1337 analyze=message->analyze[select_num];
1338 join = analyze->join;
1339 left_num = join->col_num;
1340 range_num = analyze->rangeinfo_num;
1341 range = analyze->range[range_num - 1];
1342 state = range->state;
1343 lstate = join->state;
1346 distinfo = range->distinfo;
1347 repliinfo = range->repliinfo;
1348 selectinfo = range->selectinfo;
1352 else if(!alias && range->alias)
1353 table_name = range->alias;
1355 if(distinfo && !repliinfo && !selectinfo)
1357 right_num = distinfo->col_num;
1359 table_name = distinfo->table_name;
1360 pool_debug("inside build_join_info dist state=%c %s",range->state,table_name);
1362 if(type == JNATURAL_INNER || type == JNATURAL_RIGHT
1363 || type == JNATURAL_LEFT || type == JNATURAL_FULL)
1364 append_join_natural(analyze,distinfo->col_list,distinfo->type_list,join->col_num,distinfo->col_num,table_name);
1366 append_join_simple(join,distinfo->col_list,distinfo->type_list,distinfo->col_num,table_name);
1368 else if (repliinfo && !distinfo && !selectinfo)
1370 right_num = repliinfo->col_num;
1372 table_name = repliinfo->table_name;
1374 pool_debug("inside build_join_info repli state=%c %s",range->state,table_name);
1376 if(type == JNATURAL_INNER || type == JNATURAL_RIGHT
1377 || type == JNATURAL_LEFT || type == JNATURAL_FULL)
1378 append_join_natural(analyze,repliinfo->col_list,repliinfo->type_list,join->col_num,repliinfo->col_num,table_name);
1379 else if(join->using_length != 0)
1380 append_join_using(analyze,repliinfo->col_list,repliinfo->type_list,repliinfo->col_num,table_name);
1382 append_join_simple(join,repliinfo->col_list,repliinfo->type_list,repliinfo->col_num,table_name);
1384 else if (selectinfo && !repliinfo && !distinfo)
1386 pool_debug("inside build_join_info select state=%c %s",range->state,table_name);
1387 right_num = selectinfo->col_num;
1389 if(type == JNATURAL_INNER || type == JNATURAL_RIGHT
1390 || type == JNATURAL_LEFT || type == JNATURAL_FULL)
1391 append_join_natural(analyze,selectinfo->col_list,selectinfo->type_list,join->col_num,selectinfo->col_num,table_name);
1392 else if(join->using_length != 0)
1393 append_join_using(analyze,selectinfo->col_list,selectinfo->type_list,selectinfo->col_num,table_name);
1395 append_join_simple(join,selectinfo->col_list,selectinfo->type_list,selectinfo->col_num,table_name);
1398 if(type == JDEFAULT)
1400 join->state = state;
1404 join =analyze->join;
1406 if(lstate =='E' || state == 'E')
1411 if(lstate =='L' && state =='L')
1416 if(lstate =='L' && state =='P')
1418 int total = left_num + right_num;
1419 if(type == JRIGHT || type == JNORMAL || type == JINNER || type == JNATURAL_INNER)
1421 else if((join->col_num <= total) && (type == JNATURAL_RIGHT))
1423 else if((join->col_num == total) && (type == JNATURAL_LEFT))
1428 else if(lstate =='P' && state == 'L')
1430 int total = left_num + right_num;
1431 if(type == JLEFT || type == JNORMAL || type == JINNER || type == JNATURAL_INNER)
1433 else if((join->col_num <= total) && (type == JNATURAL_LEFT))
1435 else if((join->col_num == total) && (type == JNATURAL_RIGHT))
1444 static void change_analyze_state(AnalyzeSelect *analyze,char state)
1446 if(state == 'E' || analyze->state == 'E')
1451 analyze->state = state;
1453 else if(analyze->state == 'P' && state =='L')
1455 analyze->state = 'P';
1457 else if(analyze->state == 'L' && state =='P')
1459 analyze->state = 'P';
1461 else if(analyze->state == 'L' && state =='L')
1466 analyze->state = 'S';
1469 static void build_virtual_table(RewriteQuery *message,void *obj,int next)
1474 char *table_name = NULL;
1476 AnalyzeSelect *analyze;
1477 VirtualTable *virtual;
1479 DistDefInfo *distinfo;
1480 RepliDefInfo *repliinfo;
1481 SelectDefInfo *selectinfo;
1483 select_num = message->current_select;
1484 analyze=message->analyze[select_num];
1485 virtual = analyze->virtual;
1488 range_num = analyze->rangeinfo_num;
1489 range = analyze->range[range_num - 1];
1490 distinfo = range->distinfo;
1491 repliinfo = range->repliinfo;
1492 selectinfo = range->selectinfo;
1495 alias = range->alias;
1497 state = range->state;
1499 if(distinfo && !repliinfo && !selectinfo)
1504 table_name = distinfo->table_name;
1506 pool_debug("inside build_virtual_info dist state=%c %s",range->state,table_name);
1507 append_virtual_table(message,virtual,distinfo->col_list,distinfo->type_list,distinfo->col_num,table_name,state,-2);
1508 change_analyze_state(analyze,state);
1511 else if (repliinfo && !distinfo && !selectinfo)
1516 table_name = repliinfo->table_name;
1517 pool_debug("inside build_virtual_info repli state=%c %s",range->state,table_name);
1518 append_virtual_table(message,virtual,repliinfo->col_list,repliinfo->type_list,repliinfo->col_num,table_name,state,-3);
1519 change_analyze_state(analyze,state);
1522 else if (selectinfo && !repliinfo && !distinfo)
1525 pool_debug("inside build_virtual_info select state=%c %s",range->state,table_name);
1526 append_virtual_table(message,virtual,selectinfo->col_list,selectinfo->type_list,selectinfo->col_num,table_name,state,next);
1527 change_analyze_state(analyze,state);
1530 else if (!selectinfo && !repliinfo && !distinfo)
1532 pool_debug("inside build_virtual_info no dist state=%c %s",range->state,alias);
1533 change_analyze_state(analyze,'E');
1538 build_range_info(RewriteQuery *message,DistDefInfo *info,RepliDefInfo *info2,SelectDefInfo *info3,char *alias, int select_num,int i_num)
1541 AnalyzeSelect *analyze;
1543 analyze=message->analyze[select_num];
1547 ++analyze->rangeinfo_num;
1548 num = analyze->rangeinfo_num;
1550 (RangeInfo **) repalloc(analyze->range,sizeof(RangeInfo *) * num);
1552 analyze->range[num-1] = (RangeInfo *) palloc(sizeof(RangeInfo));
1553 pool_debug("inside build_range_info num= %d current_select=%d",num,select_num);
1558 analyze->range = (RangeInfo **) palloc(sizeof(RangeInfo *));
1559 analyze->range[0] = (RangeInfo *) palloc(sizeof(RangeInfo));
1560 analyze->rangeinfo_num = 1;
1561 pool_debug("inside build_range_info num= %d current_select=%d",num,select_num);
1564 analyze->range[num -1]->ret_num = num - 1;
1565 analyze->range[num -1]->selectinfo = NULL;
1566 /* set dist_def_info */
1567 if(info && !info2 && !info3)
1569 message->is_loadbalance = false;
1570 analyze->range[num -1]->distinfo = info;
1571 analyze->range[num -1]->repliinfo = NULL;
1572 analyze->select_ret = NULL;
1573 analyze->range[num -1]->alias = alias;
1574 analyze->range[num -1]->state = 'P';
1575 pool_debug("inside build_range_info dist %d",select_num);
1578 /* set repli_def_info */
1579 if(info2 && !info && !info3)
1581 analyze->range[num -1]->distinfo = NULL;
1582 analyze->range[num -1]->repliinfo = info2;
1583 analyze->select_ret = NULL;
1584 analyze->range[num -1]->alias = alias;
1585 analyze->range[num -1]->state = 'L';
1586 pool_debug("inside build_range_info repli %d",select_num);
1590 /* CALL FROM _rertiteRangeSubselect */
1591 if(info3 && !info && !info2)
1593 char state = (char)0;
1594 analyze->range[num -1]->distinfo = NULL;
1595 analyze->range[num -1]->repliinfo = NULL;
1596 analyze->range[num -1]->selectinfo = info3;
1597 analyze->range[num -1]->alias = alias;
1598 state = message->analyze[i_num]->state;
1599 analyze->range[num -1]->state = state;
1600 pool_debug("inside build_range_info select %d, state = %c (%c)",select_num,state,analyze->state);
1607 analyze->select_ret = NULL;
1608 pool_debug("inside build_range_info error %d",select_num);
1612 if(!info && !info2 && !info3)
1615 message->is_loadbalance = true;
1616 analyze->range[num -1]->distinfo = NULL;
1617 analyze->range[num -1]->repliinfo = NULL;
1618 analyze->range[num -1]->state = 'E';
1619 analyze->select_ret = NULL;
1620 analyze->range[num -1]->alias = alias;
1621 pool_debug("inside build_range_info const or func %d",select_num);
1626 _rewriteRangeVar(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RangeVar *node)
1628 DistDefInfo *info = NULL;
1629 RepliDefInfo *info2 = NULL;
1631 if(message->r_code == SELECT_ANALYZE)
1633 info = pool_get_dist_def_info(dblink->dbname, node->schemaname, node->relname);
1634 info2 = pool_get_repli_def_info(dblink->dbname, node->schemaname, node->relname);
1637 if(!(message->r_code == SELECT_DEFAULT && message->rewritelock == -1 && message->ignore_rewrite == -1))
1639 if (node->catalogname)
1641 delay_string_append_char(message, str, node->catalogname);
1642 delay_string_append_char(message, str, ".");
1645 if (node->schemaname)
1647 delay_string_append_char(message, str, node->schemaname);
1648 delay_string_append_char(message, str, ".");
1650 if(strcmp(node->schemaname,"pg_catalog") == 0)
1652 message->is_pg_catalog = true;
1656 delay_string_append_char(message, str, node->relname);
1660 Alias *alias = node->alias;
1661 _rewriteNode(BaseSelect, message, dblink, str, node->alias);
1662 if(message->r_code == SELECT_ANALYZE)
1663 build_range_info(message,info,info2,NULL,alias->aliasname,message->current_select,-1);
1667 if(message->r_code == SELECT_ANALYZE)
1668 build_range_info(message,info,info2,NULL,node->relname,message->current_select,-1);
1671 if (node->inhOpt == INH_YES)
1673 delay_string_append_char(message, str, " * ");
1679 /* rewrite query using dblink connection */
1680 char *alias_name = NULL;
1681 SelectStmt *select = (SelectStmt *)BaseSelect;
1685 alias_name = node->alias->aliasname;
1688 * iff schemaname is pg_catalog, send query to
1689 * one node not system db.
1691 if(node->schemaname &&
1692 (strcmp(node->schemaname,"pg_catalog") == 0))
1694 message->is_pg_catalog =true;
1698 info = pool_get_dist_def_info(dblink->dbname, node->schemaname, node->relname);
1699 info2 = pool_get_repli_def_info(dblink->dbname, node->schemaname, node->relname);
1701 writeRangeHeader(message,dblink,str,info,info2,alias_name);
1703 if (node->catalogname)
1705 delay_string_append_char(message, str, node->catalogname);
1706 delay_string_append_char(message, str, ".");
1709 if (node->schemaname)
1711 delay_string_append_char(message, str, node->schemaname);
1712 delay_string_append_char(message, str, ".");
1713 message->schemaname = node->schemaname;
1715 if(strcmp(node->schemaname,"pg_catalog") == 0)
1717 message->is_pg_catalog = true;
1722 message->schemaname = NULL;
1724 delay_string_append_char(message, str, node->relname);
1728 delay_string_append_char(message, str, " AS ");
1729 delay_string_append_char(message, str, alias_name);
1732 if(select->whereClause &&
1733 !(message->r_code == SELECT_PGCATALOG))
1736 int message_code = message->r_code;
1737 delay_string_append_char(message, str, " WHERE ");
1739 if(message->table_relname)
1740 temp = message->table_relname;
1743 message->table_relname = alias_name;
1745 message->table_relname = node->relname;
1747 message->rewritelock = message->current_select;
1748 CheckWhereCaluse(select->whereClause, message,dblink,str,0);
1749 message->rewritelock = -1;
1750 message->table_relname = temp;
1751 KeepRewriteQueryReturnCode(message, message_code);
1754 writeRangeFooter(message,dblink,str,info,info2,alias_name);
1756 if (node->inhOpt == INH_YES)
1758 delay_string_append_char(message, str, " * ");
1763 if(message->r_code == SELECT_ANALYZE && message->fromClause)
1765 int next = message->analyze_num;
1766 build_virtual_table(message,node,next);
1771 _rewriteVar(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, Var *node)
1777 _rewriteConst(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, Const *node)
1783 _rewriteParam(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, Param *node)
1789 _rewriteAggref(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, Aggref *node)
1795 _rewriteArrayRef(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ArrayRef *node)
1801 _rewriteFuncExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FuncExpr *node)
1807 _rewriteOpExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, OpExpr *node)
1813 _rewriteDistinctExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DistinctExpr *node)
1819 _rewriteScalarArrayOpExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ScalarArrayOpExpr *node)
1825 _rewriteBoolExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, BoolExpr *node)
1831 _rewriteSubLink(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, SubLink *node)
1833 if(message->r_code == SELECT_AEXPR)
1835 KeepRewriteQueryReturnCode(message, SELECT_AEXPR_FALSE);
1838 _rewriteNode(BaseSelect, message, dblink, str, node->testexpr);
1840 if (node->operName != NIL)
1842 Value *v = linitial(node->operName);
1843 if (strcmp(v->val.str, "=") == 0)
1844 delay_string_append_char(message, str, " IN ");
1847 delay_string_append_char(message, str, v->val.str);
1851 switch (node->subLinkType)
1853 case EXISTS_SUBLINK:
1854 delay_string_append_char(message, str, " EXISTS ");
1858 delay_string_append_char(message, str, " ARRAY ");
1862 if (node->operName != NIL)
1864 Value *v = linitial(node->operName);
1865 if (strcmp(v->val.str, "=") != 0)
1867 delay_string_append_char(message, str, v->val.str);
1868 delay_string_append_char(message, str, " ANY ");
1874 delay_string_append_char(message, str, " ALL ");
1881 if (node->subselect)
1883 int count = message->current_select;
1884 int part = message->part;
1885 delay_string_append_char(message, str, "(");
1886 _rewriteNode(BaseSelect, message, dblink, str, node->subselect);
1887 delay_string_append_char(message, str, ")");
1888 KeepMessages(message,count,part);
1893 _rewriteSubPlan(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, SubPlan *node)
1899 _rewriteFieldSelect(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FieldSelect *node)
1905 _rewriteFieldStore(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FieldStore *node)
1911 _rewriteRelabelType(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RelabelType *node)
1917 _rewriteConvertRowtypeExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ConvertRowtypeExpr *node)
1923 _rewriteCaseExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CaseExpr *node)
1927 delay_string_append_char(message, str, "CASE ");
1929 _rewriteNode(BaseSelect, message, dblink, str, node->arg);
1931 foreach (lc, node->args)
1933 _rewriteNode(BaseSelect, message, dblink, str, lfirst(lc));
1936 if (node->defresult)
1938 delay_string_append_char(message, str, " ELSE ");
1939 _rewriteNode(BaseSelect, message, dblink, str, node->defresult);
1942 delay_string_append_char(message, str, " END");
1946 _rewriteCaseWhen(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CaseWhen *node)
1948 delay_string_append_char(message, str, " WHEN ");
1949 _rewriteNode(BaseSelect, message, dblink, str, node->expr);
1950 delay_string_append_char(message, str, " THEN ");
1951 _rewriteNode(BaseSelect, message, dblink, str, node->result);
1955 _rewriteCaseTestExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CaseTestExpr *node)
1961 _rewriteArrayExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ArrayExpr *node)
1963 delay_string_append_char(message, str, "[");
1964 _rewriteNode(BaseSelect, message, dblink, str, node->elements);
1965 delay_string_append_char(message, str, "]");
1969 _rewriteRowExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RowExpr *node)
1971 if (node->args == NIL)
1972 delay_string_append_char(message, str, "ROW ()");
1975 delay_string_append_char(message, str, "ROW (");
1976 _rewriteNode(BaseSelect, message, dblink, str, node->args);
1977 delay_string_append_char(message, str, ")");
1982 _rewriteCoalesceExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CoalesceExpr *node)
1984 delay_string_append_char(message, str, "COALESCE (");
1985 _rewriteNode(BaseSelect, message, dblink, str, node->args);
1986 delay_string_append_char(message, str, ")");
1990 _rewriteMinMaxExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, MinMaxExpr *node)
1992 if (node->op == IS_GREATEST)
1994 delay_string_append_char(message, str, "GREATEST (");
1995 _rewriteNode(BaseSelect, message, dblink, str, node->args);
1996 delay_string_append_char(message, str, ")");
1998 else if (node->op == IS_LEAST)
2000 delay_string_append_char(message, str, "LEAST (");
2001 _rewriteNode(BaseSelect, message, dblink, str, node->args);
2002 delay_string_append_char(message, str, ")");
2007 _rewriteNullIfExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, NullIfExpr *node)
2013 _rewriteNullTest(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, NullTest *node)
2015 _rewriteNode(BaseSelect, message, dblink, str, node->arg);
2016 if (node->nulltesttype == IS_NOT_NULL)
2017 delay_string_append_char(message, str, " IS NOT NULL");
2019 delay_string_append_char(message, str, " IS NULL");
2023 _rewriteBooleanTest(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, BooleanTest *node)
2025 _rewriteNode(BaseSelect, message, dblink, str, node->arg);
2027 switch (node->booltesttype)
2030 delay_string_append_char(message, str, " IS TRUE");
2034 delay_string_append_char(message, str, " IS NOT TRUE");
2038 delay_string_append_char(message, str, " IS FALSE");
2042 delay_string_append_char(message, str, " IS NOT FALSE");
2046 delay_string_append_char(message, str, " IS UNKNOWN");
2049 case IS_NOT_UNKNOWN:
2050 delay_string_append_char(message, str, " IS NOT UNKNOWN");
2056 _rewriteCoerceToDomain(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CoerceToDomain *node)
2062 _rewriteCoerceToDomainValue(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CoerceToDomainValue *node)
2068 _rewriteSetToDefault(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, SetToDefault *node)
2070 delay_string_append_char(message, str, "DEFAULT");
2074 _rewriteTargetEntry(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, TargetEntry *node)
2080 _rewriteRangeTblRef(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RangeTblRef *node)
2085 static char *GetTableName(Node *node)
2088 if(IsA(node, RangeVar))
2090 RangeVar *range = (RangeVar *)node;
2093 Alias *alias = range->alias;
2094 return alias->aliasname;
2096 return range->relname;
2099 else if (IsA(node,RangeSubselect))
2101 RangeSubselect *select = (RangeSubselect *)node;
2102 Alias * alias = select->alias;
2103 return alias->aliasname;
2108 static int RetVirtualColumn(VirtualTable *virtual, char *tablename, char *colname)
2110 int col_num = virtual->col_num;
2112 for( i = 0; i < col_num; i++)
2114 if(strcmp(virtual->col_list[i], colname) == 0
2115 && strcmp(virtual->table_list[i], tablename) == 0)
2117 return virtual->column_no[i];
2121 /* ERROR OR AMBIGIUS */
2126 ConvertFromUsingToON(RewriteQuery *message, String *str, JoinExpr *node, int select_num)
2132 VirtualTable *virtual = message->analyze[select_num]->virtual;
2134 lname = GetTableName(node->larg);
2135 rname = GetTableName(node->rarg);
2137 delay_string_append_char(message, str, " ON");
2138 foreach (lc, node->using)
2147 delay_string_append_char(message, str, " AND ");
2150 snprintf(lbuf, 16, "%d",RetVirtualColumn(virtual,lname,value->val.str));
2151 snprintf(rbuf, 16, "%d",RetVirtualColumn(virtual,rname,value->val.str));
2152 delay_string_append_char(message, str, " \"pool_c$");
2153 delay_string_append_char(message, str, lbuf);
2154 delay_string_append_char(message, str, "\"");
2155 delay_string_append_char(message, str, " = ");
2156 delay_string_append_char(message, str, "\"pool_c$");
2157 delay_string_append_char(message, str, rbuf);
2158 delay_string_append_char(message, str, "\"");
2159 delay_string_append_char(message, str, " ");
2164 _rewriteJoinExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, JoinExpr *node)
2166 char l_state,r_state;
2169 bool natural = false;
2176 int using_length = 0;
2179 Alias *alias = node->alias;
2181 aliasname = alias->aliasname;
2185 from = message->fromClause;
2186 select_num = message->current_select;
2188 _rewriteNode(BaseSelect, message, dblink, str, node->larg);
2191 message->fromClause = from;
2192 message->current_select = select_num;
2193 l_state = message->table_state;
2195 if(message->r_code == SELECT_ANALYZE &&
2196 (IsA(node->larg, RangeVar) || IsA(node->larg,RangeSubselect)))
2198 build_join_table(message,aliasname,JDEFAULT);
2202 if (node->isNatural == TRUE)
2205 delay_string_append_char(message, str, " NATURAL");
2208 if (node->jointype == JOIN_INNER)
2210 if (node->using == NIL && node->quals == NULL && !node->isNatural)
2213 delay_string_append_char(message, str, " CROSS JOIN ");
2217 delay_string_append_char(message, str, " JOIN ");
2222 else if (node->jointype == JOIN_LEFT)
2224 delay_string_append_char(message, str, " LEFT OUTER JOIN ");
2227 else if (node->jointype == JOIN_FULL)
2229 delay_string_append_char(message, str, " FULL OUTER JOIN ");
2232 else if (node->jointype == JOIN_RIGHT)
2234 delay_string_append_char(message, str, " RIGHT OUTER JOIN ");
2238 _rewriteNode(BaseSelect, message, dblink, str, node->rarg);
2240 r_state = message->table_state;
2241 message->fromClause = from;
2242 message->current_select = select_num;
2244 if(message->r_code == SELECT_ANALYZE)
2246 if(cross && (IsA(node->rarg, RangeVar) || IsA(node->rarg,RangeSubselect)))
2247 build_join_table(message,aliasname,JNORMAL);
2249 if(IsA(node->rarg, RangeVar) || IsA(node->rarg,RangeSubselect))
2251 if(natural && inner)
2252 build_join_table(message,aliasname,JNATURAL_INNER);
2253 else if(natural && left)
2254 build_join_table(message,aliasname,JNATURAL_LEFT);
2255 else if(natural && right)
2256 build_join_table(message,aliasname,JNATURAL_RIGHT);
2257 else if(natural && full)
2258 build_join_table(message,aliasname,JFULL);
2262 if (node->using != NIL && IsA(node->using, List))
2268 using_length= list_length(node->using);
2269 using_list = (char **) palloc(sizeof(char *) * using_length);
2271 if(message->r_code == SELECT_DEFAULT && message->rewritelock == -1
2272 && message->analyze[select_num]->state == 'S')
2274 /* Rewrite Using Cluase to On Clause */
2275 ConvertFromUsingToON(message, str, node, select_num);
2277 delay_string_append_char(message, str, " USING(");
2279 foreach (lc, node->using)
2286 delay_string_append_char(message, str, ",");
2289 delay_string_append_char(message, str, value->val.str);
2290 using_list[count] = value->val.str;
2294 message->analyze[select_num]->join->using_length = using_length;
2295 message->analyze[select_num]->join->using_list = using_list;
2297 delay_string_append_char(message, str, ")");
2301 if(message->r_code == SELECT_ANALYZE)
2303 if(IsA(node->rarg, RangeVar) || IsA(node->rarg,RangeSubselect))
2305 if(!natural && inner){
2306 build_join_table(message,aliasname,JINNER);
2308 else if(!natural && left)
2309 build_join_table(message,aliasname,JLEFT);
2310 else if(!natural && right)
2311 build_join_table(message,aliasname,JRIGHT);
2312 else if(!natural && full)
2313 build_join_table(message,aliasname,JFULL);
2315 message->analyze[select_num]->state = message->analyze[select_num]->join->state;
2320 int on_select = message->analyze_num - 1;
2322 delay_string_append_char(message, str, " ON ");
2323 _rewriteNode(BaseSelect, message, dblink, str, node->quals);
2325 /* This condition means that the sub select is in ON CLAUSE*/
2326 if(on_select < message->analyze_num -1)
2328 int count = message->analyze_num - 1 - on_select;
2329 char joinstate = message->analyze[select_num]->state;
2331 if(joinstate == 'S')
2336 for(i= on_select + 1; i < count + on_select + 1;i++)
2338 char onstate = message->analyze[i]->state;
2339 if (onstate == 'S' || onstate == 'P')
2341 message->analyze[select_num]->state = 'S';
2342 pool_debug("_rewriteJoinExpr: Change Join state from %c to %c",joinstate,
2343 message->analyze[select_num]->state);
2354 _rewriteFromExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FromExpr *node)
2358 /*****************************************************************************
2360 * Stuff from parsenodes.h.
2362 *****************************************************************************/
2365 _rewriteCreateStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateStmt *node)
2367 delay_string_append_char(message, str, "CREATE ");
2368 if (node->relation->istemp)
2369 delay_string_append_char(message, str, "TEMP ");
2370 delay_string_append_char(message, str, "TABLE ");
2371 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
2372 delay_string_append_char(message, str, " (");
2373 _rewriteNode(BaseSelect, message, dblink, str, node->tableElts);
2374 delay_string_append_char(message, str, ") ");
2376 if (node->inhRelations != NIL)
2378 delay_string_append_char(message, str, "INHERITS (");
2379 _rewriteNode(BaseSelect, message, dblink, str, node->inhRelations);
2380 delay_string_append_char(message, str, ")");
2384 _rewriteWithDefinition(BaseSelect, message, dblink, str, node->options);
2386 switch (node->oncommit)
2389 delay_string_append_char(message, str, " ON COMMIT DROP");
2392 case ONCOMMIT_DELETE_ROWS:
2393 delay_string_append_char(message, str, " ON COMMIT DELETE ROWS");
2395 case ONCOMMIT_PRESERVE_ROWS:
2396 delay_string_append_char(message, str, " ON COMMIT PRESERVE ROWS");
2403 if (node->tablespacename)
2405 delay_string_append_char(message, str, " TABLESPACE \"");
2406 delay_string_append_char(message, str, node->tablespacename);
2407 delay_string_append_char(message, str, "\"");
2412 _rewriteIndexStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, IndexStmt *node)
2414 delay_string_append_char(message, str, "CREATE ");
2416 if (node->unique == TRUE)
2417 delay_string_append_char(message, str, "UNIQUE ");
2419 if (node->concurrent == true)
2420 delay_string_append_char(message, str, "INDEX CONCURRENTLY \"");
2422 delay_string_append_char(message, str, "INDEX \"");
2423 delay_string_append_char(message, str, node->idxname);
2424 delay_string_append_char(message, str, "\" ON ");
2425 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
2427 if (strcmp(node->accessMethod, DEFAULT_INDEX_TYPE))
2429 delay_string_append_char(message, str, " USING ");
2430 delay_string_append_char(message, str, node->accessMethod);
2433 delay_string_append_char(message, str, "(");
2434 _rewriteNode(BaseSelect, message, dblink, str, node->indexParams);
2435 delay_string_append_char(message, str, ")");
2437 if (node->tableSpace)
2439 delay_string_append_char(message, str, " TABLESPACE \"");
2440 delay_string_append_char(message, str, node->tableSpace);
2441 delay_string_append_char(message, str, "\"");
2444 if (node->whereClause)
2446 delay_string_append_char(message, str, " WHERE ");
2447 _rewriteNode(BaseSelect, message, dblink, str, node->whereClause);
2452 _rewriteNotifyStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, NotifyStmt *node)
2454 delay_string_append_char(message, str, "NOTIFY ");
2455 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
2459 _rewriteDeclareCursorStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DeclareCursorStmt *node)
2461 delay_string_append_char(message, str, "DECLARE \"");
2462 delay_string_append_char(message, str, node->portalname);
2463 delay_string_append_char(message, str, "\" ");
2465 if (node->options & CURSOR_OPT_SCROLL)
2466 delay_string_append_char(message, str, "SCROLL ");
2467 if (node->options & CURSOR_OPT_BINARY)
2468 delay_string_append_char(message, str, "BINARY ");
2469 if (node->options & CURSOR_OPT_INSENSITIVE)
2470 delay_string_append_char(message, str, "INSENSITIVE ");
2472 delay_string_append_char(message, str, "CURSOR ");
2474 if (node->options & CURSOR_OPT_HOLD)
2475 delay_string_append_char(message, str, "WITH HOLD ");
2477 delay_string_append_char(message, str, "FOR");
2478 _rewriteNode(BaseSelect, message, dblink, str, node->query);
2482 initSelectStmt(RewriteQuery *message,SelectStmt *node)
2487 AnalyzeSelect *analyze;
2489 if(message->r_code != SELECT_ANALYZE && message->r_code != SELECT_DEFAULT)
2492 count = message->analyze_num++;
2493 last = message->current_select;
2494 message->current_select = count;
2496 if(message->r_code == SELECT_ANALYZE)
2500 message->analyze = (AnalyzeSelect **) palloc(sizeof(AnalyzeSelect *));
2501 message->analyze[count]=(AnalyzeSelect *) palloc(sizeof(AnalyzeSelect));
2502 message->part = SELECT_START;
2504 analyze = message->analyze[count];
2505 analyze->now_select = 0;
2506 analyze->last_select = -1;
2507 analyze->part = SELECT_START;
2508 analyze->call_part = SELECT_START;
2512 message->analyze = (AnalyzeSelect **) repalloc(message->analyze,sizeof(AnalyzeSelect *) * (count+1));
2513 message->analyze[count]=(AnalyzeSelect *) palloc(sizeof(AnalyzeSelect));
2514 analyze = message->analyze[count];
2515 analyze->now_select = count;
2516 analyze->last_select = last;
2517 analyze->part = message->part;
2518 analyze->call_part = message->analyze[last]->part;
2521 analyze->range =NULL;
2522 analyze->rangeinfo_num =-1;
2523 analyze->virtual = NULL;
2524 analyze->join = NULL;
2525 analyze->state = (char) 0;
2526 analyze->aggregate = false;
2527 analyze->aggexpr = NULL;
2528 analyze->table_name = NULL;
2529 analyze->select_range = false;
2530 analyze->rarg_count = -1;
2531 analyze->larg_count = -1;
2532 analyze->ret_count = 0;
2533 analyze->retlock = false;
2535 for(i = 0; i< 8; i++)
2536 analyze->partstate[i] = (char)0;
2538 if(node->larg && node->rarg)
2539 analyze->select_union = true;
2541 analyze->select_union = false;
2543 pool_debug("initSelectStmt: ANALYZE now(%d)",message->current_select);
2545 /* set default table_state */
2546 /* S means that tuples was create by systemdb */
2547 /* L means that tuples was create by one node */
2548 /* P means that tuples was create by parallel node */
2549 message->table_state = 'S';
2553 static void writeRangeHeader(RewriteQuery *message,ConInfoTodblink *dblink, String *str,DistDefInfo *info, RepliDefInfo *info2,char *alias)
2556 char *schema = NULL;
2560 pool_debug("writeRangeHeader select_no=%d",message->current_select);
2562 sprintf(port,"%d",dblink->port);
2564 delay_string_append_char(message, str, "dblink(");
2565 delay_string_append_char(message, str, "'");
2566 delay_string_append_char(message, str, "host=");
2567 delay_string_append_char(message, str, dblink->hostaddr);
2568 delay_string_append_char(message, str, " dbname=");
2569 delay_string_append_char(message, str, dblink->dbname);
2570 delay_string_append_char(message, str, " port=");
2571 delay_string_append_char(message, str, port);
2572 delay_string_append_char(message, str, " user=");
2573 delay_string_append_char(message, str, dblink->user);
2575 if(strlen(dblink->password))
2577 delay_string_append_char(message, str, " password=");
2578 delay_string_append_char(message, str, dblink->password);
2581 delay_string_append_char(message, str, "'");
2582 delay_string_append_char(message, str, ",");
2583 delay_string_append_char(message, str, "'");
2587 delay_string_append_char(message, str, "SELECT pool_parallel(\"");
2588 schema = info->schema_name;
2592 table = info->table_name;
2594 else if (!info && info2)
2596 delay_string_append_char(message, str, "SELECT pool_loadbalance(\"");
2597 schema = info2->schema_name;
2601 table = info2->table_name;
2605 VirtualTable *virtual = NULL;
2606 int no = message->current_select;
2611 AnalyzeSelect *analyze = message->analyze[no];
2612 virtual = analyze->virtual;
2613 v_colnum = virtual->col_num;
2615 delay_string_append_char(message, str, "SELECT ");
2617 for(i = 0; i < v_colnum; i++)
2619 if(!strcmp(virtual->table_list[i],table) && virtual->valid[i] != -1)
2624 delay_string_append_char(message, str, virtual->table_list[i]);
2625 delay_string_append_char(message, str, ".");
2626 delay_string_append_char(message, str, virtual->col_list[i]);
2631 delay_string_append_char(message, str, ", ");
2632 delay_string_append_char(message, str, virtual->table_list[i]);
2633 delay_string_append_char(message, str, ".");
2634 delay_string_append_char(message, str, virtual->col_list[i]);
2640 delay_string_append_char(message, str, " * ");
2642 delay_string_append_char(message, str, " FROM ");
2646 static void writeRangeFooter(RewriteQuery *message,ConInfoTodblink *dblink, String *str,DistDefInfo *info, RepliDefInfo *info2,char *alias)
2649 char *schema = NULL;
2652 delay_string_append_char(message, str, "\"");
2653 delay_string_append_char(message, str, ")");
2654 delay_string_append_char(message, str, "'");
2655 delay_string_append_char(message, str, ",false)");
2657 delay_string_append_char(message, str," AS ");
2665 schema = info->schema_name;
2666 table = info->table_name;
2668 else if (!info && info2)
2670 schema = info2->schema_name;
2671 table = info2->table_name;
2678 message->r_code = SELECT_RELATION_ERROR;
2681 delay_string_append_char(message, str, table);
2682 delay_string_append_char(message, str, "(");
2685 VirtualTable *virtual = NULL;
2687 int no = message->current_select;
2688 AnalyzeSelect *analyze = message->analyze[no];
2689 virtual = analyze->virtual;
2690 num = virtual->col_num;
2692 for(i = 0; i < num; i++)
2695 if(!strcmp(virtual->table_list[i],table) && virtual->valid[i] != -1)
2701 delay_string_append_char(message, str, ",");
2703 snprintf(buf, 16, "%d", analyze->virtual->column_no[i]);
2704 delay_string_append_char(message, str,"\"pool_c$");
2705 delay_string_append_char(message, str,buf);
2706 delay_string_append_char(message, str, "\"");
2707 delay_string_append_char(message, str, " ");
2708 delay_string_append_char(message, str,virtual->type_list[i]);
2714 for(i = 0; i < num; i++)
2717 if(!strcmp(virtual->table_list[i],table))
2722 delay_string_append_char(message, str, ",");
2724 snprintf(buf, 16, "%d", analyze->virtual->column_no[i]);
2725 delay_string_append_char(message, str,"\"pool_c$");
2726 delay_string_append_char(message, str,buf);
2727 delay_string_append_char(message, str,"\"");
2728 delay_string_append_char(message, str, " ");
2729 delay_string_append_char(message, str,virtual->type_list[i]);
2733 delay_string_append_char(message, str, ")");
2737 static void writeSelectAggHeader(RewriteQuery *message,ConInfoTodblink *dblink, String *str,int state)
2740 int count = message->current_select;
2741 AnalyzeSelect *analyze;
2746 analyze = message->analyze[count];
2747 agg = analyze->aggexpr;
2749 ret_count = agg->t_num + agg->c_num + agg->h_num;
2751 sprintf(port,"%d",dblink->port);
2752 pool_debug("writeSelectAggHeader select_no=%d state=%d",message->current_select,state);
2754 delay_string_append_char(message, str, "dblink(");
2755 delay_string_append_char(message, str, "'");
2756 delay_string_append_char(message, str, "host=");
2757 delay_string_append_char(message, str, dblink->hostaddr);
2758 delay_string_append_char(message, str, " dbname=");
2759 delay_string_append_char(message, str, dblink->dbname);
2760 delay_string_append_char(message, str, " port=");
2761 delay_string_append_char(message, str, port);
2762 delay_string_append_char(message, str, " user=");
2763 delay_string_append_char(message, str, dblink->user);
2765 if(strlen(dblink->password))
2767 delay_string_append_char(message, str, " password=");
2768 delay_string_append_char(message, str, dblink->password);
2770 delay_string_append_char(message, str, "'");
2771 delay_string_append_char(message, str, ",");
2772 delay_string_append_char(message, str, "'");
2773 delay_string_append_char(message, str, "SELECT pool_parallel(\"");
2774 delay_string_append_char(message, str, "SELECT ");
2776 message->rewritelock = count;
2778 for(i = 0; i< agg->t_num; i++)
2780 char *funcname = NULL;
2781 funcname = strVal(lfirst(list_head(agg->tfunc_p[i]->funcname)));
2782 if(strcmp(funcname,"avg"))
2784 _rewriteFuncCall(NULL,message,NULL,str,agg->tfunc_p[i]);
2788 AvgFuncCall(NULL,message,NULL,str,agg->tfunc_p[i]);
2792 delay_string_append_char(message, str, ",");
2795 for(i = 0; i< agg->c_num; i++)
2797 _rewriteColumnRef(NULL,message,NULL,str,agg->col_p[i]);
2800 delay_string_append_char(message, str, ",");
2803 for(i = 0; i< agg->h_num; i++)
2805 char *funcname = NULL;
2806 funcname = strVal(lfirst(list_head(agg->hfunc_p[i]->funcname)));
2807 if(strcmp(funcname,"avg"))
2809 _rewriteFuncCall(NULL,message,NULL,str,agg->hfunc_p[i]);
2813 AvgFuncCall(NULL,message,NULL,str,agg->hfunc_p[i]);
2817 delay_string_append_char(message, str, ",");
2819 delay_string_append_char(message, str, " FROM ");
2822 static void writeSelectHeader(RewriteQuery *message,ConInfoTodblink *dblink, String *str,int parallel,int state)
2826 sprintf(port,"%d",dblink->port);
2827 pool_debug("writeSelectHeader select_no=%d state=%d",message->current_select,state);
2829 if(state == SELECT_START)
2831 delay_string_append_char(message, str, "SELECT * FROM ");
2834 delay_string_append_char(message, str, "dblink(");
2835 delay_string_append_char(message, str, "'");
2836 delay_string_append_char(message, str, "host=");
2837 delay_string_append_char(message, str, dblink->hostaddr);
2838 delay_string_append_char(message, str, " dbname=");
2839 delay_string_append_char(message, str, dblink->dbname);
2840 delay_string_append_char(message, str, " port=");
2841 delay_string_append_char(message, str, port);
2842 delay_string_append_char(message, str, " user=");
2843 delay_string_append_char(message, str, dblink->user);
2845 if(strlen(dblink->password))
2847 delay_string_append_char(message, str, " password=");
2848 delay_string_append_char(message, str, dblink->password);
2850 delay_string_append_char(message, str, "'");
2851 delay_string_append_char(message, str, ",");
2852 delay_string_append_char(message, str, "'");
2854 delay_string_append_char(message, str, "SELECT pool_parallel(\"");
2856 delay_string_append_char(message, str, "SELECT pool_loadbalance(\"");
2858 if(state == SELECT_FROMCLAUSE)
2860 int no = message->current_select;
2865 AnalyzeSelect *analyze = message->analyze[no];
2867 v_colnum = analyze->virtual->col_num;
2869 delay_string_append_char(message, str, "SELECT ");
2871 for(i = 0; i < v_colnum; i++)
2873 if(analyze->virtual->valid[i] != -1)
2875 char *col_name = analyze->virtual->col_list[i];
2879 //delay_string_append_char(message, str, analyze->virtual->table_list[i]);
2880 //delay_string_append_char(message, str, "ooo.");
2881 if(strcmp(col_name,"\"?column?\""))
2882 delay_string_append_char(message, str, col_name);
2885 delay_string_append_char(message, str, "\"");
2886 delay_string_append_char(message, str, col_name);
2887 delay_string_append_char(message, str, "\"");
2893 delay_string_append_char(message, str, ", ");
2894 delay_string_append_char(message, str, analyze->virtual->table_list[i]);
2895 delay_string_append_char(message, str, ".");
2896 if(strcmp(col_name,"\"?column?\""))
2897 delay_string_append_char(message, str, col_name);
2900 delay_string_append_char(message, str, "\"");
2901 delay_string_append_char(message, str, col_name);
2902 delay_string_append_char(message, str, "\"");
2909 delay_string_append_char(message, str, " * ");
2911 delay_string_append_char(message, str, " FROM ");
2915 static char *estimateFuncTypes(AnalyzeSelect *analyze,FuncCall *func)
2917 char *funcname = NULL;
2920 obj = lfirst(list_head(func->args));
2922 funcname = strVal(lfirst(list_head(func->funcname)));
2924 if(!strcmp(funcname,"max") || !strcmp(funcname,"min"))
2926 if (obj && (IsA(obj, ColumnRef)))
2928 char *table_name = NULL;
2929 char *column_name = NULL;
2930 VirtualTable *virtual = analyze->virtual;
2932 column_name = GetNameFromColumnRef((ColumnRef *) obj,true);
2933 table_name = GetNameFromColumnRef((ColumnRef *) obj ,false);
2934 type = search_type_from_virtual(virtual,table_name,column_name);
2937 else if( obj && (IsA(obj,TypeCast)))
2939 TypeCast *typecast = (TypeCast *) obj;
2940 TypeName *typename = (TypeName *)typecast->typename;
2941 type = strVal(lfirst(list_head(typename->names)));
2946 char *numeric = "numeric";
2947 type = (char *) palloc(sizeof(char) * strlen(numeric) +1);
2948 strcpy(type,numeric);
2952 else if(!strcmp(funcname,"sum"))
2954 char *numeric = "numeric";
2955 type = (char *) palloc(sizeof(char) * strlen(numeric) +1);
2956 strcpy(type,numeric);
2963 static void writeSelectAggFooter(RewriteQuery *message,String *str,AnalyzeSelect *analyze)
2965 int count = message->current_select;
2969 int group_count = 0;
2971 analyze = message->analyze[count];
2972 agg = analyze->aggexpr;
2974 ret_count = agg->t_num + agg->c_num + agg->h_num;
2976 group_count = agg->c_num;
2978 if(group_count != 0)
2980 delay_string_append_char(message, str, " GROUP BY ");
2982 for(i = 0; i< agg->c_num; i++)
2984 _rewriteColumnRef(NULL,message,NULL,str,agg->col_p[i]);
2986 if(group_count != 0)
2987 delay_string_append_char(message, str, ",");
2991 delay_string_append_char(message, str, "\"");
2992 delay_string_append_char(message, str, ")");
2993 delay_string_append_char(message, str, "'");
2994 delay_string_append_char(message, str, ",false)");
2996 delay_string_append_char(message, str," AS ");
2997 delay_string_append_char(message, str, analyze->table_name);
2999 /* symbol of aggregate opt */
3000 delay_string_append_char(message, str,"g");
3001 delay_string_append_char(message, str, " (");
3003 message->rewritelock = -1;
3005 for(i = 0; i < ret_count; i++)
3008 snprintf(buf, 16, "%d", i);
3009 delay_string_append_char(message, str, "pool_g$");
3010 delay_string_append_char(message, str, buf);
3011 delay_string_append_char(message, str, " ");
3015 char *funcname = NULL;
3016 funcname = strVal(lfirst(list_head(agg->tfunc_p[i]->funcname)));
3017 if(!strcmp(funcname,"count"))
3018 delay_string_append_char(message, str, "bigint ");
3019 else if(!strcmp(funcname,"avg"))
3021 delay_string_append_char(message, str, "numeric ");
3022 delay_string_append_char(message, str, ",");
3023 delay_string_append_char(message, str, "pool_g$");
3024 delay_string_append_char(message, str, buf);
3025 delay_string_append_char(message, str, "c");
3026 delay_string_append_char(message, str, " ");
3027 delay_string_append_char(message, str, "bigint ");
3031 char *type = estimateFuncTypes(analyze,agg->tfunc_p[i]);
3032 delay_string_append_char(message, str, type);
3035 else if(i >= agg->t_num && i < agg->t_num + agg->c_num)
3037 char *table_name = NULL;
3038 char *column_name = NULL;
3040 VirtualTable *virtual = analyze->virtual;
3042 column_name = GetNameFromColumnRef(agg->col_p[i - agg->t_num],true);
3043 table_name = GetNameFromColumnRef(agg->col_p[i - agg->t_num],false);
3044 type = search_type_from_virtual(virtual,table_name,column_name);
3045 delay_string_append_char(message, str, type);
3047 else if(i >= agg->t_num + agg->c_num)
3049 char *funcname = NULL;
3050 int arg = i - agg->t_num - agg->c_num;
3051 funcname = strVal(lfirst(list_head(agg->hfunc_p[arg]->funcname)));
3052 if(!strcmp(funcname,"count"))
3053 delay_string_append_char(message, str, "bigint ");
3054 else if(!strcmp(funcname,"avg"))
3056 delay_string_append_char(message, str, "numeric ");
3057 delay_string_append_char(message, str, ",");
3058 delay_string_append_char(message, str, "pool_g$");
3059 delay_string_append_char(message, str, buf);
3060 delay_string_append_char(message, str, "c");
3061 delay_string_append_char(message, str, " ");
3062 delay_string_append_char(message, str, "bigint ");
3066 char *type = estimateFuncTypes(analyze,agg->hfunc_p[arg]);
3067 delay_string_append_char(message, str, type);
3071 if( i + 1 != ret_count)
3072 delay_string_append_char(message, str, ",");
3074 delay_string_append_char(message, str, ") ");
3077 static void writeSelectFooter(RewriteQuery *message,String *str,AnalyzeSelect *analyze,int state)
3081 delay_string_append_char(message, str, "\"");
3082 delay_string_append_char(message, str, ")");
3083 delay_string_append_char(message, str, "'");
3084 delay_string_append_char(message, str, ",false)");
3086 delay_string_append_char(message, str," AS ");
3087 delay_string_append_char(message, str, analyze->table_name);
3088 delay_string_append_char(message, str, "(");
3089 pool_debug("writeSelectFooter %s",analyze->table_name);
3091 if(state != SELECT_FROMCLAUSE)
3093 num = analyze->select_ret->col_num;
3094 for(i = 0; i < num; i++)
3096 delay_string_append_char(message, str, analyze->select_ret->col_list[i]);
3097 delay_string_append_char(message, str, " ");
3098 delay_string_append_char(message, str, analyze->select_ret->type_list[i]);
3100 delay_string_append_char(message, str, ",");
3102 delay_string_append_char(message, str, ")");
3107 num = analyze->virtual->col_num;
3109 for(i = 0; i < num; i++)
3111 if(analyze->virtual->valid[i] != -1)
3116 snprintf(buf, 16, "%d", analyze->virtual->column_no[i]);
3117 delay_string_append_char(message, str, "\"pool_c$");
3118 delay_string_append_char(message, str, buf);
3119 delay_string_append_char(message, str, "\"");
3120 delay_string_append_char(message, str, " ");
3121 delay_string_append_char(message, str, analyze->virtual->type_list[i]);
3124 delay_string_append_char(message, str, ",");
3125 snprintf(buf, 16, "%d", analyze->virtual->column_no[i]);
3126 delay_string_append_char(message, str, "\"pool_c$");
3127 delay_string_append_char(message, str, buf);
3128 delay_string_append_char(message, str, "\"");
3129 delay_string_append_char(message, str, " ");
3130 delay_string_append_char(message, str, analyze->virtual->type_list[i]);
3137 for(i = 0; i < num; i++)
3141 delay_string_append_char(message, str, analyze->virtual->col_list[i]);
3142 delay_string_append_char(message, str, " ");
3143 delay_string_append_char(message, str, analyze->virtual->type_list[i]);
3146 delay_string_append_char(message, str, ",");
3147 delay_string_append_char(message, str, analyze->virtual->col_list[i]);
3148 delay_string_append_char(message, str, " ");
3149 delay_string_append_char(message, str, analyze->virtual->type_list[i]);
3154 delay_string_append_char(message, str, ")");
3159 CopyFromLeftArg(RewriteQuery *message,int current_num)
3161 AnalyzeSelect *l_analyze = message->analyze[current_num + 1];
3162 AnalyzeSelect *analyze = message->analyze[current_num];
3163 VirtualTable *virtual = message->analyze[current_num]->virtual;
3166 char **col_list = NULL;
3167 char **type_list = NULL;
3171 table_name = l_analyze->table_name;
3172 col_list = l_analyze->select_ret->col_list;
3173 type_list = l_analyze->select_ret->type_list;
3174 col_num = l_analyze->select_ret->col_num;
3176 state = l_analyze->state;
3177 append_virtual_table(message,virtual,col_list,type_list,col_num,table_name,state,current_num + 1);
3179 analyze->select_ret = (SelectDefInfo *) palloc(sizeof(SelectDefInfo));
3180 analyze->select_ret->valid = false;
3181 analyze->select_ret->col_num = 0;
3182 for(i =0; i<col_num; i++)
3184 append_select_def_info(analyze->select_ret,col_list[i],type_list[i]);
3190 ChangeStateByCluase(RewriteQuery *message,void *obj,int before, int after)
3192 AnalyzeSelect *analyze;
3193 int count = message->current_select;
3195 if(message->r_code != SELECT_ANALYZE)
3198 analyze = message->analyze[count];
3200 if (obj && analyze->partstate[before] == 'P')
3201 analyze->partstate[after] = 'S';
3203 analyze->partstate[after] = analyze->partstate[before];
3207 ChangeStateRewriteFooter(RewriteQuery *message,String *str,int defore, int after)
3209 AnalyzeSelect *analyze;
3210 int count = message->current_select;
3213 if(message->r_code != SELECT_DEFAULT)
3216 analyze = message->analyze[count];
3218 if(analyze->state == 'S' && message->rewritelock == count
3219 && message->ignore_rewrite == -1)
3221 state = analyze->partstate[defore];
3223 if(state == 'L' || state == 'P')
3225 if(state != analyze->partstate[after])
3227 writeSelectFooter(message,str,analyze,SELECT_FROMCLAUSE);
3228 message->rewritelock = -1;
3235 CheckUnionFromClause(RewriteQuery *message)
3238 int count = message->current_select;
3239 AnalyzeSelect *analyze;
3240 analyze = message->analyze[count];
3242 check = analyze->last_select;
3243 pool_debug("CheckUnion select=%d last_select=%d", count,check);
3249 if(message->analyze[check]->select_union &&
3250 message->analyze[check]->call_part == SELECT_FROMCLAUSE)
3252 pool_debug("CheckUnion true");
3261 _rewriteSelectStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, SelectStmt *node)
3263 BaseSelect = (Node *) node;
3264 AnalyzeSelect *analyze;
3266 int analyze_num = 0;
3267 int target_analyze = 0;
3268 int from_analyze = 0;
3270 bool direct = false;
3271 bool aggrewrite = false;
3273 count = message->analyze_num;
3275 /* Allocate Memory Space and initialize some Flags*/
3276 initSelectStmt(message,node);
3278 if(message->r_code == SELECT_DEFAULT)
3280 if(message->current_select == 0)
3281 pool_debug("_rewriteSelectStmt:START QueryRewrite");
3284 analyze_num = message->analyze_num;
3286 analyze = message->analyze[count];
3287 analyze->part = SELECT_START;
3289 if(message->r_code == SELECT_DEFAULT && message->rewritelock == -1
3290 && message->ignore_rewrite == -1)
3293 if(analyze->state == 'P')
3295 if(analyze->call_part != SELECT_FROMCLAUSE || !CheckUnionFromClause(message))
3297 writeSelectHeader(message,dblink,str,PARALLEL,analyze->part);
3298 message->rewritelock = count;
3305 if(analyze->state == 'L')
3307 if(analyze->call_part != SELECT_FROMCLAUSE && !CheckUnionFromClause(message))
3309 writeSelectHeader(message,dblink,str,LOADBALANCE,analyze->part);
3310 message->rewritelock = count;
3318 if (node->larg) /* SETOP */
3320 if(message->r_code == SELECT_ANALYZE)
3323 char *temp = "pool_t$";
3324 analyze->virtual = (VirtualTable *) palloc(sizeof(VirtualTable));
3325 snprintf(buf, 16, "%d", message->virtual_num);
3326 message->virtual_num++;
3327 analyze->table_name = (char *) palloc(sizeof(char) * (strlen(temp) + strlen(buf) + 1));
3328 strcpy(analyze->table_name,temp);
3329 strcat(analyze->table_name,buf);
3330 analyze->virtual->col_num = 0;
3333 delay_string_append_char(message, str, "(");
3334 message->part = SELECT_START;
3335 _rewriteNode(BaseSelect, message, dblink, str, node->larg);
3336 pool_debug("union larg select_no=%d(%d)",count,message->analyze_num);
3338 delay_string_append_char(message, str, ")");
3339 KeepMessages(message,count,SELECT_START);
3341 /* COPY analyze of left arg */
3342 if(message->r_code == SELECT_ANALYZE)
3344 analyze->larg_count = count + 1;
3345 analyze->rarg_count = message->analyze_num;
3346 pool_debug("_rewriteSelectStmt: COUNT larg=%d, rarg=%d",analyze->larg_count, analyze->rarg_count);
3352 delay_string_append_char(message, str, " UNION ");
3355 case SETOP_INTERSECT:
3356 delay_string_append_char(message, str, " INTERSECT ");
3360 delay_string_append_char(message, str, " EXCEPT ");
3367 delay_string_append_char(message, str, "ALL ");
3371 delay_string_append_char(message, str, "(");
3372 message->part = SELECT_START;
3373 _rewriteNode(BaseSelect, message, dblink, str, node->rarg);
3374 delay_string_append_char(message, str, ")");
3375 KeepMessages(message,count,SELECT_START);
3377 if(message->r_code == SELECT_ANALYZE)
3378 CopyFromLeftArg(message,count);
3381 if(message->r_code == SELECT_ANALYZE)
3383 pool_debug("_rewriteSelectStmt: STATE larg=%c, rarg=%c",message->analyze[analyze->larg_count]->state,
3384 message->analyze[analyze->rarg_count]->state);
3388 if(message->r_code == SELECT_DEFAULT)
3390 pool_debug("_rewriteSelectStmt: DEFAULT COUNT larg=%d, rarg=%d",analyze->larg_count, analyze->rarg_count);
3393 if(message->r_code == SELECT_ANALYZE)
3395 int lcount = analyze->larg_count;
3396 int rcount = analyze->rarg_count;
3397 if(message->analyze[lcount]->state == 'L' &&
3398 message->analyze[rcount]->state == 'L')
3401 for(j = 0; j < SELECT_SORTCLAUSE; j++)
3403 analyze->partstate[j]='L';
3409 for(j = 0; j < SELECT_SORTCLAUSE; j++)
3411 analyze->partstate[j]='S';
3418 if (node->intoClause)
3420 IntoClause *into = node->intoClause;
3421 RangeVar *rel = (RangeVar *)into->rel;
3423 delay_string_append_char(message, str, "CREATE ");
3424 if (rel->istemp == true)
3425 delay_string_append_char(message, str, "TEMP ");
3426 delay_string_append_char(message, str, "TABLE ");
3427 _rewriteNode(BaseSelect, message, dblink, str, into->rel);
3428 KeepRewriteQueryReturnCode(message, SELECT_RELATION_ERROR);
3432 delay_string_append_char(message, str, " (");
3433 _rewriteNode(BaseSelect, message, dblink, str, into->colNames);
3434 delay_string_append_char(message, str, ") ");
3435 KeepRewriteQueryReturnCode(message, SELECT_RELATION_ERROR);
3439 _rewriteWithDefinition(BaseSelect, message, dblink, str, into->options);
3441 switch (into->onCommit)
3444 delay_string_append_char(message, str, " ON COMMIT DROP");
3447 case ONCOMMIT_DELETE_ROWS:
3448 delay_string_append_char(message, str, " ON COMMIT DELETE ROWS");
3451 case ONCOMMIT_PRESERVE_ROWS:
3452 delay_string_append_char(message, str, " ON COMMIT PRESERVE ROWS");
3458 delay_string_append_char(message, str, " AS");
3461 delay_string_append_char(message, str, " SELECT ");
3464 * Check from-clause before Checking target-list
3466 if(node->fromClause)
3468 message->part = SELECT_FROMCLAUSE;
3469 analyze->part = SELECT_FROMCLAUSE;
3470 message->fromClause = true;
3472 if(message->r_code == SELECT_ANALYZE)
3475 char *temp = "pool_t$";
3476 analyze->virtual = (VirtualTable *) palloc(sizeof(VirtualTable));
3477 snprintf(buf, 16, "%d", message->virtual_num);
3478 message->virtual_num++;
3479 analyze->table_name = (char *) palloc(sizeof(char) * (strlen(temp) + strlen(buf) + 1));
3480 strcpy(analyze->table_name,temp);
3481 strcat(analyze->table_name,buf);
3482 analyze->virtual->col_num = 0;
3485 if(message->r_code == SELECT_DEFAULT && message->ignore_rewrite == -1)
3486 message->ignore_rewrite = count;
3488 /* remember analyze_num */
3489 from_analyze = message->analyze_num;
3491 _rewriteNode(BaseSelect, message, dblink, str, node->fromClause);
3493 if(message->r_code == SELECT_DEFAULT && message->ignore_rewrite == count)
3494 message->ignore_rewrite = -1;
3496 message->fromClause = false;
3498 if(message->r_code == SELECT_ANALYZE)
3500 message->table_state = analyze->state;
3501 analyze->partstate[SELECT_FROMCLAUSE] = analyze->state;
3506 /* this is const or function call*/
3507 message->part = SELECT_TARGETLIST;
3508 if(message->r_code == SELECT_ANALYZE)
3509 build_range_info(message,NULL,NULL,NULL,NULL,message->current_select,-1);
3512 message->part = SELECT_OTHER;
3513 analyze->part = SELECT_OTHER;
3515 if (message->r_code == SELECT_ANALYZE && node->groupClause)
3517 analyze->aggregate = true;
3520 if (node->distinctClause)
3522 if(message->r_code == SELECT_ANALYZE)
3523 analyze->partstate[SELECT_TARGETLIST] = 'S';
3526 * DISTINCT optimization
3528 if(message->r_code == SELECT_ANALYZE)
3529 analyze->aggregate = true;
3531 delay_string_append_char(message, str, "DISTINCT ");
3532 if (lfirst(list_head(node->distinctClause)) != NIL)
3534 delay_string_append_char(message, str, "ON (");
3535 _rewriteNode(BaseSelect, message, dblink,str, node->distinctClause);
3536 KeepMessages(message,count,SELECT_OTHER);
3537 delay_string_append_char(message, str, ") ");
3541 message->part = SELECT_TARGETLIST;
3542 analyze->part = SELECT_TARGETLIST;
3544 if(analyze->partstate[SELECT_FROMCLAUSE] == 'P' && analyze->aggregate)
3545 analyze->partstate[SELECT_TARGETLIST] = 'S';
3547 /* TARGETLIST START */
3548 _rewriteNode(BaseSelect, message, dblink, str, node->targetList);
3550 aggrewrite = CheckAggOpt(message);
3552 target_analyze = message->analyze_num;
3554 if(message->r_code == SELECT_ANALYZE)
3556 if (analyze->aggregate && (analyze->partstate[SELECT_FROMCLAUSE] == 'P'
3557 || analyze->partstate[SELECT_TARGETLIST] == 'P'))
3558 analyze->partstate[SELECT_TARGETLIST] = 'S';
3559 else if (!analyze->partstate[SELECT_TARGETLIST])
3560 analyze->partstate[SELECT_TARGETLIST] = analyze->partstate[SELECT_FROMCLAUSE];
3563 KeepMessages(message,count,SELECT_TARGETLIST);
3565 if (node->fromClause && message->r_code != SELECT_ANALYZE)
3568 message->analyze_num = from_analyze;
3570 message->part = SELECT_FROMCLAUSE;
3571 analyze->part = SELECT_FROMCLAUSE;
3572 delay_string_append_char(message, str, " FROM ");
3574 if(message->r_code == SELECT_DEFAULT &&
3575 (analyze->state == 'S' || lock)
3576 && message->rewritelock == -1 && message->ignore_rewrite ==-1)
3578 if(analyze->partstate[SELECT_FROMCLAUSE] == 'L')
3580 writeSelectHeader(message,dblink,str,LOADBALANCE, message->part);
3581 message->rewritelock = count;
3583 else if(analyze->partstate[SELECT_FROMCLAUSE] == 'P')
3587 writeSelectAggHeader(message,dblink,str, message->part);
3591 writeSelectHeader(message,dblink,str,PARALLEL, message->part);
3593 message->rewritelock = count;
3597 message->fromClause = true;
3598 _rewriteNode(BaseSelect, message, dblink, str, node->fromClause);
3599 message->fromClause = false;
3600 KeepMessages(message,count,SELECT_FROMCLAUSE);
3602 if(message->r_code == SELECT_DEFAULT && analyze->state == 'S'
3603 && message->rewritelock == count && message->ignore_rewrite == -1)
3605 if(analyze->partstate[SELECT_FROMCLAUSE] == 'L')
3607 if(analyze->partstate[SELECT_WHERECLAUSE] != 'L')
3609 if(node->whereClause)
3611 int message_code = message->r_code;
3612 delay_string_append_char(message, str, " WHERE ");
3613 CheckWhereCaluse(node->whereClause, message,dblink,str,0);
3614 KeepRewriteQueryReturnCode(message, message_code);
3617 writeSelectFooter(message,str,analyze,SELECT_FROMCLAUSE);
3618 message->rewritelock = -1;
3621 else if(analyze->partstate[SELECT_FROMCLAUSE] == 'P')
3623 if(analyze->partstate[SELECT_WHERECLAUSE] != 'P')
3625 if(node->whereClause)
3627 int message_code = message->r_code;
3628 delay_string_append_char(message, str, " WHERE ");
3629 CheckWhereCaluse(node->whereClause, message,dblink,str,0);
3630 KeepRewriteQueryReturnCode(message, message_code);
3632 writeSelectFooter(message,str,analyze,SELECT_FROMCLAUSE);
3633 message->rewritelock = -1;
3637 message->analyze_num = target_analyze;
3642 message->part = SELECT_OTHER;
3643 if (node->whereClause)
3646 if (node->whereClause)
3648 message->part = SELECT_WHERECLAUSE;
3649 analyze->part = SELECT_WHERECLAUSE;
3650 delay_string_append_char(message, str, " WHERE ");
3651 _rewriteNode(BaseSelect, message, dblink, str, node->whereClause);
3652 KeepMessages(message,count,SELECT_OTHER);
3655 if(!analyze->partstate[SELECT_WHERECLAUSE] && message->r_code == SELECT_ANALYZE)
3656 analyze->partstate[SELECT_WHERECLAUSE] = analyze->partstate[SELECT_FROMCLAUSE];
3659 writeSelectAggFooter(message,str,analyze);
3661 ChangeStateRewriteFooter(message,str,SELECT_WHERECLAUSE, SELECT_GROUPBYCLAUSE);
3663 /* GROUPBY CLAUSE */
3664 if (node->groupClause)
3666 analyze->part = SELECT_GROUPBYCLAUSE;
3667 delay_string_append_char(message, str, " GROUP BY ");
3668 _rewriteNode(BaseSelect, message, dblink, str, node->groupClause);
3669 KeepMessages(message,count,SELECT_OTHER);
3672 ChangeStateByCluase(message,node->groupClause,SELECT_WHERECLAUSE,SELECT_GROUPBYCLAUSE);
3675 if (node->havingClause)
3677 analyze->part = SELECT_HAVINGCLAUSE;
3678 delay_string_append_char(message, str, " HAVING ");
3679 _rewriteNode(BaseSelect, message, dblink, str, node->havingClause);
3680 KeepMessages(message,count,SELECT_OTHER);
3684 if(message->r_code == SELECT_ANALYZE)
3685 analyze->partstate[SELECT_HAVINGCLAUSE] = analyze->partstate[SELECT_GROUPBYCLAUSE];
3688 ChangeStateRewriteFooter(message,str,SELECT_HAVINGCLAUSE, SELECT_SORTCLAUSE);
3690 if (node->sortClause)
3692 analyze->part = SELECT_SORTCLAUSE;
3693 delay_string_append_char(message, str, " ORDER BY ");
3694 _rewriteNode(BaseSelect, message, dblink, str, node->sortClause);
3695 KeepMessages(message,count,SELECT_OTHER);
3698 ChangeStateByCluase(message,node->sortClause,SELECT_HAVINGCLAUSE,SELECT_SORTCLAUSE);
3701 ChangeStateRewriteFooter(message,str, SELECT_SORTCLAUSE, SELECT_OFFSETCLAUSE);
3703 if (node->limitOffset)
3705 analyze->part = SELECT_OFFSETCLAUSE;
3706 delay_string_append_char(message, str, " OFFSET ");
3707 _rewriteNode(BaseSelect, message, dblink, str, node->limitOffset);
3708 KeepMessages(message,count,SELECT_OTHER);
3712 ChangeStateByCluase(message,node->limitOffset,SELECT_SORTCLAUSE,SELECT_OFFSETCLAUSE);
3714 ChangeStateRewriteFooter(message,str,SELECT_OFFSETCLAUSE,SELECT_LIMITCLAUSE);
3716 if (node->limitCount)
3718 analyze->part = SELECT_LIMITCLAUSE;
3719 delay_string_append_char(message, str, " LIMIT ");
3720 if (IsA(node->limitCount, A_Const) &&
3721 ((A_Const *)node->limitCount)->val.type == T_Null)
3723 delay_string_append_char(message, str, "ALL ");
3727 _rewriteNode(BaseSelect, message, dblink, str, node->limitCount);
3728 KeepMessages(message,count,SELECT_OTHER);
3732 ChangeStateByCluase(message,node->limitCount,SELECT_OFFSETCLAUSE,SELECT_LIMITCLAUSE);
3734 if(message->r_code == SELECT_ANALYZE)
3737 analyze->state = analyze->partstate[SELECT_LIMITCLAUSE];
3739 for(i = 0; i< 8; i++)
3741 char s = analyze->partstate[i];
3750 _rewriteNode(BaseSelect, message, dblink, str, node->lockingClause);
3751 KeepMessages(message,count,SELECT_OTHER);
3753 if(message->r_code == SELECT_ANALYZE)
3755 if(node->targetList)
3756 AnalyzeReturnRecord(BaseSelect,message,dblink,str,node->targetList);
3758 pool_debug("_rewriteSelectStmt select_no=%d state=%s",message->current_select,analyze->partstate);
3760 if(strstr(analyze->partstate,"E"))
3761 message->is_loadbalance = true;
3766 AnalyzeSelect *last = message->analyze[analyze->last_select];
3767 if(last->part == SELECT_WHERECLAUSE)
3769 char fromstate = last->partstate[SELECT_FROMCLAUSE];
3770 char wherestate = (char) 0;
3772 if(last->partstate[SELECT_WHERECLAUSE])
3773 wherestate = last->partstate[SELECT_WHERECLAUSE];
3775 if(fromstate == 'P' && analyze->state == 'L')
3777 if(wherestate && wherestate == 'P')
3778 last->partstate[SELECT_WHERECLAUSE] = 'P';
3780 else if(fromstate == 'L' && analyze->state == 'L')
3782 last->partstate[SELECT_WHERECLAUSE] = 'L';
3785 last->partstate[SELECT_WHERECLAUSE] = 'S';
3788 if(last->part == SELECT_TARGETLIST)
3790 char fromstate = last->partstate[SELECT_FROMCLAUSE];
3791 char targetstate = (char) 0;
3793 if(last->partstate[SELECT_TARGETLIST])
3794 targetstate = last->partstate[SELECT_TARGETLIST];
3796 if(fromstate == 'P' && analyze->state == 'L')
3798 last->partstate[SELECT_TARGETLIST] = 'P';
3800 else if(fromstate == 'L' && analyze->state == 'L')
3802 last->partstate[SELECT_TARGETLIST] = 'L';
3805 last->partstate[SELECT_TARGETLIST] = 'S';
3810 if(message->r_code == SELECT_DEFAULT && message->rewritelock == count
3811 && message->ignore_rewrite ==-1 )
3814 writeSelectFooter(message,str,analyze,analyze->call_part);
3816 writeSelectFooter(message,str,analyze,SELECT_FROMCLAUSE);
3818 message->rewritelock = -1;
3823 initAggexpr(AnalyzeSelect *analyze)
3827 if(analyze->aggexpr)
3830 analyze->aggexpr = (Aggexpr *) palloc(sizeof(Aggexpr));
3831 agg = analyze->aggexpr;
3833 agg->tfunc_p = NULL;
3835 agg->hfunc_p = NULL;
3848 FuncChangebyAggregate(AnalyzeSelect *analyze, FuncCall *fnode)
3854 if(analyze->aggregate && analyze->aggexpr)
3855 agg = analyze->aggexpr;
3862 if(analyze->part == SELECT_TARGETLIST)
3864 for(i = 0; i < agg->t_num; i++)
3866 if(fnode == agg->tfunc_p[i])
3872 else if(analyze->part == SELECT_HAVINGCLAUSE)
3874 for(i = 0; i < agg->h_num; i++)
3876 if(fnode == agg->hfunc_p[i])
3882 else if(analyze->part == SELECT_SORTCLAUSE)
3885 sortfunc = init_string("");
3886 _outNode(sortfunc, fnode);
3888 for(i = 0; i < agg->t_num; i++)
3891 having = init_string("");
3892 _outNode(having, agg->tfunc_p[i]);
3893 if(!strcmp(sortfunc->data,having->data))
3895 free_string(having);
3896 free_string(sortfunc);
3900 free_string(having);
3904 free_string(sortfunc);
3910 ColumnChangebyAggregate(AnalyzeSelect *analyze,ColumnRef *cnode)
3916 if(analyze->aggregate && analyze->aggexpr)
3917 agg = analyze->aggexpr;
3924 if(analyze->part == SELECT_GROUPBYCLAUSE)
3926 for(i = 0; i < agg->c_num; i++)
3928 if(cnode == agg->col_p[i])
3930 return agg->t_num + i;
3934 else if(analyze->part == SELECT_TARGETLIST)
3936 for(i = 0; i < agg->u_num; i++)
3942 n_c = GetNameFromColumnRef(cnode,true);
3943 n_t = GetNameFromColumnRef(cnode,false);
3944 c_c = GetNameFromColumnRef(agg->usec_p[i],true);
3945 c_t = GetNameFromColumnRef(agg->usec_p[i],false);
3949 if(!strcmp(n_t,c_t) && !strcmp(n_c,c_c))
3950 return agg->t_num + agg->umapc[i];
3954 if(!strcmp(n_c,c_c))
3955 return agg->t_num + agg->umapc[i];
3959 else if(analyze->part == SELECT_HAVINGCLAUSE || analyze->part == SELECT_SORTCLAUSE)
3961 for(i = 0; i < agg->c_num; i++)
3967 n_c = GetNameFromColumnRef(cnode,true);
3968 n_t = GetNameFromColumnRef(cnode,false);
3969 c_c = GetNameFromColumnRef(agg->col_p[i],true);
3970 c_t = GetNameFromColumnRef(agg->col_p[i],false);
3974 if(!strcmp(n_t,c_t) && !strcmp(n_c,c_c))
3975 return agg->t_num + i;
3979 if(!strcmp(n_c,c_c))
3980 return agg->t_num + i;
3988 AppendAggregate(AnalyzeSelect *analyze,FuncCall *fnode,ColumnRef *cnode)
3992 initAggexpr(analyze);
3994 agg = analyze->aggexpr;
3997 if(analyze->part == SELECT_GROUPBYCLAUSE)
4001 agg->col_p = (ColumnRef **) palloc(sizeof(ColumnRef *));
4005 agg->col_p = (ColumnRef **) repalloc(agg->col_p,(agg->c_num + 1) *sizeof(ColumnRef *));
4007 agg->col_p[agg->c_num] = cnode;
4008 SeekColumnName(agg,cnode,SELECT_GROUPBYCLAUSE);
4011 else if(analyze->part == SELECT_TARGETLIST)
4013 if(fnode) /* for function */
4017 agg->tfunc_p = (FuncCall **) palloc(sizeof(FuncCall *));
4021 agg->tfunc_p = (FuncCall **) repalloc(agg->tfunc_p,(agg->t_num + 1) *sizeof(FuncCall *));
4023 agg->tfunc_p[agg->t_num] = fnode;
4025 } else { /* for Column */
4028 agg->usec_p = (ColumnRef **) palloc(sizeof(ColumnRef *));
4029 agg->umapc = (int *) palloc(sizeof(int));
4033 agg->usec_p = (ColumnRef **) repalloc(agg->usec_p,(agg->u_num + 1) *sizeof(ColumnRef *));
4034 agg->umapc = (int *) repalloc(agg->umapc,(agg->u_num + 1) *sizeof(int));
4036 agg->usec_p[agg->u_num] = cnode;
4040 else if(analyze->part == SELECT_HAVINGCLAUSE)
4042 if(fnode) /* for function */
4046 agg->hfunc_p = (FuncCall **) palloc(sizeof(FuncCall *));
4050 agg->hfunc_p = (FuncCall **) repalloc(agg->hfunc_p,(agg->h_num + 1) *sizeof(FuncCall *));
4052 agg->hfunc_p[agg->h_num] = fnode;
4059 _rewriteFuncCall(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FuncCall *node)
4062 bool avg_flag = false;
4063 if(message->r_code == SELECT_AEXPR)
4065 KeepRewriteQueryReturnCode(message, SELECT_AEXPR_FALSE);
4069 funcname = strVal(lfirst(list_head(node->funcname)));
4071 if (CheckAggOpt(message))
4074 AnalyzeSelect *analyze;
4075 int no = message->current_select;
4076 analyze = message->analyze[no];
4078 i = FuncChangebyAggregate(analyze,node);
4081 if(!strcmp(funcname,"count"))
4082 delay_string_append_char(message, str, "sum");
4083 else if(!strcmp(funcname,"avg"))
4085 delay_string_append_char(message, str, "(sum");
4089 _rewriteFuncName(BaseSelect, message, dblink, str, node->funcname);
4092 _rewriteFuncName(BaseSelect, message, dblink, str, node->funcname);
4096 _rewriteFuncName(BaseSelect, message, dblink, str, node->funcname);
4098 if(message->r_code == SELECT_ANALYZE && funcname)
4100 /* aggregate functions */
4101 if(!strcmp(funcname,"count") || !strcmp(funcname,"max") || !strcmp(funcname,"min")
4102 || !strcmp(funcname,"sum") || !strcmp(funcname,"avg") || !strcmp(funcname,"bit_and")
4103 || !strcmp(funcname,"bit_or") || !strcmp(funcname,"bool_and") || !strcmp(funcname,"bool_or")
4104 || !strcmp(funcname,"every") || !strcmp(funcname,"corr") || !strcmp(funcname,"covar_pop")
4105 || !strcmp(funcname,"covar_samp") || !strcmp(funcname,"regr_avgx") || !strcmp(funcname,"regr_avgy")
4106 || !strcmp(funcname,"regr_count") || !strcmp(funcname,"regr_intercept") || !strcmp(funcname,"regr_r2")
4107 || !strcmp(funcname,"regr_slope") || !strcmp(funcname,"regr_sxx") || !strcmp(funcname,"regr_sxy")
4108 || !strcmp(funcname,"regr_syy") || !strcmp(funcname,"stddev") || !strcmp(funcname,"stddev_pop")
4109 || !strcmp(funcname,"stddev_samp") || !strcmp(funcname,"variance") || !strcmp(funcname,"var_pop")
4110 || !strcmp(funcname,"var_samp"))
4112 AnalyzeSelect *analyze;
4113 int no = message->current_select;
4114 analyze = message->analyze[no];
4115 analyze->aggregate = true;
4117 if(analyze->part == SELECT_TARGETLIST || analyze->part == SELECT_HAVINGCLAUSE)
4119 if(!strcmp(funcname,"count") || !strcmp(funcname,"max") ||
4120 !strcmp(funcname,"min") || !strcmp(funcname,"sum") || !strcmp(funcname,"avg"))
4122 AppendAggregate(analyze,node,NULL);
4126 initAggexpr(analyze);
4127 analyze->aggexpr->opt = false;
4133 if(strcmp(funcname,"user") == 0 ||
4134 strcmp(funcname,"current_user") == 0 ||
4135 strcmp(funcname,"session_user") == 0 ||
4136 strcmp(funcname,"current_role") == 0)
4139 delay_string_append_char(message, str, "(");
4141 if (node->agg_distinct == TRUE)
4142 delay_string_append_char(message, str, "DISTINCT ");
4144 if (CheckAggOpt(message))
4147 AnalyzeSelect *analyze;
4148 int no = message->current_select;
4149 analyze = message->analyze[no];
4150 i = FuncChangebyAggregate(analyze,node);
4154 snprintf(buf, 16, "%d", i);
4155 delay_string_append_char(message, str, "pool_g$");
4156 delay_string_append_char(message, str, buf);
4157 pool_debug("_FuncCall: aggregate no = %d",i);
4158 delay_string_append_char(message, str, ")");
4162 delay_string_append_char(message, str, "/");
4163 delay_string_append_char(message, str, "sum(");
4164 delay_string_append_char(message, str, "pool_g$");
4165 delay_string_append_char(message, str, buf);
4166 delay_string_append_char(message, str, "c");
4167 delay_string_append_char(message, str, "))");
4173 if (node->agg_star == TRUE)
4174 delay_string_append_char(message, str, "*");
4176 _rewriteNode(BaseSelect, message, dblink, str, node->args);
4178 delay_string_append_char(message, str, ")");
4182 AvgFuncCall(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FuncCall *node)
4185 if(message->r_code == SELECT_AEXPR)
4187 KeepRewriteQueryReturnCode(message, SELECT_AEXPR_FALSE);
4191 funcname = strVal(lfirst(list_head(node->funcname)));
4193 delay_string_append_char(message, str, "sum");
4195 delay_string_append_char(message, str, "(");
4197 if (node->agg_distinct == TRUE)
4198 delay_string_append_char(message, str, "DISTINCT ");
4200 _rewriteNode(BaseSelect, message, dblink, str, node->args);
4202 delay_string_append_char(message, str, ")");
4203 delay_string_append_char(message, str, ",");
4204 delay_string_append_char(message, str, "count");
4206 delay_string_append_char(message, str, "(");
4208 if (node->agg_distinct == TRUE)
4209 delay_string_append_char(message, str, "DISTINCT ");
4211 _rewriteNode(BaseSelect, message, dblink, str, node->args);
4213 delay_string_append_char(message, str, ")");
4217 _rewriteDefElem(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DefElem *node)
4223 _rewriteLockingClause(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, LockingClause *node)
4228 if (node->forUpdate == TRUE)
4229 delay_string_append_char(message, str, " FOR UPDATE");
4231 delay_string_append_char(message, str, " FOR SHARED");
4233 _rewriteNode(BaseSelect, message, dblink, str, node->lockedRels);
4235 if (node->noWait == TRUE)
4236 delay_string_append_char(message, str, " NOWAIT ");
4240 _rewriteColumnDef(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ColumnDef *node)
4242 delay_string_append_char(message, str, "\"");
4243 delay_string_append_char(message, str, node->colname);
4244 delay_string_append_char(message, str, "\" ");
4245 _rewriteNode(BaseSelect, message, dblink, str, node->typename);
4246 _rewriteNode(BaseSelect, message, dblink, str, node->constraints);
4250 _rewriteTypeName(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, TypeName *node)
4255 foreach (lc, node->names)
4257 Value *v = (Value *) lfirst(lc);
4258 char *typename = v->val.str;
4263 delay_string_append_char(message, str, ".");
4264 if(node->typemod < 0)
4266 if(message->rewritelock != -1)
4268 delay_string_append_char(message, str, "\"\"");
4269 delay_string_append_char(message, str, typename);
4270 delay_string_append_char(message, str, "\"\"");
4272 //delay_string_append_char(message, str, "\"");
4273 delay_string_append_char(message, str, typename);
4274 //delay_string_append_char(message, str, "\"");
4277 delay_string_append_char(message, str, typename);
4280 if (node->typemod > 0)
4284 delay_string_append_char(message, str, "(");
4285 snprintf(buf, 16, "%d", ((node->typemod - VARHDRSZ) >> 16) & 0x00FF);
4286 delay_string_append_char(message, str, buf);
4287 lower = (node->typemod-VARHDRSZ) & 0x00FF;
4292 delay_string_append_char(message, str, ",");
4293 snprintf(buf2, 16, "%d",lower);
4294 delay_string_append_char(message, str, buf2);
4297 delay_string_append_char(message, str, ")");
4302 _rewriteTypeCast(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, TypeCast *node)
4304 _rewriteNode(BaseSelect, message, dblink, str, node->arg);
4305 delay_string_append_char(message, str, "::");
4306 _rewriteNode(BaseSelect, message, dblink, str, node->typename);
4311 _rewriteIndexElem(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, IndexElem *node)
4315 delay_string_append_char(message, str, "\"");
4316 delay_string_append_char(message, str, node->name);
4317 delay_string_append_char(message, str, "\"");
4318 if (node->opclass != NIL)
4319 _rewriteNode(BaseSelect, message, dblink, str, node->opclass);
4323 delay_string_append_char(message, str, "(");
4324 _rewriteNode(BaseSelect, message, dblink, str, node->expr);
4325 delay_string_append_char(message, str, ")");
4326 if (node->opclass != NIL)
4327 _rewriteNode(BaseSelect, message, dblink, str, node->opclass);
4333 _rewriteSortClause(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, SortClause *node)
4339 _rewriteGroupClause(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, GroupClause *node)
4345 _rewriteSetOperationStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, SetOperationStmt *node)
4352 _rewriteAExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, A_Expr *node)
4359 if (list_length(node->name) == 1)
4361 Value *op = (Value *) lfirst(list_head(node->name));
4363 delay_string_append_char(message, str, " (");
4364 _rewriteNode(BaseSelect, message, dblink, str, node->lexpr);
4365 delay_string_append_char(message, str, op->val.str);
4366 _rewriteNode(BaseSelect, message, dblink, str, node->rexpr);
4367 delay_string_append_char(message, str, " )");
4372 delay_string_append_char(message, str, " (");
4373 _rewriteNode(BaseSelect, message, dblink, str, node->lexpr);
4374 delay_string_append_char(message, str, " AND ");
4375 _rewriteNode(BaseSelect, message, dblink, str, node->rexpr);
4376 delay_string_append_char(message, str, ")");
4380 delay_string_append_char(message, str, " (");
4381 _rewriteNode(BaseSelect, message, dblink, str, node->lexpr);
4382 delay_string_append_char(message, str, " OR ");
4383 _rewriteNode(BaseSelect, message, dblink, str, node->rexpr);
4384 delay_string_append_char(message, str, ")");
4388 delay_string_append_char(message, str, " (NOT ");
4389 _rewriteNode(BaseSelect, message, dblink, str, node->rexpr);
4390 delay_string_append_char(message, str, ")");
4394 _rewriteNode(BaseSelect,message,dblink,str, node->lexpr);
4395 v = linitial(node->name);
4396 delay_string_append_char(message,str, v->val.str);
4397 delay_string_append_char(message,str, "ANY(");
4398 _rewriteNode(BaseSelect,message,dblink,str, node->rexpr);
4399 delay_string_append_char(message,str, ")");
4403 _rewriteNode(BaseSelect,message,dblink,str, node->lexpr);
4404 v = linitial(node->name);
4405 delay_string_append_char(message,str, v->val.str);
4406 delay_string_append_char(message,str, "ALL(");
4407 _rewriteNode(BaseSelect,message,dblink,str, node->rexpr);
4408 delay_string_append_char(message,str, ")");
4411 case AEXPR_DISTINCT:
4412 delay_string_append_char(message, str, " (");
4413 _rewriteNode(BaseSelect, message, dblink, str, node->lexpr);
4414 delay_string_append_char(message, str, " IS DISTINCT FROM ");
4415 _rewriteNode(BaseSelect, message, dblink, str, node->rexpr);
4416 delay_string_append_char(message, str, ")");
4420 delay_string_append_char(message, str, " NULLIF(");
4421 _rewriteNode(BaseSelect, message, dblink, str, node->lexpr);
4422 delay_string_append_char(message, str, ", ");
4423 _rewriteNode(BaseSelect, message, dblink, str, node->rexpr);
4424 delay_string_append_char(message, str, ")");
4428 _rewriteNode(BaseSelect, message, dblink, str, node->lexpr);
4429 v = linitial(node->name);
4430 if (v->val.str[0] == '!')
4431 delay_string_append_char(message, str, " IS NOT OF (");
4433 delay_string_append_char(message, str, " IS OF (");
4434 _rewriteNode(BaseSelect, message, dblink, str, node->rexpr);
4435 delay_string_append_char(message, str, ")");
4438 _rewriteNode(BaseSelect,message,dblink,str, node->lexpr);
4439 v = (Value *)lfirst(list_head(node->name));
4440 if (v->val.str[0] == '=')
4441 delay_string_append_char(message,str, " IN (");
4443 delay_string_append_char(message,str, " NOT IN (");
4444 _rewriteNode(BaseSelect,message,dblink,str, node->rexpr);
4445 delay_string_append_char(message,str, ")");
4453 _rewriteValue(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, Value *value)
4457 switch (value->type)
4460 sprintf(buf, "%ld", value->val.ival);
4461 delay_string_append_char(message, str, buf);
4465 delay_string_append_char(message, str, value->val.str);
4469 /* delay_string_append_char(message, str, "'"); */
4470 delay_string_append_char(message, str, escape_string(value->val.str));
4471 /* delay_string_append_char(message, str, "'"); */
4475 delay_string_append_char(message, str, "NULL");
4484 GetInnerRef(RewriteQuery *message,int last,char *table_name,char *column,char state)
4486 AnalyzeSelect *analyze;
4487 VirtualTable *virtual;
4491 analyze = message->analyze[last];
4492 virtual = analyze->virtual;
4493 num = virtual->col_num;
4495 for(i=0; i < num; i++)
4497 char *vcol = virtual->col_list[i];
4498 char *vtable = virtual->table_list[i];
4500 && !strcmp(table_name,vtable) && !strcmp(column,vcol))
4502 pool_debug("GetInnerRef state = %c now select(%d), table_name=(%s), col_name=(%s) detect",state,last,vtable,vcol);
4506 else if(!table_name && !strcmp(column,vcol))
4508 pool_debug("GetInnerRef state = %c now select(%d), table_name=(%s), col_name=(%s) detect",state,last,vtable,vcol);
4518 /* there isn't the inner refarence at parallel part */
4519 if(state == 'P' || analyze->partstate[SELECT_FROMCLAUSE] =='P')
4525 return GetInnerRef(message,analyze->last_select,table_name,column,state);
4530 ChangeStatebyColumnRef(RewriteQuery *message,ColumnRef *col)
4532 AnalyzeSelect *analyze;
4533 VirtualTable *virtual;
4537 char *table_name = NULL;
4538 char *column = NULL;
4543 no = message->current_select;
4544 analyze = message->analyze[no];
4546 if(list->length > 2 || list->length == 0)
4548 /* Is this error ? */
4549 message->analyze[no]->state = 'S';
4553 foreach (c, col->fields)
4555 Node *n = (Node *) lfirst(c);
4559 Value *v = (Value *) lfirst(c);
4560 if(list->length == 2 && first == 0)
4563 table_name = v->val.str;
4566 column = v->val.str;
4572 message->table_state = 'S';
4576 pool_debug("ChangeStatebyColumnRef %s now(%d),last(%d) part(%d) call_part(%d)",
4578 analyze->now_select,
4579 analyze->last_select,
4584 virtual = analyze->virtual;
4585 num = virtual->col_num;
4587 if(message->part==SELECT_WHERECLAUSE || message->part == SELECT_TARGETLIST)
4589 if(analyze->partstate[message->part] != 'S')
4591 analyze->partstate[message->part] =
4592 GetInnerRef(message,no,table_name,column,analyze->partstate[SELECT_FROMCLAUSE]);
4593 pool_debug("return state is %c",analyze->partstate[message->part]);
4598 static bool DetectValidColumn(RewriteQuery *message,char *table_name,char *column_name,int no, int call)
4600 AnalyzeSelect *analyze;
4601 VirtualTable *virtual;
4607 call_num = message->current_select;
4609 if(call != -1 && no != call_num && call == SELECT_FROMCLAUSE)
4611 int last = message->analyze[no]->last_select;
4612 int call_part = message->analyze[no]->call_part;
4620 return DetectValidColumn(message,table_name,column_name,last,call_part);
4624 analyze = message->analyze[no];
4625 virtual = analyze->virtual;
4626 v_num = virtual->col_num;
4628 for(i = 0; i< v_num; i++)
4630 char *vcol = virtual->col_list[i];
4631 char *vtable = virtual->table_list[i];
4633 if(table_name && !strcmp(table_name,vtable) && !strcmp(column_name,"*"))
4635 virtual->valid[i] = message->current_select;
4638 else if (!table_name && !strcmp(column_name,"*"))
4640 virtual->valid[i] = message->current_select;
4645 && !strcmp(table_name,vtable) && !strcmp(column_name,vcol))
4647 pool_debug("DetectValidColumn no = %d, table_name=(%s), col_name=(%s) detect",no, vtable, vcol);
4650 if(virtual->valid[i] == -1)
4652 virtual->valid[i] = message->current_select;
4654 else if (virtual->valid[i] > no)
4656 virtual->valid[i] = message->current_select;
4659 else if(!table_name && !strcmp(column_name,vcol))
4661 pool_debug("DetectValidColumn no = %d, col_name=(%s) detect",no, vcol);
4664 if(virtual->valid[i] == -1)
4666 virtual->valid[i] = message->current_select;
4668 else if (virtual->valid[i] > no)
4670 virtual->valid[i] = message->current_select;
4684 int last = analyze->last_select;
4687 return DetectValidColumn(message,table_name,column_name,analyze->last_select,analyze->call_part);
4691 pool_debug("DetectValidColumn select_no=(%d) col_name=(%s) ambiguous",message->current_select,column_name);
4696 static bool GetPoolColumn(RewriteQuery *message,String *str,char *table_name,char *column_name,int no, int call,bool state)
4698 AnalyzeSelect *analyze,*analyze_now;
4699 VirtualTable *virtual;
4705 call_num = message->current_select;
4707 if(call != -1 && no != call_num && call == SELECT_FROMCLAUSE)
4709 int last = message->analyze[no]->last_select;
4710 int call_part = message->analyze[no]->call_part;
4718 return GetPoolColumn(message,str,table_name,column_name,last,call_part,state);
4722 analyze = message->analyze[no];
4723 analyze_now = message->analyze[call_num];
4724 virtual = analyze->virtual;
4725 v_num = virtual->col_num;
4727 for(i = 0; i< v_num; i++)
4729 char *vcol = virtual->col_list[i];
4730 char *vtable = virtual->table_list[i];
4732 if(table_name && !strcmp(table_name,vtable) && !strcmp(column_name,"*"))
4737 else if (!table_name && !strcmp(column_name,"*"))
4744 && !strcmp(table_name,vtable) && !strcmp(column_name,vcol))
4746 pool_debug("GetPoolColumn no = %d, table_name=(%s), col_name=(%s) new_colname$%d detect",no, vtable, vcol,i);
4750 else if(!table_name && !strcmp(column_name,vcol))
4752 pool_debug("GetPoolColumn no = %d, col_name=(%s) new_colname=pool_c$%d detect",no, vcol,i);
4763 for(i = 0; i < v_num; i++)
4766 if(!strcmp(virtual->table_list[i],table_name) && virtual->valid[i] != -1)
4771 delay_string_append_char(message, str, ",");
4773 if(message->rewritelock == -1)
4775 snprintf(buf, 16, "%d", analyze->virtual->column_no[i]);
4776 delay_string_append_char(message, str,"\"pool_c$");
4777 delay_string_append_char(message, str,buf);
4778 delay_string_append_char(message, str, "\"");
4780 if(message->ignore_rewrite == -1 && call_num != 0 && analyze->call_part == SELECT_FROMCLAUSE)
4783 int col_no = analyze->select_ret->return_list[analyze->ret_count];
4784 delay_string_append_char(message, str, " AS ");
4785 snprintf(buf2, 16, "%d", col_no);
4786 delay_string_append_char(message, str,"\"pool_c$");
4787 delay_string_append_char(message, str,buf2);
4788 delay_string_append_char(message, str, "\"");
4789 delay_string_append_char(message, str," ");
4790 pool_debug("GetPoolColumn analyze[%d] targetlist=* => pool_c$%s AS pool_c$%s",
4792 analyze->ret_count++;
4796 delay_string_append_char(message, str,analyze->virtual->col_list[i]);
4799 delay_string_append_char(message, str, " ");
4801 if(state && message->rewritelock == -1)
4803 delay_string_append_char(message, str, " AS ");
4804 delay_string_append_char(message, str, "\"");
4805 delay_string_append_char(message, str, analyze->select_ret->col_list[message->ret_num]);
4806 delay_string_append_char(message, str, "\" ");
4815 for(i = 0; i < v_num; i++)
4818 if(virtual->valid[i] != -1)
4823 delay_string_append_char(message, str, ",");
4825 if(message->rewritelock == -1)
4827 snprintf(buf, 16, "%d", analyze->virtual->column_no[i]);
4828 delay_string_append_char(message, str,"\"pool_c$");
4829 delay_string_append_char(message, str,buf);
4830 delay_string_append_char(message, str,"\"");
4832 if(message->ignore_rewrite == -1 && call_num != 0 && analyze->call_part == SELECT_FROMCLAUSE)
4835 int col_no = analyze->select_ret->return_list[analyze->ret_count];
4836 delay_string_append_char(message, str, " AS ");
4837 snprintf(buf2, 16, "%d", col_no);
4838 delay_string_append_char(message, str,"\"pool_c$");
4839 delay_string_append_char(message, str,buf2);
4840 delay_string_append_char(message, str,"\"");
4841 delay_string_append_char(message, str," ");
4842 analyze->ret_count++;
4843 pool_debug("GetPoolColumn analyze[%d] targetlist=%s => pool_c$%s AS pool_c$%s",
4844 no,column_name,buf,buf2);
4849 delay_string_append_char(message, str,analyze->virtual->col_list[i]);
4851 delay_string_append_char(message, str, " ");
4853 if(state && message->rewritelock == -1)
4855 delay_string_append_char(message, str, " AS ");
4856 delay_string_append_char(message, str, analyze->select_ret->col_list[message->ret_num]);
4868 snprintf(buf, 16, "%d", virtual->column_no[i]);
4871 if(analyze_now->partstate[SELECT_FROMCLAUSE] != 'S') {
4872 delay_string_append_char(message, str, analyze->table_name);
4873 delay_string_append_char(message, str, ".");
4875 delay_string_append_char(message, str, virtual->table_list[i]);
4876 delay_string_append_char(message, str, ".");
4879 delay_string_append_char(message, str, "\"pool_c$");
4880 delay_string_append_char(message, str, buf);
4881 delay_string_append_char(message, str, "\"");
4887 int last = analyze->last_select;
4890 return GetPoolColumn(message,str,table_name,column_name,analyze->last_select,analyze->call_part,state);
4899 static void SeekColumnName(Aggexpr *agg,ColumnRef *node, int state)
4901 char *column = NULL;
4905 /* get column & table name from group by */
4906 column = GetNameFromColumnRef(node,true);
4907 table = GetNameFromColumnRef(node,false);
4909 if(state == SELECT_GROUPBYCLAUSE)
4911 for(i = 0; i < agg->u_num; i++)
4913 ColumnRef *unode = agg->usec_p[i];
4914 char *t_column = NULL;
4915 char *t_table = NULL;
4916 t_column = GetNameFromColumnRef(unode,true);
4917 t_table = GetNameFromColumnRef(unode,false);
4919 if(table && t_table)
4921 if(!strcmp(table,t_table) && !strcmp(column,t_column))
4923 agg->umapc[i] = agg->c_num;
4929 if(!strcmp(column,t_column))
4931 agg->umapc[i] = agg->c_num;
4939 static bool CheckAggOpt(RewriteQuery *message)
4941 AnalyzeSelect *analyze;
4942 if(message->r_code != SELECT_DEFAULT)
4945 analyze = message->analyze[message->current_select];
4947 if(analyze->aggregate && analyze->aggexpr && analyze->aggexpr->opt
4948 && (analyze->part == SELECT_TARGETLIST || analyze->part == SELECT_GROUPBYCLAUSE
4949 || analyze->part == SELECT_HAVINGCLAUSE || analyze->part == SELECT_SORTCLAUSE)
4950 && analyze->partstate[SELECT_FROMCLAUSE] == 'P'
4951 && analyze->partstate[SELECT_TARGETLIST] == 'S'
4952 && analyze->partstate[SELECT_WHERECLAUSE] == 'P')
4958 static char *GetNameFromColumnRef(ColumnRef *node,bool state)
4962 list = node->fields;
4964 char *table_name = NULL;
4965 char *column_name = NULL;
4967 foreach (c, node->fields)
4969 Node *n = (Node *) lfirst(c);
4973 Value *v = (Value *) lfirst(c);
4974 if(list->length == 2 && first == 0)
4977 table_name = v->val.str;
4980 column_name = v->val.str;
4991 _rewriteColumnRef(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ColumnRef *node)
4996 char *table_name = NULL;
4997 char *column_name = NULL;
4999 if(CheckAggOpt(message))
5002 AnalyzeSelect *analyze = message->analyze[message->current_select];
5004 i = ColumnChangebyAggregate(analyze,node);
5008 snprintf(buf, 16, "%d", i);
5009 delay_string_append_char(message, str, "pool_g$");
5010 delay_string_append_char(message, str, buf);
5011 pool_debug("_rewriteColumnRef: aggregate no = %d",i);
5016 list = node->fields;
5018 foreach (c, node->fields)
5020 Node *n = (Node *) lfirst(c);
5025 if(message->r_code == SELECT_AEXPR &&
5026 (_checkVirtualColumn(node, message) != 1))
5028 KeepRewriteQueryReturnCode(message, SELECT_AEXPR_FALSE);
5032 Value *v = (Value *) lfirst(c);
5033 if(list->length == 2 && first == 0)
5036 table_name = v->val.str;
5039 column_name = v->val.str;
5043 if(message->r_code == SELECT_ANALYZE)
5045 AnalyzeSelect *analyze = message->analyze[message->current_select];
5047 if(analyze->part == SELECT_GROUPBYCLAUSE || analyze->part == SELECT_TARGETLIST)
5048 AppendAggregate(analyze,NULL,node);
5050 if(!DetectValidColumn(message,table_name,column_name,message->current_select,-1))
5052 message->is_loadbalance = true;
5053 pool_debug("_rewriteColumnRef: wrong column select_no=%d",message->current_select);
5055 if(strcmp(column_name,"*"))
5056 ChangeStatebyColumnRef(message,node);
5058 else if(message->r_code == SELECT_DEFAULT)
5061 if(message->rewritelock == -1)
5063 if(!GetPoolColumn(message,str,table_name,column_name,message->current_select,-1,false))
5064 delay_string_append_char(message, str, column_name);
5070 if(message->rewritelock == -1)
5072 AnalyzeSelect *analyze = message->analyze[message->current_select];
5073 char s = analyze->partstate[SELECT_FROMCLAUSE];
5075 if(s == 'L' || s =='P')
5077 delay_string_append_char(message, str, analyze->table_name);
5081 delay_string_append_char(message, str, table_name);
5082 delay_string_append_char(message, str, ".");
5084 delay_string_append_char(message, str, column_name);
5090 _rewriteParamRef(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ParamRef *node)
5094 snprintf(buf, 16, "%d", node->number);
5095 delay_string_append_char(message, str, "$");
5096 delay_string_append_char(message, str, buf);
5100 _rewriteAConst(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, A_Const *node)
5107 Value *v = linitial(node->typename->names);
5109 _rewriteNode(BaseSelect, message, dblink, str, node->typename);
5110 delay_string_append_char(message, str, " ");
5113 switch (node->val.type)
5116 sprintf(buf, "%ld", node->val.val.ival);
5117 delay_string_append_char(message, str, buf);
5121 delay_string_append_char(message, str, node->val.val.str);
5125 if(message->rewritelock != -1)
5127 delay_string_append_char(message, str, "\'\'");
5128 delay_string_append_char(message, str, escape_string(node->val.val.str));
5129 delay_string_append_char(message, str, "\'\'");
5131 delay_string_append_char(message, str, "\'");
5132 delay_string_append_char(message, str, escape_string(node->val.val.str));
5133 delay_string_append_char(message, str, "\'");
5138 delay_string_append_char(message, str, "NULL");
5145 if (name && (strcmp(name, "interval") == 0) &&
5146 node->typename->typmods)
5148 A_Const *v = linitial(node->typename->typmods);
5149 int mask = v->val.val.ival;
5151 if (mask == INTERVAL_MASK(YEAR))
5152 delay_string_append_char(message, str, " YEAR");
5153 else if (mask == INTERVAL_MASK(MONTH))
5154 delay_string_append_char(message, str, " MONTH");
5155 else if (mask == INTERVAL_MASK(DAY))
5156 delay_string_append_char(message, str, " DAY");
5157 else if (mask == INTERVAL_MASK(HOUR))
5158 delay_string_append_char(message, str, " HOUR");
5159 else if (mask == INTERVAL_MASK(MINUTE))
5160 delay_string_append_char(message, str, " MINUTE");
5161 else if (mask == INTERVAL_MASK(SECOND))
5162 delay_string_append_char(message, str, " SECOND");
5163 else if (mask == (INTERVAL_MASK(YEAR) | INTERVAL_MASK(MONTH)))
5164 delay_string_append_char(message, str, " YEAR TO MONTH");
5165 else if (mask == (INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR)))
5166 delay_string_append_char(message, str, " DAY TO HOUR");
5167 else if (mask == (INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) |
5168 INTERVAL_MASK(MINUTE)))
5169 delay_string_append_char(message, str, " DAY TO MINUTE");
5170 else if (mask == (INTERVAL_MASK(DAY) | INTERVAL_MASK(HOUR) |
5171 INTERVAL_MASK(MINUTE) | INTERVAL_MASK(SECOND)))
5172 delay_string_append_char(message, str, " DAY TO SECOND");
5173 else if (mask == (INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE)))
5174 delay_string_append_char(message, str, " HOUR TO MINUTE");
5175 else if (mask == (INTERVAL_MASK(HOUR) | INTERVAL_MASK(MINUTE) |
5176 INTERVAL_MASK(SECOND)))
5177 delay_string_append_char(message, str, " HOUR TO SECOND");
5182 _rewriteA_Indices(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, A_Indices *node)
5184 delay_string_append_char(message, str, "[");
5187 _rewriteNode(BaseSelect, message, dblink, str, node->lidx);
5188 delay_string_append_char(message, str, ":");
5190 _rewriteNode(BaseSelect, message, dblink, str, node->uidx);
5191 delay_string_append_char(message, str, "]");
5195 _rewriteA_Indirection(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, A_Indirection *node)
5197 _rewriteNode(BaseSelect, message, dblink, str, node->arg);
5198 _rewriteNode(BaseSelect, message, dblink, str, node->indirection);
5203 AliasToResTargetCondition(RewriteQuery *message,String *str)
5205 int select_no = message->current_select;
5206 AnalyzeSelect *n_analyze;
5207 AnalyzeSelect *u_analyze;
5212 if(select_no == 0 || message->r_code != SELECT_DEFAULT
5213 || message->rewritelock != -1 || message->ignore_rewrite != -1)
5216 n_analyze=message->analyze[select_no];
5217 u_analyze=message->analyze[select_no - 1];
5219 if(n_analyze->call_part == SELECT_FROMCLAUSE)
5221 ret = n_analyze->ret_count;
5222 col_no = n_analyze->select_ret->return_list[n_analyze->ret_count];
5223 pool_debug("AliasToResTargetCondition select no =%d,ret_no = %d,col_no =%d,colname=%s", select_no,ret,col_no,n_analyze->select_ret->col_list[ret]);
5224 delay_string_append_char(message, str, " AS ");
5225 snprintf(buf, 16, "%d", col_no);
5226 delay_string_append_char(message, str,"\"pool_c$");
5227 delay_string_append_char(message, str,buf);
5228 delay_string_append_char(message, str,"\"");
5229 delay_string_append_char(message, str," ");
5232 else if(u_analyze->select_union && u_analyze->call_part == SELECT_FROMCLAUSE)
5234 ret = u_analyze->ret_count;
5235 col_no = u_analyze->select_ret->return_list[u_analyze->ret_count];
5236 pool_debug("AliasToResTargetCondition(union) select now=%d up=%d,ret_no = %d,col_no =%d,colname=%s", select_no,select_no-1,ret,col_no,u_analyze->select_ret->col_list[ret]);
5237 delay_string_append_char(message, str, " AS ");
5238 snprintf(buf, 16, "%d", col_no);
5239 delay_string_append_char(message, str,"\"pool_c$");
5240 delay_string_append_char(message, str,buf);
5241 delay_string_append_char(message, str,"\"");
5242 delay_string_append_char(message, str," ");
5243 u_analyze->ret_count++;
5251 _rewriteResTarget(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ResTarget *node)
5253 int select_no = message->current_select;
5254 AnalyzeSelect *analyze = NULL;
5255 SelectDefInfo *select = NULL;
5257 if(message->r_code == SELECT_DEFAULT)
5259 analyze= message->analyze[select_no];
5260 select = analyze->select_ret;
5263 if (node->indirection != NIL)
5265 delay_string_append_char(message, str, "\"");
5266 delay_string_append_char(message, str, node->name);
5267 delay_string_append_char(message, str, "\"=");
5268 _rewriteNode(BaseSelect, message, dblink, str, node->val);
5273 char *table_name = NULL;
5275 if(message->r_code == SELECT_DEFAULT && !node->name)
5277 if (node->val && (IsA(node->val, ColumnRef)))
5283 col = (ColumnRef *) node->val;
5284 foreach (c, col->fields)
5286 Node *n = (Node *) lfirst(c);
5290 Value *v = (Value *) lfirst(c);
5291 if(col->fields->length == 2 && first == 0)
5294 table_name = v->val.str;
5302 if(star && strcmp(star,"*"))
5308 if(select_no == 0 && star)
5310 GetPoolColumn(message,str,table_name,star,message->current_select,-1,true);
5315 _rewriteNode(BaseSelect, message, dblink, str, node->val);
5320 if(AliasToResTargetCondition(message,str))
5325 delay_string_append_char(message, str, " AS ");
5326 delay_string_append_char(message, str, node->name);
5327 if(message->r_code == SELECT_DEFAULT && select_no == 0)
5331 else if(message->r_code == SELECT_DEFAULT && select_no == 0
5334 char *col_name = select->col_list[message->ret_num];
5335 pool_debug("_rewriteResTarget: check(%d) ret_num=%d",message->current_select,message->ret_num);
5336 pool_debug("_rewriteResTarget: col ret_num=%d col_name=%s",message->current_select,col_name);
5337 delay_string_append_char(message, str, " AS ");
5338 delay_string_append_char(message, str, col_name);
5346 _rewriteConstraint(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, Constraint *node)
5350 delay_string_append_char(message, str, "CONSTRAINT \"");
5351 delay_string_append_char(message, str, node->name);
5352 delay_string_append_char(message, str, "\"");
5355 switch (node->contype)
5358 delay_string_append_char(message, str, " CHECK (");
5359 _rewriteNode(BaseSelect, message, dblink, str, node->raw_expr);
5360 delay_string_append_char(message, str, ")");
5364 delay_string_append_char(message, str, " UNIQUE");
5367 delay_string_append_char(message, str, "(");
5368 _rewriteIdList(BaseSelect, message, dblink, str, node->keys);
5369 delay_string_append_char(message, str, ")");
5372 if (node->indexspace)
5374 delay_string_append_char(message, str, " USING INDEX TABLESPACE \"");
5375 delay_string_append_char(message, str, node->indexspace);
5376 delay_string_append_char(message, str, "\"");
5380 case CONSTR_PRIMARY:
5381 delay_string_append_char(message, str, " PRIMARY KEY");
5384 delay_string_append_char(message, str, "(");
5385 _rewriteIdList(BaseSelect, message, dblink, str, node->keys);
5386 delay_string_append_char(message, str, ")");
5388 if (node->indexspace)
5390 delay_string_append_char(message, str, " USING INDEX TABLESPACE \"");
5391 delay_string_append_char(message, str, node->indexspace);
5392 delay_string_append_char(message, str, "\"");
5396 case CONSTR_NOTNULL:
5397 delay_string_append_char(message, str, " NOT NULL");
5401 delay_string_append_char(message, str, " NULL");
5404 case CONSTR_DEFAULT:
5405 delay_string_append_char(message, str, "DEFAULT ");
5406 _rewriteNode(BaseSelect, message, dblink, str, node->raw_expr);
5415 _rewriteFkConstraint(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FkConstraint *node)
5417 if (node->constr_name)
5419 delay_string_append_char(message, str, "CONSTRAINT \"");
5420 delay_string_append_char(message, str, node->constr_name);
5421 delay_string_append_char(message, str, "\"");
5424 if (node->fk_attrs != NIL)
5426 delay_string_append_char(message, str, " FOREIGN KEY (");
5427 _rewriteIdList(BaseSelect, message, dblink, str, node->fk_attrs);
5428 delay_string_append_char(message, str, ")" );
5431 delay_string_append_char(message, str, " REFERENCES ");
5432 _rewriteNode(BaseSelect, message, dblink, str, node->pktable);
5434 if (node->pk_attrs != NIL)
5436 delay_string_append_char(message, str, "(");
5437 _rewriteIdList(BaseSelect, message, dblink, str, node->pk_attrs);
5438 delay_string_append_char(message, str, ")");
5441 switch (node->fk_matchtype)
5443 case FKCONSTR_MATCH_FULL:
5444 delay_string_append_char(message, str, " MATCH FULL");
5447 case FKCONSTR_MATCH_PARTIAL:
5448 delay_string_append_char(message, str, " MATCH PARTIAL");
5455 switch (node->fk_upd_action)
5457 case FKCONSTR_ACTION_RESTRICT:
5458 delay_string_append_char(message, str, " ON UPDATE RESTRICT");
5461 case FKCONSTR_ACTION_CASCADE:
5462 delay_string_append_char(message, str, " ON UPDATE CASCADE");
5465 case FKCONSTR_ACTION_SETNULL:
5466 delay_string_append_char(message, str, " ON UPDATE SET NULL");
5469 case FKCONSTR_ACTION_SETDEFAULT:
5470 delay_string_append_char(message, str, " ON UPDATE SET DEFAULT");
5477 switch (node->fk_del_action)
5479 case FKCONSTR_ACTION_RESTRICT:
5480 delay_string_append_char(message, str, " ON DELETE RESTRICT");
5483 case FKCONSTR_ACTION_CASCADE:
5484 delay_string_append_char(message, str, " ON DELETE CASCADE");
5487 case FKCONSTR_ACTION_SETNULL:
5488 delay_string_append_char(message, str, " ON DELETE SET NULL");
5491 case FKCONSTR_ACTION_SETDEFAULT:
5492 delay_string_append_char(message, str, " ON DELETE SET DEFAULT");
5499 if (node->deferrable)
5500 delay_string_append_char(message, str, " DEFERRABLE");
5502 if (node->initdeferred)
5503 delay_string_append_char(message, str, " INITIALLY DEFERRED");
5508 _rewriteSortBy(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, SortBy *node)
5510 _rewriteNode(BaseSelect, message, dblink, str, node->node);
5512 if (node->sortby_dir == SORTBY_USING)
5514 delay_string_append_char(message, str, " USING ");
5515 _rewriteNode(BaseSelect, message, dblink, str, node->useOp);
5517 else if (node->sortby_dir == SORTBY_DESC)
5518 delay_string_append_char(message, str, " DESC ");
5520 if (node->sortby_nulls == SORTBY_NULLS_FIRST)
5521 delay_string_append_char(message, str, " NULLS FIRST ");
5522 else if (node->sortby_nulls == SORTBY_NULLS_LAST)
5523 delay_string_append_char(message, str, " NULLS LAST ");
5526 static void _rewriteInsertStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, InsertStmt *node)
5528 delay_string_append_char(message, str, "INSERT INTO ");
5529 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
5531 if (node->cols == NIL && node->selectStmt == NULL)
5532 delay_string_append_char(message, str, " DEFAULT VALUES");
5539 delay_string_append_char(message, str, "(");
5541 foreach (lc, node->cols)
5543 ResTarget *node = lfirst(lc);
5547 delay_string_append_char(message, str, ", ");
5549 delay_string_append_char(message, str, "\"");
5550 delay_string_append_char(message, str, node->name);
5551 delay_string_append_char(message, str, "\"");
5553 delay_string_append_char(message, str, ")");
5556 if (node->selectStmt)
5558 _rewriteNode(BaseSelect, message, dblink, str, node->selectStmt);
5561 if (node->returningList)
5563 delay_string_append_char(message, str, " RETURNING ");
5564 _rewriteNode(BaseSelect, message, dblink, str, node->returningList);
5568 static void _rewriteUpdateStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, UpdateStmt *node)
5573 delay_string_append_char(message, str, "UPDATE ");
5575 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
5577 delay_string_append_char(message, str, " SET ");
5578 foreach (lc, node->targetList)
5580 ResTarget *node = lfirst(lc);
5584 delay_string_append_char(message, str, ", ");
5586 delay_string_append_char(message, str, "\"");
5587 delay_string_append_char(message, str, node->name);
5588 delay_string_append_char(message, str, "\" =");
5589 _rewriteNode(BaseSelect, message, dblink, str, node->val);
5592 if (node->fromClause)
5594 delay_string_append_char(message, str, " FROM ");
5595 _rewriteNode(BaseSelect, message, dblink, str, node->fromClause);
5598 if (node->whereClause)
5600 delay_string_append_char(message, str, " WHERE ");
5601 _rewriteNode(BaseSelect, message, dblink, str, node->whereClause);
5604 if (node->returningList)
5606 delay_string_append_char(message, str, " RETURNING ");
5607 _rewriteNode(BaseSelect, message, dblink, str, node->returningList);
5611 static void _rewriteDeleteStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DeleteStmt *node)
5613 delay_string_append_char(message, str, "DELETE FROM ");
5615 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
5617 if (node->usingClause)
5619 delay_string_append_char(message, str, " USING ");
5620 _rewriteNode(BaseSelect, message, dblink, str, node->usingClause);
5623 if (node->whereClause)
5625 delay_string_append_char(message, str, " WHERE ");
5626 _rewriteNode(BaseSelect, message, dblink, str, node->whereClause);
5629 if (node->returningList)
5631 delay_string_append_char(message, str, " RETURNING ");
5632 _rewriteNode(BaseSelect, message, dblink, str, node->returningList);
5636 static void _rewriteTransactionStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, TransactionStmt *node)
5640 case TRANS_STMT_BEGIN:
5641 delay_string_append_char(message, str, "BEGIN ");
5644 case TRANS_STMT_START:
5645 delay_string_append_char(message, str, "START TRANSACTION ");
5648 case TRANS_STMT_COMMIT:
5649 delay_string_append_char(message, str, "COMMIT ");
5652 case TRANS_STMT_ROLLBACK:
5653 delay_string_append_char(message, str, "ABORT ");
5656 case TRANS_STMT_SAVEPOINT:
5657 delay_string_append_char(message, str, "SAVEPOINT ");
5660 case TRANS_STMT_RELEASE:
5661 delay_string_append_char(message, str, "RELEASE ");
5664 case TRANS_STMT_ROLLBACK_TO:
5665 delay_string_append_char(message, str, "ROLLBACK TO ");
5668 case TRANS_STMT_PREPARE:
5669 delay_string_append_char(message, str, "PREPARE TRANSACTION ");
5672 case TRANS_STMT_COMMIT_PREPARED:
5673 delay_string_append_char(message, str, "COMMIT PREPARED ");
5676 case TRANS_STMT_ROLLBACK_PREPARED:
5677 delay_string_append_char(message, str, "ROLLBACK PREPARED ");
5685 _rewriteSetTransactionModeList(BaseSelect, message, dblink, str, node->options);
5688 delay_string_append_char(message, str, node->gid);
5692 static void _rewriteTruncateStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, TruncateStmt *node)
5694 delay_string_append_char(message, str, "TRUNCATE ");
5695 _rewriteNode(BaseSelect, message, dblink, str, node->relations);
5698 static void _rewriteVacuumStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, VacuumStmt *node)
5700 if (node->vacuum == true)
5701 delay_string_append_char(message, str, "VACUUM ");
5703 delay_string_append_char(message, str, "ANALYZE ");
5705 if (node->full == TRUE)
5706 delay_string_append_char(message, str, "FULL ");
5708 if (node->freeze_min_age == 0)
5709 delay_string_append_char(message, str, "FREEZE ");
5711 if (node->verbose == TRUE)
5712 delay_string_append_char(message, str, "VERBOSE ");
5715 delay_string_append_char(message, str, "ANALYZE ");
5717 _rewriteNode(BaseSelect, message, dblink, str, node->va_cols);
5720 static void _rewriteExplainStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ExplainStmt *node)
5722 delay_string_append_char(message, str, "EXPLAIN ");
5724 if (node->analyze == TRUE)
5725 delay_string_append_char(message, str, "ANALYZE ");
5726 if (node->verbose == TRUE)
5727 delay_string_append_char(message, str, "VERBOSE ");
5729 _rewriteNode(BaseSelect, message, dblink, str, node->query);
5732 static void _rewriteClusterStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ClusterStmt *node)
5734 delay_string_append_char(message, str, "CLUSTER ");
5736 if (node->indexname)
5738 delay_string_append_char(message, str, "\"");
5739 delay_string_append_char(message, str, node->indexname);
5740 delay_string_append_char(message, str, "\" ON ");
5743 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
5746 static void _rewriteCheckPointStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CheckPointStmt *node)
5748 delay_string_append_char(message, str, "CHECKPOINT");
5751 static void _rewriteClosePortalStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ClosePortalStmt *node)
5753 delay_string_append_char(message, str, "CLOSE ");
5754 delay_string_append_char(message, str, "\"");
5755 delay_string_append_char(message, str, node->portalname);
5756 delay_string_append_char(message, str, "\"");
5759 static void _rewriteListenStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ListenStmt *node)
5761 delay_string_append_char(message, str, "LISTEN ");
5762 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
5765 static void _rewriteUnlistenStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, UnlistenStmt *node)
5767 delay_string_append_char(message, str, "UNLISTEN ");
5768 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
5771 static void _rewriteLoadStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, LoadStmt *node)
5773 delay_string_append_char(message, str, "LOAD '");
5774 delay_string_append_char(message, str, node->filename);
5775 delay_string_append_char(message, str, "'");
5778 static void _rewriteCopyStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CopyStmt *node)
5782 char *delimiter = NULL;
5787 char *escape = NULL;
5788 Node *force_quote = NULL;
5789 Node *force_notnull = NULL;
5792 foreach (lc, node->attlist)
5794 DefElem *e = lfirst(lc);
5796 if (strcmp(e->defname, "binary") == 0)
5798 else if (strcmp(e->defname, "oids") == 0)
5800 else if (strcmp(e->defname, "delimiter") == 0)
5801 delimiter = ((Value *) e->arg)->val.str;
5802 else if (strcmp(e->defname, "null") == 0)
5803 null = ((Value *) e->arg)->val.str;
5804 else if (strcmp(e->defname, "csv") == 0)
5806 else if (strcmp(e->defname, "header") == 0)
5808 else if (strcmp(e->defname, "quote") == 0)
5809 quote = ((Value *) e->arg)->val.str;
5810 else if (strcmp(e->defname, "escape") == 0)
5811 escape = ((Value *) e->arg)->val.str;
5812 else if (strcmp(e->defname, "force_quote") == 0)
5813 force_quote = e->arg;
5814 else if (strcmp(e->defname, "force_notnull") == 0)
5815 force_notnull = e->arg;
5818 delay_string_append_char(message, str, "COPY ");
5822 delay_string_append_char(message, str, "(");
5823 _rewriteNode(BaseSelect, message, dblink, str, node->query);
5824 delay_string_append_char(message, str, ")");
5828 delay_string_append_char(message, str, "BINARY ");
5830 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
5834 delay_string_append_char(message, str, "(");
5835 _rewriteNode(BaseSelect, message, dblink, str, node->attlist);
5836 delay_string_append_char(message, str, ") ");
5840 delay_string_append_char(message, str, " OIDS ");
5842 if (node->is_from == TRUE)
5843 delay_string_append_char(message, str, " FROM ");
5845 delay_string_append_char(message, str, " TO ");
5849 delay_string_append_char(message, str, "'");
5850 delay_string_append_char(message, str, node->filename);
5851 delay_string_append_char(message, str, "'");
5854 delay_string_append_char(message, str, node->is_from == TRUE ? "STDIN" : "STDOUT");
5858 delay_string_append_char(message, str, " DELIMITERS '");
5859 delay_string_append_char(message, str, delimiter);
5860 delay_string_append_char(message, str, "'");
5865 delay_string_append_char(message, str, "NULL '");
5866 delay_string_append_char(message, str, null);
5867 delay_string_append_char(message, str, "' ");
5871 delay_string_append_char(message, str, "CSV ");
5874 delay_string_append_char(message, str, "HEADER ");
5878 delay_string_append_char(message, str, "QUOTE '");
5879 delay_string_append_char(message, str, quote);
5880 delay_string_append_char(message, str, "' ");
5885 delay_string_append_char(message, str, "ESCAPE '");
5886 delay_string_append_char(message, str, escape);
5887 delay_string_append_char(message, str, "' ");
5892 delay_string_append_char(message, str, "FORCE QUOTE ");
5893 _rewriteNode(BaseSelect, message, dblink, str, force_quote);
5898 delay_string_append_char(message, str, " FORCE NOT NULL ");
5899 _rewriteNode(BaseSelect, message, dblink, str, force_notnull);
5903 static void _rewriteDeallocateStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DeallocateStmt *node)
5905 delay_string_append_char(message, str, "DEALLOCATE \"");
5906 delay_string_append_char(message, str, node->name);
5907 delay_string_append_char(message, str, "\"");
5910 static void _rewriteRenameStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RenameStmt *node)
5915 delay_string_append_char(message, str, "ALTER ");
5917 switch (node->renameType)
5919 case OBJECT_AGGREGATE:
5920 delay_string_append_char(message, str, "AGGREGATE ");
5921 _rewriteNode(BaseSelect, message, dblink, str, node->object);
5922 delay_string_append_char(message, str, " (");
5923 delay_string_append_char(message, str, ") RENAME TO \"");
5924 delay_string_append_char(message, str, node->newname);
5925 delay_string_append_char(message, str, "\"");
5928 case OBJECT_CONVERSION:
5929 delay_string_append_char(message, str, "CONVERSION ");
5930 _rewriteNode(BaseSelect, message, dblink, str, node->object);
5931 delay_string_append_char(message, str, " RENAME TO \"");
5932 delay_string_append_char(message, str, node->newname);
5933 delay_string_append_char(message, str, "\"");
5936 case OBJECT_DATABASE:
5937 delay_string_append_char(message, str, "DATABASE \"");
5938 delay_string_append_char(message, str, node->subname);
5939 delay_string_append_char(message, str, "\" RENAME TO \"");
5940 delay_string_append_char(message, str, node->newname);
5941 delay_string_append_char(message, str, "\"");
5944 case OBJECT_FUNCTION:
5945 delay_string_append_char(message, str, "FUNCTION ");
5947 foreach (lc, node->object)
5949 Node *n = lfirst(lc);
5952 Value *value = (Value *) n;
5956 delay_string_append_char(message, str, ".");
5957 delay_string_append_char(message, str, "\"");
5958 delay_string_append_char(message, str, value->val.str);
5959 delay_string_append_char(message, str, "\"");
5962 _rewriteNode(BaseSelect, message, dblink, str, n);
5965 delay_string_append_char(message, str, "(");
5966 _rewriteNode(BaseSelect, message, dblink, str, node->objarg);
5967 delay_string_append_char(message, str, ")");
5968 delay_string_append_char(message, str, " RENAME TO \"");
5969 delay_string_append_char(message, str, node->newname);
5970 delay_string_append_char(message, str, "\"");
5974 delay_string_append_char(message, str, "ROLE \"");
5975 delay_string_append_char(message, str, node->subname);
5976 delay_string_append_char(message, str, "\" RENAME TO \"");
5977 delay_string_append_char(message, str, node->newname);
5978 delay_string_append_char(message, str, "\"");
5981 case OBJECT_LANGUAGE:
5982 delay_string_append_char(message, str, "LANGUAGE \"");
5983 delay_string_append_char(message, str, node->subname);
5984 delay_string_append_char(message, str, "\" RENAME TO \"");
5985 delay_string_append_char(message, str, node->newname);
5986 delay_string_append_char(message, str, "\"");
5989 case OBJECT_OPCLASS:
5990 delay_string_append_char(message, str, "OPERATOR CLASS ");
5991 _rewriteNode(BaseSelect, message, dblink, str, node->object);
5992 delay_string_append_char(message, str, " USING ");
5993 delay_string_append_char(message, str, node->subname);
5994 delay_string_append_char(message, str, " RENAME TO \"");
5995 delay_string_append_char(message, str, node->newname);
5996 delay_string_append_char(message, str, "\"");
6000 delay_string_append_char(message, str, "SCHEMA \"");
6001 delay_string_append_char(message, str, node->subname);
6002 delay_string_append_char(message, str, "\" RENAME TO \"");
6003 delay_string_append_char(message, str, node->newname);
6004 delay_string_append_char(message, str, "\"");
6008 delay_string_append_char(message, str, "TABLE ");
6009 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
6010 delay_string_append_char(message, str, " RENAME TO \"");
6011 delay_string_append_char(message, str, node->newname);
6012 delay_string_append_char(message, str, "\"");
6016 delay_string_append_char(message, str, "INDEX ");
6017 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
6018 delay_string_append_char(message, str, " RENAME TO \"");
6019 delay_string_append_char(message, str, node->newname);
6020 delay_string_append_char(message, str, "\"");
6024 delay_string_append_char(message, str, "TABLE ");
6025 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
6026 delay_string_append_char(message, str, " RENAME \"");
6027 delay_string_append_char(message, str, node->subname);
6028 delay_string_append_char(message, str, "\" TO \"");
6029 delay_string_append_char(message, str, node->newname);
6030 delay_string_append_char(message, str, "\"");
6033 case OBJECT_TRIGGER:
6034 delay_string_append_char(message, str, "TRIGGER \"");
6035 delay_string_append_char(message, str, node->subname);
6036 delay_string_append_char(message, str, "\" ON ");
6037 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
6038 delay_string_append_char(message, str, " RENAME TO \"");
6039 delay_string_append_char(message, str, node->newname);
6040 delay_string_append_char(message, str, "\"");
6043 case OBJECT_TABLESPACE:
6044 delay_string_append_char(message, str, "TABLESPACE \"");
6045 delay_string_append_char(message, str, node->subname);
6046 delay_string_append_char(message, str, "\" RENAME TO \"");
6047 delay_string_append_char(message, str, node->newname);
6048 delay_string_append_char(message, str, "\"");
6057 _rewriteOptRoleList(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *options)
6061 foreach (lc, options)
6063 DefElem *elem = lfirst(lc);
6064 Value *value = (Value *) elem->arg;
6066 if (strcmp(elem->defname, "password") == 0)
6069 delay_string_append_char(message, str, " PASSWORD NULL");
6072 delay_string_append_char(message, str, " PASSWORD '");
6073 delay_string_append_char(message, str, value->val.str);
6074 delay_string_append_char(message, str, "'");
6077 else if (strcmp(elem->defname, "encryptedPassword") == 0)
6079 delay_string_append_char(message, str, " ENCRYPTED PASSWORD '");
6080 delay_string_append_char(message, str, value->val.str);
6081 delay_string_append_char(message, str, "'");
6083 else if (strcmp(elem->defname, "unencryptedPassword") == 0)
6085 delay_string_append_char(message, str, " UNENCRYPTED PASSWORD '");
6086 delay_string_append_char(message, str, value->val.str);
6087 delay_string_append_char(message, str, "'");
6089 else if (strcmp(elem->defname, "superuser") == 0)
6091 if (value->val.ival == TRUE)
6092 delay_string_append_char(message, str, " SUPERUSER");
6094 delay_string_append_char(message, str, " NOSUPERUSER");
6096 else if (strcmp(elem->defname, "inherit") == 0)
6098 if (value->val.ival == TRUE)
6099 delay_string_append_char(message, str, " INHERIT");
6101 delay_string_append_char(message, str, " NOINHERIT");
6103 else if (strcmp(elem->defname, "createdb") == 0)
6105 if (value->val.ival == TRUE)
6106 delay_string_append_char(message, str, " CREATEDB");
6108 delay_string_append_char(message, str, " NOCREATEDB");
6110 else if (strcmp(elem->defname, "createrole") == 0)
6112 if (value->val.ival == TRUE)
6113 delay_string_append_char(message, str, " CREATEROLE");
6115 delay_string_append_char(message, str, " NOCREATEROLE");
6117 else if (strcmp(elem->defname, "canlogin") == 0)
6119 if (value->val.ival == TRUE)
6120 delay_string_append_char(message, str, " LOGIN");
6122 delay_string_append_char(message, str, " NOLOGIN");
6124 else if (strcmp(elem->defname, "connectionlimit") == 0)
6128 delay_string_append_char(message, str, " CONNECTION LIMIT ");
6129 snprintf(buf, 16, "%ld", value->val.ival);
6130 delay_string_append_char(message, str, buf);
6132 else if (strcmp(elem->defname, "validUntil") == 0)
6134 delay_string_append_char(message, str, " VALID UNTIL '");
6135 delay_string_append_char(message, str, value->val.str);
6136 delay_string_append_char(message, str, "'");
6138 else if (strcmp(elem->defname, "rolemembers") == 0)
6140 delay_string_append_char(message, str, " ROLE ");
6141 _rewriteIdList(BaseSelect, message, dblink, str, (List *) elem->arg);
6143 else if (strcmp(elem->defname, "sysid") == 0)
6147 delay_string_append_char(message, str, " SYSID ");
6148 snprintf(buf, 16, "%ld", value->val.ival);
6149 delay_string_append_char(message, str, buf);
6151 else if (strcmp(elem->defname, "adminmembers") == 0)
6153 delay_string_append_char(message, str, " ADMIN ");
6154 _rewriteIdList(BaseSelect, message, dblink, str, (List *) elem->arg);
6156 else if (strcmp(elem->defname, "addroleto") == 0)
6158 delay_string_append_char(message, str, " IN ROLE ");
6159 _rewriteIdList(BaseSelect, message, dblink, str, (List *) elem->arg);
6165 _rewriteCreateRoleStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateRoleStmt *node)
6167 delay_string_append_char(message, str, "CREATE ");
6168 switch (node->stmt_type)
6171 delay_string_append_char(message, str, "ROLE \"");
6175 delay_string_append_char(message, str, "USER \"");
6178 case ROLESTMT_GROUP:
6179 delay_string_append_char(message, str, "GROUP \"");
6182 delay_string_append_char(message, str, node->role);
6183 delay_string_append_char(message, str, "\"");
6185 _rewriteOptRoleList(BaseSelect, message, dblink, str, node->options);
6189 _rewriteAlterRoleStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterRoleStmt *node)
6191 delay_string_append_char(message, str, "ALTER ROLE \"");
6192 delay_string_append_char(message, str, node->role);
6193 delay_string_append_char(message, str, "\"");
6195 _rewriteOptRoleList(BaseSelect, message, dblink, str, node->options);
6199 _rewriteAlterRoleSetStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterRoleSetStmt *node)
6201 delay_string_append_char(message, str, "ALTER ROLE \"");
6202 delay_string_append_char(message, str, node->role);
6203 delay_string_append_char(message, str, "\" ");
6207 _rewriteNode(BaseSelect, message, dblink, str, node->setstmt);
6213 _rewriteSetTransactionModeList(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *list)
6220 DefElem *elem = lfirst(lc);
6225 delay_string_append_char(message, str, ",");
6227 if (strcmp(elem->defname, "transaction_isolation") == 0)
6229 A_Const *v = (A_Const *) elem->arg;
6230 delay_string_append_char(message, str, " ISOLATION LEVEL ");
6231 delay_string_append_char(message, str, v->val.val.str);
6233 else if (strcmp(elem->defname, "transaction_read_only") == 0)
6235 A_Const *n = (A_Const *) elem->arg;
6236 if (n->val.val.ival == TRUE)
6237 delay_string_append_char(message, str, "READ ONLY ");
6239 delay_string_append_char(message, str, "READ WRITE ");
6246 _rewriteSetRest(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, VariableSetStmt *node)
6248 if (strcmp(node->name, "timezone") == 0)
6250 delay_string_append_char(message, str, "TIME ZONE ");
6251 if (node->kind != VAR_RESET)
6252 _rewriteNode(BaseSelect, message, dblink, str, node->args);
6254 else if (strcmp(node->name, "TRANSACTION") == 0)
6256 delay_string_append_char(message, str, "TRANSACTION ");
6257 _rewriteSetTransactionModeList(BaseSelect, message, dblink, str, node->args);
6259 else if (strcmp(node->name, "SESSION CHARACTERISTICS") == 0)
6261 delay_string_append_char(message, str, "SESSION CHARACTERISTICS AS TRANSACTION ");
6262 _rewriteSetTransactionModeList(BaseSelect, message, dblink, str, node->args);
6264 else if (strcmp(node->name, "role") == 0)
6266 delay_string_append_char(message, str, "ROLE ");
6267 if (node->kind != VAR_RESET)
6268 _rewriteNode(BaseSelect, message, dblink, str, node->args);
6270 else if (strcmp(node->name, "session_authorization") == 0)
6272 delay_string_append_char(message, str, "SESSION AUTHORIZATION ");
6273 if (node->args == NIL && node->kind != VAR_RESET)
6274 delay_string_append_char(message, str, "DEFAULT");
6276 _rewriteNode(BaseSelect, message, dblink, str, node->args);
6278 else if (strcmp(node->name, "transaction_isolation") == 0)
6280 delay_string_append_char(message, str, "TRANSACTION ISOLATION LEVEL");
6281 if (node->kind != VAR_RESET)
6282 _rewriteSetTransactionModeList(BaseSelect, message, dblink, str, node->args);
6284 else if (strcmp(node->name, "xmloption") == 0)
6286 A_Const *v = linitial(node->args);
6287 delay_string_append_char(message, str, "XML OPTOIN ");
6288 delay_string_append_char(message, str, v->val.val.str);
6292 delay_string_append_char(message, str, node->name);
6293 if (node->kind != VAR_RESET)
6295 if (node->kind == VAR_SET_CURRENT)
6297 delay_string_append_char(message, str, " FROM CURRENT");
6301 delay_string_append_char(message, str, " TO ");
6302 if (node->args == NULL)
6304 delay_string_append_char(message, str, "DEFAULT");
6307 _rewriteNode(BaseSelect, message, dblink, str, node->args);
6314 _rewriteDropRoleStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DropRoleStmt *node)
6316 delay_string_append_char(message, str, "DROP ROLE ");
6317 if (node->missing_ok == TRUE)
6318 delay_string_append_char(message, str, "IF EXISTS ");
6319 _rewriteIdList(BaseSelect, message, dblink, str, node->roles);
6323 _rewriteCreateSchemaStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateSchemaStmt *node)
6325 delay_string_append_char(message, str, "CREATE SCHEMA \"");
6326 delay_string_append_char(message, str, node->schemaname);
6327 delay_string_append_char(message, str, "\"");
6330 delay_string_append_char(message, str, "AUTHORIZATION \"");
6331 delay_string_append_char(message, str, node->authid);
6332 delay_string_append_char(message, str, "\" ");
6334 _rewriteNode(BaseSelect, message, dblink, str, node->schemaElts);
6338 _rewriteVariableSetStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, VariableSetStmt *node)
6340 if (node->kind == VAR_RESET_ALL)
6342 delay_string_append_char(message, str, "RESET ALL");
6346 if (node->kind == VAR_RESET)
6347 delay_string_append_char(message, str, "RESET ");
6349 delay_string_append_char(message, str, "SET ");
6352 delay_string_append_char(message, str, "LOCAL ");
6354 _rewriteSetRest(BaseSelect, message, dblink, str, node);
6358 _rewriteVariableShowStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, VariableShowStmt *node)
6360 if (strcmp(node->name, "timezone") == 0)
6361 delay_string_append_char(message, str, "SHOW TIME ZONE");
6362 else if (strcmp(node->name, "transaction_isolation") == 0)
6363 delay_string_append_char(message, str, "SHOW TRANSACTION ISOLATION LEVEL");
6364 else if (strcmp(node->name, "session_authorization") == 0)
6365 delay_string_append_char(message, str, "SHOW SESSION AUTHORIZATION");
6366 else if (strcmp(node->name, "all") == 0)
6367 delay_string_append_char(message, str, "SHOW ALL");
6370 delay_string_append_char(message, str, "SHOW ");
6371 delay_string_append_char(message, str, node->name);
6376 _rewriteConstraintsSetStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ConstraintsSetStmt *node)
6378 delay_string_append_char(message, str, "SET CONSTRAINTS ");
6380 if (node->constraints == NIL)
6381 delay_string_append_char(message, str, "ALL");
6383 _rewriteNode(BaseSelect, message, dblink, str, node->constraints);
6385 delay_string_append_char(message, str, node->deferred == TRUE ? " DEFERRED" : " IMMEDIATE");
6389 _rewriteAlterTableCmd(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterTableCmd *node)
6393 switch (node->subtype)
6396 delay_string_append_char(message, str, "ADD ");
6397 _rewriteNode(BaseSelect, message, dblink, str, node->def);
6400 case AT_ColumnDefault:
6401 delay_string_append_char(message, str, "ALTER \"");
6402 delay_string_append_char(message, str, node->name);
6403 delay_string_append_char(message, str, "\" ");
6404 if (node->def == NULL)
6405 delay_string_append_char(message, str, "DROP DEFAULT");
6408 delay_string_append_char(message, str, "SET DEFAULT ");
6409 _rewriteNode(BaseSelect, message, dblink, str, node->def);
6413 case AT_DropNotNull:
6414 delay_string_append_char(message, str, "ALTER \"");
6415 delay_string_append_char(message, str, node->name);
6416 delay_string_append_char(message, str, "\" DROP NOT NULL");
6420 delay_string_append_char(message, str, "ALTER \"");
6421 delay_string_append_char(message, str, node->name);
6422 delay_string_append_char(message, str, "\" SET NOT NULL");
6425 case AT_SetStatistics:
6426 delay_string_append_char(message, str, "ALTER \"");
6427 delay_string_append_char(message, str, node->name);
6428 delay_string_append_char(message, str, "\" SET STATISTICS ");
6429 snprintf(buf, 16, "%ld", ((Value *) node->def)->val.ival);
6430 delay_string_append_char(message, str, buf);
6434 delay_string_append_char(message, str, "ALTER \"");
6435 delay_string_append_char(message, str, node->name);
6436 delay_string_append_char(message, str, "\" SET STORAGE ");
6437 delay_string_append_char(message, str, ((Value *) node->def)->val.str);
6441 delay_string_append_char(message, str, "DROP \"");
6442 delay_string_append_char(message, str, node->name);
6443 delay_string_append_char(message, str, "\" ");
6444 if (node->behavior == DROP_CASCADE)
6445 delay_string_append_char(message, str, "CASCADE");
6448 case AT_AlterColumnType:
6449 delay_string_append_char(message, str, "ALTER \"");
6450 delay_string_append_char(message, str, node->name);
6451 delay_string_append_char(message, str, "\" TYPE ");
6452 _rewriteNode(BaseSelect, message, dblink, str, node->def);
6453 if (node->transform)
6455 delay_string_append_char(message, str, " USING ");
6456 _rewriteNode(BaseSelect, message, dblink, str, node->transform);
6460 case AT_AddConstraint:
6461 delay_string_append_char(message, str, "ADD ");
6462 _rewriteNode(BaseSelect, message, dblink, str, node->def);
6465 case AT_DropConstraint:
6466 delay_string_append_char(message, str, "DROP CONSTRAINT \"");
6467 delay_string_append_char(message, str, node->name);
6468 delay_string_append_char(message, str, "\"");
6469 if (node->behavior == DROP_CASCADE)
6470 delay_string_append_char(message, str, " CASCADE");
6474 delay_string_append_char(message, str, "SET WITHOUT OIDS");
6478 delay_string_append_char(message, str, "CLUSTER ON \"");
6479 delay_string_append_char(message, str, node->name);
6480 delay_string_append_char(message, str, "\"");
6483 case AT_EnableAlwaysTrig:
6484 /* not implemented */
6487 case AT_EnableReplicaTrig:
6488 /* not implemented */
6491 case AT_DropCluster:
6492 delay_string_append_char(message, str, "SET WITHOUT CLUSTER");
6496 delay_string_append_char(message, str, "ENABLE TRIGGER \"");
6497 delay_string_append_char(message, str, node->name);
6498 delay_string_append_char(message, str, "\"");
6501 case AT_EnableTrigAll:
6502 delay_string_append_char(message, str, "ENABLE TRIGGER ALL");
6506 /* not implemented */
6509 case AT_EnableReplicaRule:
6510 /* not implemented */
6513 case AT_EnableAlwaysRule:
6514 /* not implemented */
6517 case AT_DisableRule:
6518 /* not implemented */
6522 /* not implemented */
6525 case AT_EnableTrigUser:
6526 delay_string_append_char(message, str, "ENABLE TRIGGER USER");
6529 case AT_DisableTrig:
6530 delay_string_append_char(message, str, "DISABLE TRIGGER \"");
6531 delay_string_append_char(message, str, node->name);
6532 delay_string_append_char(message, str, "\"");
6535 case AT_DisableTrigAll:
6536 delay_string_append_char(message, str, "DISABLE TRIGGER ALL");
6539 case AT_DisableTrigUser:
6540 delay_string_append_char(message, str, "DISABLE TRIGGER USER");
6543 case AT_ChangeOwner:
6544 delay_string_append_char(message, str, "OWNER TO \"");
6545 delay_string_append_char(message, str, node->name);
6546 delay_string_append_char(message, str, "\"");
6549 case AT_SetTableSpace:
6550 delay_string_append_char(message, str, "SET TABLESPACE \"");
6551 delay_string_append_char(message, str, node->name);
6552 delay_string_append_char(message, str, "\"");
6555 case AT_SetRelOptions:
6556 /* not implemented */
6559 case AT_ResetRelOptions:
6560 /* not implemented */
6569 _rewriteAlterTableStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterTableStmt *node)
6571 if (node->relkind == OBJECT_TABLE)
6572 delay_string_append_char(message, str, "ALTER TABLE ");
6574 delay_string_append_char(message, str, "ALTER INDEX ");
6576 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
6577 delay_string_append_char(message, str, " ");
6578 _rewriteNode(BaseSelect, message, dblink, str, node->cmds);
6582 _rewriteOptSeqList(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *options)
6586 foreach (lc, options)
6588 DefElem *e = lfirst(lc);
6589 Value *v = (Value *)e->arg;
6592 if (strcmp(e->defname, "cycle") == 0)
6594 if (v->val.ival == TRUE)
6595 delay_string_append_char(message, str, " CYCLE");
6597 delay_string_append_char(message, str, " NO CYCLE");
6599 else if (strcmp(e->defname, "minvalue") == 0 && !v)
6600 delay_string_append_char(message, str, " NO MINVALUE");
6601 else if (strcmp(e->defname, "maxvalue") == 0 && !v)
6602 delay_string_append_char(message, str, " NO MAXVALUE");
6603 else if (strcmp(e->defname, "owned_by") == 0)
6605 delay_string_append_char(message, str, " OWNED BY ");
6606 _rewriteIdList(BaseSelect, message, dblink, str, (List *)e->arg);
6610 if (strcmp(e->defname, "cache") == 0)
6611 delay_string_append_char(message, str, " CACHE ");
6612 else if (strcmp(e->defname, "increment") == 0)
6613 delay_string_append_char(message, str, " INCREMENT ");
6614 else if (strcmp(e->defname, "maxvalue") == 0 && v)
6615 delay_string_append_char(message, str, " MAXVALUE ");
6616 else if (strcmp(e->defname, "minvalue") == 0 && v)
6617 delay_string_append_char(message, str, " MINVALUE ");
6618 else if (strcmp(e->defname, "start") == 0)
6619 delay_string_append_char(message, str, " START ");
6620 else if (strcmp(e->defname, "restart") == 0)
6621 delay_string_append_char(message, str, " RESTART ");
6623 if (IsA(e->arg, String))
6624 delay_string_append_char(message, str, v->val.str);
6627 snprintf(buf, 16, "%ld", v->val.ival);
6628 delay_string_append_char(message, str, buf);
6635 _rewriteCreateSeqStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateSeqStmt *node)
6637 delay_string_append_char(message, str, "CREATE ");
6638 if (node->sequence->istemp)
6639 delay_string_append_char(message, str, "TEMP ");
6640 delay_string_append_char(message, str, "SEQUENCE ");
6641 _rewriteNode(BaseSelect, message, dblink, str, node->sequence);
6643 _rewriteOptSeqList(BaseSelect, message, dblink, str, node->options);
6647 _rewriteAlterSeqStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterSeqStmt *node)
6649 delay_string_append_char(message, str, "ALTER SEQUENCE ");
6650 _rewriteNode(BaseSelect, message, dblink, str, node->sequence);
6651 _rewriteOptSeqList(BaseSelect, message, dblink, str, node->options);
6655 _rewriteCreatePLangStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreatePLangStmt *node)
6657 delay_string_append_char(message, str, "CREATE ");
6658 if (node->pltrusted == true)
6659 delay_string_append_char(message, str, "TRUSTED ");
6660 delay_string_append_char(message, str, "LANGUAGE \"");
6661 delay_string_append_char(message, str, node->plname);
6662 delay_string_append_char(message, str, "\"");
6664 if (node->plhandler != NIL)
6669 delay_string_append_char(message, str, " HANDLER ");
6670 foreach (lc, node->plhandler)
6672 Value *v = lfirst(lc);
6677 delay_string_append_char(message, str, ".");
6679 delay_string_append_char(message, str, "\"");
6680 delay_string_append_char(message, str, v->val.str);
6681 delay_string_append_char(message, str, "\"");
6685 if (node->plvalidator != NIL)
6690 delay_string_append_char(message, str, " VALIDATOR ");
6691 foreach (lc, node->plvalidator)
6693 Value *v = lfirst(lc);
6698 delay_string_append_char(message, str, ".");
6700 delay_string_append_char(message, str, "\"");
6701 delay_string_append_char(message, str, v->val.str);
6702 delay_string_append_char(message, str, "\"");
6708 _rewriteDropPLangStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DropPLangStmt *node)
6710 delay_string_append_char(message, str, "DROP LANGUAGE \"");
6711 delay_string_append_char(message, str, node->plname);
6712 delay_string_append_char(message, str, "\"");
6713 if (node->behavior == DROP_CASCADE)
6714 delay_string_append_char(message, str, " CASCADE");
6718 _rewriteCreateTableSpaceStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateTableSpaceStmt *node)
6720 delay_string_append_char(message, str, "CREATE TABLESPACE \"");
6721 delay_string_append_char(message, str, node->tablespacename);
6722 delay_string_append_char(message, str, "\" ");
6726 delay_string_append_char(message, str, "OWNER \"");
6727 delay_string_append_char(message, str, node->owner);
6728 delay_string_append_char(message, str, "\" ");
6731 delay_string_append_char(message, str, "LOCATION '");
6732 delay_string_append_char(message, str, node->location);
6733 delay_string_append_char(message, str, "'");
6737 _rewriteDropTableSpaceStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DropTableSpaceStmt *node)
6739 delay_string_append_char(message, str, "DROP TABLESPACE \"");
6740 delay_string_append_char(message, str, node->tablespacename);
6741 delay_string_append_char(message, str, "\"");
6745 _rewriteFuncName(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *func_name)
6751 if (func_name == NULL)
6754 foreach (lc, func_name)
6756 v = (Value *) lfirst(lc);
6761 delay_string_append_char(message, str, ".");
6765 //delay_string_append_char(message, str, "\"");
6766 delay_string_append_char(message, str, v->val.str);
6767 //delay_string_append_char(message, str, "\"");
6776 _rewriteCreateTrigStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateTrigStmt *node)
6780 if (node->isconstraint == TRUE)
6781 delay_string_append_char(message, str, "CREATE CONSTRAINT TRIGGER \"");
6783 delay_string_append_char(message, str, "CREATE TRIGGER \"");
6784 delay_string_append_char(message, str, node->trigname);
6785 delay_string_append_char(message, str, "\" ");
6787 if (node->before == TRUE)
6788 delay_string_append_char(message, str, "BEFORE ");
6790 delay_string_append_char(message, str, "AFTER ");
6792 len = strlen(node->actions);
6793 for (i = 0; i < len; i++)
6796 delay_string_append_char(message, str, "OR ");
6798 if (node->actions[i] == 'i')
6799 delay_string_append_char(message, str, "INSERT ");
6800 else if (node->actions[i] == 'd')
6801 delay_string_append_char(message, str, "DELETE ");
6803 delay_string_append_char(message, str, "UPDATE ");
6806 delay_string_append_char(message, str, "ON ");
6807 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
6809 if (node->constrrel)
6811 delay_string_append_char(message, str, " FROM ");
6812 _rewriteNode(BaseSelect, message, dblink, str, node->constrrel);
6815 if (node->deferrable)
6816 delay_string_append_char(message, str, " DEFERRABLE");
6817 if (node->initdeferred)
6818 delay_string_append_char(message, str, " INITIALLY DEFERRED");
6820 if (node->row == TRUE)
6821 delay_string_append_char(message, str, " FOR EACH ROW ");
6823 delay_string_append_char(message, str, " FOR EACH STATEMENT ");
6825 delay_string_append_char(message, str, "EXECUTE PROCEDURE ");
6827 _rewriteFuncName(BaseSelect, message, dblink, str, node->funcname);
6828 delay_string_append_char(message, str, "(");
6829 _rewriteNode(BaseSelect, message, dblink, str, node->args);
6830 delay_string_append_char(message, str, ")");
6834 _rewriteDropPropertyStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DropPropertyStmt *node)
6836 switch (node->removeType)
6838 case OBJECT_TRIGGER:
6839 delay_string_append_char(message, str, "DROP TRIGGER \"");
6840 delay_string_append_char(message, str, node->property);
6841 delay_string_append_char(message, str, "\" ON ");
6842 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
6843 if (node->behavior == DROP_CASCADE)
6844 delay_string_append_char(message, str, " CASCADE");
6848 delay_string_append_char(message, str, "DROP RULE \"");
6849 delay_string_append_char(message, str, node->property);
6850 delay_string_append_char(message, str, "\" ON ");
6851 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
6852 if (node->behavior == DROP_CASCADE)
6853 delay_string_append_char(message, str, " CASCADE");
6862 _rewriteDefinition(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *definition)
6867 if (definition == NIL)
6870 delay_string_append_char(message, str, "(");
6871 foreach (lc, definition)
6873 DefElem *e = lfirst(lc);
6878 delay_string_append_char(message, str, ", ");
6880 delay_string_append_char(message, str, "\"");
6881 delay_string_append_char(message, str, e->defname);
6882 delay_string_append_char(message, str, "\"");
6886 delay_string_append_char(message, str, "=");
6887 _rewriteNode(BaseSelect, message, dblink, str, e->arg);
6890 delay_string_append_char(message, str, ")");
6894 _rewriteDefineStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DefineStmt *node)
6901 case OBJECT_AGGREGATE:
6902 delay_string_append_char(message, str, "CREATE AGGREGATE ");
6903 _rewriteFuncName(BaseSelect, message, dblink, str, node->defnames);
6904 delay_string_append_char(message, str, " ");
6905 _rewriteDefinition(BaseSelect, message, dblink, str, node->definition);
6908 case OBJECT_OPERATOR:
6909 delay_string_append_char(message, str, "CREATE OPERATOR ");
6911 foreach (lc, node->defnames)
6913 Value *v = lfirst(lc);
6918 delay_string_append_char(message, str, ".");
6920 delay_string_append_char(message, str, v->val.str);
6923 delay_string_append_char(message, str, " ");
6924 _rewriteDefinition(BaseSelect, message, dblink, str, node->definition);
6928 delay_string_append_char(message, str, "CREATE TYPE");
6929 _rewriteFuncName(BaseSelect, message, dblink, str, node->defnames);
6930 delay_string_append_char(message, str, " ");
6931 _rewriteDefinition(BaseSelect, message, dblink, str, node->definition);
6934 case OBJECT_TSPARSER:
6935 delay_string_append_char(message, str, "CREATE TEXT SEARCH PARSER ");
6936 _rewriteIdList(BaseSelect, message, dblink, str, node->defnames);
6937 _rewriteDefinition(BaseSelect, message, dblink, str, node->definition);
6940 case OBJECT_TSDICTIONARY:
6941 delay_string_append_char(message, str, "CREATE TEXT SEARCH DICTIONARY ");
6942 _rewriteIdList(BaseSelect, message, dblink, str, node->defnames);
6943 _rewriteDefinition(BaseSelect, message, dblink, str, node->definition);
6946 case OBJECT_TSTEMPLATE:
6947 delay_string_append_char(message, str, "CREATE TEXT SEARCH TEMPLATE ");
6948 _rewriteIdList(BaseSelect, message, dblink, str, node->defnames);
6949 _rewriteDefinition(BaseSelect, message, dblink, str, node->definition);
6952 case OBJECT_TSCONFIGURATION:
6953 delay_string_append_char(message, str, "CREATE TEXT SEARCH CONFIGURATION ");
6954 _rewriteIdList(BaseSelect, message, dblink, str, node->defnames);
6955 _rewriteDefinition(BaseSelect, message, dblink, str, node->definition);
6964 _rewriteOperatorName(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *list)
6971 Value *v = lfirst(lc);
6976 delay_string_append_char(message, str, ".");
6978 delay_string_append_char(message, str, v->val.str);
6983 _rewriteCreateOpClassItem(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateOpClassItem *node)
6987 switch (node->itemtype)
6989 case OPCLASS_ITEM_OPERATOR:
6990 delay_string_append_char(message, str, "OPERATOR ");
6991 snprintf(buf, 16, "%d", node->number);
6992 delay_string_append_char(message, str, buf);
6993 delay_string_append_char(message, str, " ");
6994 _rewriteOperatorName(BaseSelect, message, dblink, str, node->name);
6996 if (node->args != NIL)
6998 delay_string_append_char(message, str, "(");
6999 _rewriteNode(BaseSelect, message, dblink, str, node->args);
7000 delay_string_append_char(message, str, ")");
7002 if (node->recheck == TRUE)
7003 delay_string_append_char(message, str, " RECHECK");
7006 case OPCLASS_ITEM_FUNCTION:
7007 delay_string_append_char(message, str, "FUNCTION ");
7008 snprintf(buf, 16, "%d", node->number);
7009 delay_string_append_char(message, str, buf);
7010 delay_string_append_char(message, str, " ");
7011 _rewriteFuncName(BaseSelect, message, dblink, str, node->name);
7012 delay_string_append_char(message, str, "(");
7013 _rewriteNode(BaseSelect, message, dblink, str, node->args);
7014 delay_string_append_char(message, str, ")");
7017 case OPCLASS_ITEM_STORAGETYPE:
7018 delay_string_append_char(message, str, "STORAGE ");
7019 _rewriteNode(BaseSelect, message, dblink, str, node->storedtype);
7029 _rewriteCreateOpClassStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateOpClassStmt *node)
7031 delay_string_append_char(message, str, "CREATE OPERATOR CLASS ");
7032 _rewriteFuncName(BaseSelect, message, dblink, str, node->opclassname);
7034 if (node->isDefault == TRUE)
7035 delay_string_append_char(message, str, " DEFAULT");
7037 delay_string_append_char(message, str, " FOR TYPE ");
7038 _rewriteNode(BaseSelect, message, dblink, str, node->datatype);
7039 delay_string_append_char(message, str, " USING ");
7040 delay_string_append_char(message, str, node->amname);
7041 delay_string_append_char(message, str, " AS ");
7042 _rewriteNode(BaseSelect, message, dblink, str, node->items);
7046 _rewriteRemoveOpClassStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RemoveOpClassStmt *node)
7048 delay_string_append_char(message, str, "DROP OPERATOR CLASS ");
7049 _rewriteFuncName(BaseSelect, message, dblink, str, node->opclassname);
7050 delay_string_append_char(message, str, " USING ");
7051 delay_string_append_char(message, str, node->amname);
7052 if (node->behavior == DROP_CASCADE)
7053 delay_string_append_char(message, str, " CASCADE");
7057 _rewriteDropStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DropStmt *node)
7062 delay_string_append_char(message, str, "DROP ");
7063 switch (node->removeType)
7066 delay_string_append_char(message, str, "TABLE ");
7069 case OBJECT_SEQUENCE:
7070 delay_string_append_char(message, str, "SEQUENCE ");
7074 delay_string_append_char(message, str, "VIEW ");
7078 delay_string_append_char(message, str, "INDEX ");
7082 delay_string_append_char(message, str, "TYPE ");
7086 delay_string_append_char(message, str, "DOMAIN ");
7089 case OBJECT_CONVERSION:
7090 delay_string_append_char(message, str, "CONVERSION ");
7094 delay_string_append_char(message, str, "SCHEMA ");
7101 foreach (lc, node->objects)
7106 delay_string_append_char(message, str, ", ");
7107 _rewriteFuncName(BaseSelect, message, dblink, str, lfirst(lc));
7110 if (node->behavior == DROP_CASCADE)
7111 delay_string_append_char(message, str, " CASCADE");
7115 _rewriteFetchStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FetchStmt *node)
7119 snprintf(buf, 16, "%ld", node->howMany);
7121 if (node->ismove == TRUE)
7122 delay_string_append_char(message, str, "MOVE ");
7124 delay_string_append_char(message, str, "FETCH ");
7126 switch (node->direction)
7129 delay_string_append_char(message, str, "FORWARD ");
7130 if (node->howMany == FETCH_ALL)
7131 delay_string_append_char(message, str, "ALL ");
7134 delay_string_append_char(message, str, buf);
7135 delay_string_append_char(message, str, " ");
7139 case FETCH_BACKWARD:
7140 delay_string_append_char(message, str, "BACKWARD ");
7141 if (node->howMany == FETCH_ALL)
7142 delay_string_append_char(message, str, "ALL ");
7145 delay_string_append_char(message, str, buf);
7146 delay_string_append_char(message, str, " ");
7150 case FETCH_ABSOLUTE:
7151 if (node->howMany == 1)
7152 delay_string_append_char(message, str, "FIRST ");
7153 else if (node->howMany == -1)
7154 delay_string_append_char(message, str, "LAST ");
7157 delay_string_append_char(message, str, "ABSOLUTE ");
7158 delay_string_append_char(message, str, buf);
7159 delay_string_append_char(message, str, " ");
7163 case FETCH_RELATIVE:
7164 delay_string_append_char(message, str, "RELATIVE ");
7165 delay_string_append_char(message, str, buf);
7166 delay_string_append_char(message, str, " ");
7170 delay_string_append_char(message, str, "IN \"");
7171 delay_string_append_char(message, str, node->portalname);
7172 delay_string_append_char(message, str, "\"");
7176 _rewritePrivilegeList(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *list)
7182 delay_string_append_char(message, str, "ALL");
7187 Value *v = lfirst(lc);
7192 delay_string_append_char(message, str, ", ");
7194 delay_string_append_char(message, str, v->val.str);
7200 _rewriteFunctionParameter(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FunctionParameter *node)
7204 case FUNC_PARAM_OUT:
7205 delay_string_append_char(message, str, "OUT ");
7208 case FUNC_PARAM_INOUT:
7209 delay_string_append_char(message, str, "INOUT ");
7219 delay_string_append_char(message, str, "\"");
7220 delay_string_append_char(message, str, node->name);
7221 delay_string_append_char(message, str, "\" ");
7224 _rewriteNode(BaseSelect, message, dblink, str, node->argType);
7228 _rewriteFuncWithArgs(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, FuncWithArgs *node)
7230 _rewriteFuncName(BaseSelect, message, dblink, str, node->funcname);
7231 delay_string_append_char(message, str, "(");
7232 _rewriteNode(BaseSelect, message, dblink, str, node->funcargs);
7233 delay_string_append_char(message, str, ")");
7237 _rewritePrivTarget(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, PrivTarget *node)
7239 switch (node->objtype)
7241 case ACL_OBJECT_RELATION:
7242 _rewriteNode(BaseSelect, message, dblink, str, node->objs);
7245 case ACL_OBJECT_SEQUENCE:
7246 delay_string_append_char(message, str, "SEQUENCE ");
7247 _rewriteNode(BaseSelect, message, dblink, str, node->objs);
7250 case ACL_OBJECT_FUNCTION:
7251 delay_string_append_char(message, str, "FUNCTION ");
7252 _rewriteNode(BaseSelect, message, dblink, str, node->objs);
7255 case ACL_OBJECT_DATABASE:
7256 delay_string_append_char(message, str, "DATABASE ");
7257 _rewriteIdList(BaseSelect, message, dblink, str, node->objs);
7260 case ACL_OBJECT_LANGUAGE:
7261 delay_string_append_char(message, str, "LANGUAGE ");
7262 _rewriteIdList(BaseSelect, message, dblink, str, node->objs);
7265 case ACL_OBJECT_NAMESPACE:
7266 delay_string_append_char(message, str, "SCHEMA ");
7267 _rewriteIdList(BaseSelect, message, dblink, str, node->objs);
7270 case ACL_OBJECT_TABLESPACE:
7271 delay_string_append_char(message, str, "TABLESPACE ");
7272 _rewriteIdList(BaseSelect, message, dblink, str, node->objs);
7278 _rewritePrivGrantee(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, PrivGrantee *node)
7280 if (node->rolname == NULL)
7281 delay_string_append_char(message, str, "PUBLIC");
7284 delay_string_append_char(message, str, "\"");
7285 delay_string_append_char(message, str, node->rolname);
7286 delay_string_append_char(message, str, "\"");
7291 _rewriteGrantStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, GrantStmt *node)
7295 if (node->is_grant == true)
7296 delay_string_append_char(message, str, "GRANT ");
7299 delay_string_append_char(message, str, "REVOKE ");
7300 if (node->grant_option == true)
7301 delay_string_append_char(message, str, "GRANT OPTION FOR ");
7304 _rewritePrivilegeList(BaseSelect, message, dblink, str, node->privileges);
7306 delay_string_append_char(message, str, " ON ");
7308 n = makeNode(PrivTarget);
7309 n->objtype = node->objtype;
7310 n->objs = node->objects;
7311 _rewriteNode(BaseSelect, message, dblink, str, n);
7314 if (node->is_grant == true)
7315 delay_string_append_char(message, str, " TO ");
7317 delay_string_append_char(message, str, " FROM ");
7318 _rewriteNode(BaseSelect, message, dblink, str, node->grantees);
7320 if (node->is_grant == true && node->grant_option == TRUE)
7321 delay_string_append_char(message, str, " WITH GRANT OPTION");
7323 if (node->behavior == DROP_CASCADE)
7324 delay_string_append_char(message, str, " CASCADE");
7329 _rewriteGrantRoleStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, GrantRoleStmt *node)
7331 if (node->is_grant == true)
7332 delay_string_append_char(message, str, "GRANT ");
7335 delay_string_append_char(message, str, "REVOKE ");
7336 if (node->admin_opt == true)
7337 delay_string_append_char(message, str, "ADMIN OPTION FOR ");
7340 _rewriteIdList(BaseSelect, message, dblink, str, node->granted_roles);
7342 delay_string_append_char(message, str, node->is_grant == true ? " TO " : " FROM ");
7344 _rewriteIdList(BaseSelect, message, dblink, str, node->grantee_roles);
7346 if (node->admin_opt == true && node->is_grant == true)
7347 delay_string_append_char(message, str, " WITH ADMIN OPTION");
7349 if (node->grantor != NULL)
7351 delay_string_append_char(message, str, " GRANTED BY \"");
7352 delay_string_append_char(message, str, node->grantor);
7353 delay_string_append_char(message, str, "\"");
7356 if (node->behavior == DROP_CASCADE)
7357 delay_string_append_char(message, str, " CASCADE");
7361 _rewriteFuncOptList(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *list)
7367 DefElem *e = lfirst(lc);
7368 Value *v = (Value *) e->arg;
7370 if (strcmp(e->defname, "strict") == 0)
7372 if (v->val.ival == TRUE)
7373 delay_string_append_char(message, str, " STRICT");
7375 delay_string_append_char(message, str, " CALLED ON NULL INPUT");
7377 else if (strcmp(e->defname, "volatility") == 0)
7379 char *s = v->val.str;
7380 if (strcmp(s, "immutable") == 0)
7381 delay_string_append_char(message, str, " IMMUTABLE");
7382 else if (strcmp(s, "stable") == 0)
7383 delay_string_append_char(message, str, " STABLE");
7384 else if (strcmp(s, "volatile") == 0)
7385 delay_string_append_char(message, str, " VOLATILE");
7387 else if (strcmp(e->defname, "security") == 0)
7389 if (v->val.ival == TRUE)
7390 delay_string_append_char(message, str, " SECURITY DEFINER");
7392 delay_string_append_char(message, str, " SECURITY INVOKER");
7394 else if (strcmp(e->defname, "as") == 0)
7396 delay_string_append_char(message, str, " AS ");
7397 _rewriteNode(BaseSelect, message, dblink, str, e->arg);
7399 else if (strcmp(e->defname, "language") == 0)
7401 delay_string_append_char(message, str, " LANGUAGE '");
7402 delay_string_append_char(message, str, v->val.str);
7403 delay_string_append_char(message, str, "'");
7409 _rewriteCreateFunctionStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateFunctionStmt *node)
7411 delay_string_append_char(message, str, "CREATE ");
7412 if (node->replace == true)
7413 delay_string_append_char(message, str, "OR REPLACE ");
7414 delay_string_append_char(message, str, "FUNCTION ");
7416 _rewriteFuncName(BaseSelect, message, dblink, str, node->funcname);
7418 delay_string_append_char(message, str, " (");
7419 _rewriteNode(BaseSelect, message, dblink, str, node->parameters);
7420 delay_string_append_char(message, str, ")");
7422 if (node->returnType)
7424 delay_string_append_char(message, str, " RETURNS ");
7425 _rewriteNode(BaseSelect, message, dblink, str, node->returnType);
7428 _rewriteFuncOptList(BaseSelect, message, dblink, str, node->options);
7430 if (node->withClause)
7432 delay_string_append_char(message, str, " WITH ");
7433 _rewriteDefinition(BaseSelect, message, dblink, str, node->withClause);
7438 _rewriteAlterFunctionStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterFunctionStmt *node)
7440 delay_string_append_char(message, str, "ALTER FUNCTION ");
7441 _rewriteNode(BaseSelect, message, dblink, str, node->func);
7442 _rewriteFuncOptList(BaseSelect, message, dblink, str, node->actions);
7446 _rewriteRemoveFuncStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RemoveFuncStmt *node)
7450 case OBJECT_FUNCTION:
7451 delay_string_append_char(message, str, "DROP FUNCTION ");
7454 case OBJECT_AGGREGATE:
7455 delay_string_append_char(message, str, "DROP AGGREGATE ");
7458 case OBJECT_OPERATOR:
7459 delay_string_append_char(message, str, "DROP OPERATOR CLASS ");
7466 if (node->missing_ok)
7467 delay_string_append_char(message, str, "IF EXISTS ");
7469 _rewriteFuncName(BaseSelect, message, dblink, str, node->name);
7471 delay_string_append_char(message, str, " (");
7472 _rewriteNode(BaseSelect, message, dblink, str, node->args);
7473 delay_string_append_char(message, str, ")");
7475 if (node->behavior == DROP_CASCADE)
7476 delay_string_append_char(message, str, " CASCADE");
7480 _rewriteCreateCastStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateCastStmt *node)
7482 delay_string_append_char(message, str, "CREATE CAST (");
7483 _rewriteNode(BaseSelect, message, dblink, str, node->sourcetype);
7484 delay_string_append_char(message, str, " AS ");
7485 _rewriteNode(BaseSelect, message, dblink, str, node->targettype);
7486 delay_string_append_char(message, str, ") WITH FUNCTION ");
7487 _rewriteNode(BaseSelect, message, dblink, str, node->func);
7489 switch (node->context)
7491 case COERCION_IMPLICIT:
7492 delay_string_append_char(message, str, " AS IMPLICIT");
7495 case COERCION_ASSIGNMENT:
7496 delay_string_append_char(message, str, " AS ASSIGNMENT");
7505 _rewriteDropCastStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DropCastStmt *node)
7507 delay_string_append_char(message, str, "DROP CAST (");
7508 _rewriteNode(BaseSelect, message, dblink, str, node->sourcetype);
7509 delay_string_append_char(message, str, " AS ");
7510 _rewriteNode(BaseSelect, message, dblink, str, node->targettype);
7511 delay_string_append_char(message, str, ")");
7513 if (node->behavior == DROP_CASCADE)
7514 delay_string_append_char(message, str, " CASCADE");
7518 _rewriteReindexStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ReindexStmt *node)
7520 delay_string_append_char(message, str, "REINDEX ");
7524 case OBJECT_DATABASE:
7525 if (node->do_system == true && node->do_user == false)
7526 delay_string_append_char(message, str, "SYSTEM ");
7528 delay_string_append_char(message, str, "DATABASE ");
7532 delay_string_append_char(message, str, "INDEX ");
7536 delay_string_append_char(message, str, "TABLE ");
7544 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
7548 delay_string_append_char(message, str, "\"");
7549 delay_string_append_char(message, str, (char *) node->name);
7550 delay_string_append_char(message, str, "\"");
7555 _rewriteAlterObjectSchemaStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterObjectSchemaStmt *node)
7557 delay_string_append_char(message, str, "ALTER ");
7559 switch (node->objectType)
7561 case OBJECT_AGGREGATE:
7562 delay_string_append_char(message, str, "AGGREGATE ");
7563 _rewriteFuncName(BaseSelect, message, dblink, str, node->object);
7564 delay_string_append_char(message, str, "(");
7565 if (lfirst(list_head(node->objarg)) == NULL)
7566 delay_string_append_char(message, str, "*");
7568 _rewriteNode(BaseSelect, message, dblink, str, lfirst(list_head(node->objarg)));
7569 delay_string_append_char(message, str, ") SET SCHAME \"");
7570 delay_string_append_char(message, str, node->newschema);
7571 delay_string_append_char(message, str, "\"");
7575 delay_string_append_char(message, str, "DOMAIN ");
7576 _rewriteFuncName(BaseSelect, message, dblink, str, node->object);
7577 delay_string_append_char(message, str, " SET SCHEMA \"");
7578 delay_string_append_char(message, str, node->newschema);
7579 delay_string_append_char(message, str, "\"");
7582 case OBJECT_FUNCTION:
7583 delay_string_append_char(message, str, "FUNCTION ");
7584 _rewriteFuncName(BaseSelect, message, dblink, str, node->object);
7585 delay_string_append_char(message, str, "(");
7586 _rewriteNode(BaseSelect, message, dblink, str, node->objarg);
7587 delay_string_append_char(message, str, ") SET SCHEMA \"");
7588 delay_string_append_char(message, str, node->newschema);
7589 delay_string_append_char(message, str, "\"");
7592 case OBJECT_SEQUENCE:
7593 delay_string_append_char(message, str, "SEQUENCE ");
7594 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
7595 delay_string_append_char(message, str, " SET SCHEMA \"");
7596 delay_string_append_char(message, str, node->newschema);
7597 delay_string_append_char(message, str, "\"");
7601 delay_string_append_char(message, str, "TABLE ");
7602 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
7603 delay_string_append_char(message, str, " SET SCHEMA \"");
7604 delay_string_append_char(message, str, node->newschema);
7605 delay_string_append_char(message, str, "\"");
7609 delay_string_append_char(message, str, "TYPE ");
7610 _rewriteFuncName(BaseSelect, message, dblink, str, node->object);
7611 delay_string_append_char(message, str, " SET SCHEMA \"");
7612 delay_string_append_char(message, str, node->newschema);
7613 delay_string_append_char(message, str, "\"");
7622 _rewriteAlterOwnerStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterOwnerStmt *node)
7624 delay_string_append_char(message, str, "ALTER ");
7626 switch (node->objectType)
7628 case OBJECT_AGGREGATE:
7629 delay_string_append_char(message, str, "AGGREGATE ");
7630 _rewriteFuncName(BaseSelect, message, dblink, str, node->object);
7631 delay_string_append_char(message, str, "(");
7632 if (lfirst(list_head(node->objarg)) == NULL)
7633 delay_string_append_char(message, str, "*");
7635 _rewriteNode(BaseSelect, message, dblink, str, lfirst(list_head(node->objarg)));
7636 delay_string_append_char(message, str, ") OWNER TO \"");
7637 delay_string_append_char(message, str, node->newowner);
7638 delay_string_append_char(message, str, "\"");
7641 case OBJECT_CONVERSION:
7642 delay_string_append_char(message, str, "CONVERSION ");
7643 _rewriteFuncName(BaseSelect, message, dblink, str, node->object);
7644 delay_string_append_char(message, str, " OWNER TO \"");
7645 delay_string_append_char(message, str, node->newowner);
7646 delay_string_append_char(message, str, "\"");
7649 case OBJECT_DATABASE:
7650 delay_string_append_char(message, str, "DATABASE \"");
7651 _rewriteIdList(BaseSelect, message, dblink, str, node->object);
7652 delay_string_append_char(message, str, "\" OWNER TO \"");
7653 delay_string_append_char(message, str, node->newowner);
7654 delay_string_append_char(message, str, "\"");
7658 delay_string_append_char(message, str, "DOMAIN ");
7659 _rewriteFuncName(BaseSelect, message, dblink, str, node->object);
7660 delay_string_append_char(message, str, " OWNER TO \"");
7661 delay_string_append_char(message, str, node->newowner);
7662 delay_string_append_char(message, str, "\"");
7665 case OBJECT_FUNCTION:
7666 delay_string_append_char(message, str, "FUNCTION ");
7667 _rewriteFuncName(BaseSelect, message, dblink, str, node->object);
7668 delay_string_append_char(message, str, "(");
7669 _rewriteNode(BaseSelect, message, dblink, str, node->objarg);
7670 delay_string_append_char(message, str, ") OWNER TO \"");
7671 delay_string_append_char(message, str, node->newowner);
7672 delay_string_append_char(message, str, "\"");
7675 case OBJECT_OPERATOR:
7676 delay_string_append_char(message, str, "OPERATOR ");
7677 _rewriteOperatorName(BaseSelect, message, dblink, str, node->object);
7678 delay_string_append_char(message, str, "(");
7679 _rewriteOperatorArgTypes(BaseSelect, message, dblink, str, node->objarg);
7680 delay_string_append_char(message, str, ") OWNER TO \"");
7681 delay_string_append_char(message, str, node->newowner);
7682 delay_string_append_char(message, str, "\"");
7685 case OBJECT_OPCLASS:
7686 delay_string_append_char(message, str, "OPERATOR CLASS ");
7687 _rewriteFuncName(BaseSelect, message, dblink, str, node->object);
7688 delay_string_append_char(message, str, " USING ");
7689 delay_string_append_char(message, str, node->addname);
7690 delay_string_append_char(message, str, " OWNER TO \"");
7691 delay_string_append_char(message, str, node->newowner);
7692 delay_string_append_char(message, str, "\"");
7696 delay_string_append_char(message, str, "SCHEMA \"");
7697 delay_string_append_char(message, str, linitial(node->object));
7698 delay_string_append_char(message, str, "\" OWNER TO \"");
7699 delay_string_append_char(message, str, node->newowner);
7700 delay_string_append_char(message, str, "\"");
7704 delay_string_append_char(message, str, "TYPE ");
7705 _rewriteFuncName(BaseSelect, message, dblink, str, node->object);
7706 delay_string_append_char(message, str, " OWNER TO \"");
7707 delay_string_append_char(message, str, node->newowner);
7708 delay_string_append_char(message, str, "\"");
7711 case OBJECT_TABLESPACE:
7712 delay_string_append_char(message, str, "TABLESPACE \"");
7713 delay_string_append_char(message, str, linitial(node->object));
7714 delay_string_append_char(message, str, "\" OWNER TO \"");
7715 delay_string_append_char(message, str, node->newowner);
7716 delay_string_append_char(message, str, "\"");
7725 _rewriteRuleStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RuleStmt *node)
7727 delay_string_append_char(message, str, "CREATE ");
7729 delay_string_append_char(message, str, "OR REPLACE ");
7730 delay_string_append_char(message, str, "RULE \"");
7731 delay_string_append_char(message, str, node->rulename);
7732 delay_string_append_char(message, str, "\" AS ON ");
7734 switch (node->event)
7737 delay_string_append_char(message, str, "SELECT");
7741 delay_string_append_char(message, str, "UPDATE");
7745 delay_string_append_char(message, str, "DELETE");
7749 delay_string_append_char(message, str, "INSERT");
7756 delay_string_append_char(message, str, " TO ");
7757 _rewriteNode(BaseSelect, message, dblink, str, node->relation);
7759 if (node->whereClause)
7761 delay_string_append_char(message, str, " WHERE ");
7762 _rewriteNode(BaseSelect, message, dblink, str, node->whereClause);
7765 delay_string_append_char(message, str, " DO ");
7768 delay_string_append_char(message, str, "INSTEAD ");
7770 if (node->actions == NIL)
7771 delay_string_append_char(message, str, "NOTHING");
7772 else if (list_length(node->actions) == 1)
7773 _rewriteNode(BaseSelect, message, dblink, str, linitial(node->actions));
7779 delay_string_append_char(message, str, "(");
7781 foreach (lc, node->actions)
7786 delay_string_append_char(message, str, ";");
7788 _rewriteNode(BaseSelect, message, dblink, str, lfirst(lc));
7791 delay_string_append_char(message, str, ")");
7796 _rewriteViewStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ViewStmt *node)
7799 delay_string_append_char(message, str, "CREATE OR REPLACE ");
7801 delay_string_append_char(message, str, "CREATE ");
7803 if (node->view->istemp == TRUE)
7804 delay_string_append_char(message, str, "TEMP ");
7806 delay_string_append_char(message, str, "VIEW ");
7807 _rewriteNode(BaseSelect, message, dblink, str, node->view);
7811 delay_string_append_char(message, str, "(");
7812 _rewriteIdList(BaseSelect, message, dblink, str, node->aliases);
7813 delay_string_append_char(message, str, ")");
7816 delay_string_append_char(message, str, " AS");
7817 _rewriteNode(BaseSelect, message, dblink, str, node->query);
7821 _rewriteCreatedbOptList(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *options)
7825 foreach (lc, options)
7827 DefElem *e = lfirst(lc);
7828 Value *v = (Value *) e->arg;
7832 if (strcmp(e->defname, "template") == 0)
7833 delay_string_append_char(message, str, " TEMPLATE ");
7834 else if (strcmp(e->defname, "location") == 0)
7836 delay_string_append_char(message, str, " LOCATION ");
7839 else if (strcmp(e->defname, "tablespace") == 0)
7840 delay_string_append_char(message, str, " TABLESPACE ");
7841 else if (strcmp(e->defname, "encoding") == 0)
7843 delay_string_append_char(message, str, " ENCODING ");
7846 else if (strcmp(e->defname, "owner") == 0)
7847 delay_string_append_char(message, str, " OWNER ");
7848 else if (strcmp(e->defname, "connectionlimit") == 0)
7849 delay_string_append_char(message, str, " CONNECTION LIMIT ");
7853 delay_string_append_char(message, str, "DEFAULT");
7854 else if (IsA((Node *)v, String))
7856 delay_string_append_char(message, str, sconst ? "'" : "'");
7857 delay_string_append_char(message, str, v->val.str);
7858 delay_string_append_char(message, str, sconst ? "'" : "'");
7863 snprintf(buf, 16, "%ld", v->val.ival);
7864 delay_string_append_char(message, str, buf);
7870 _rewriteCreatedbStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreatedbStmt *node)
7872 delay_string_append_char(message, str, "CREATE DATABASE \"");
7873 delay_string_append_char(message, str, node->dbname);
7874 delay_string_append_char(message, str, "\"");
7876 _rewriteCreatedbOptList(BaseSelect, message, dblink, str, node->options);
7880 _rewriteAlterDatabaseStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterDatabaseStmt *node)
7882 delay_string_append_char(message, str, "ALTER DATABASE \"");
7883 delay_string_append_char(message, str, node->dbname);
7884 delay_string_append_char(message, str, "\" ");
7886 _rewriteCreatedbOptList(BaseSelect, message, dblink, str, node->options);
7890 _rewriteAlterDatabaseSetStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterDatabaseSetStmt *node)
7892 delay_string_append_char(message, str, "ALTER DATABASE \"");
7893 delay_string_append_char(message, str, node->dbname);
7894 delay_string_append_char(message, str, "\" ");
7896 _rewriteNode(BaseSelect, message, dblink, str, node->setstmt);
7900 _rewriteDropdbStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, DropdbStmt *node)
7902 delay_string_append_char(message, str, "DROP DATABASE \"");
7903 delay_string_append_char(message, str, node->dbname);
7904 delay_string_append_char(message, str, "\"");
7908 _rewriteCreateDomainStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateDomainStmt *node)
7912 delay_string_append_char(message, str, "CREATE DOMAIN ");
7913 _rewriteFuncName(BaseSelect, message, dblink, str, node->domainname);
7914 delay_string_append_char(message, str, " ");
7915 _rewriteNode(BaseSelect, message, dblink, str, node->typename);
7918 foreach (lc, node->constraints)
7920 delay_string_append_char(message, str, " ");
7921 _rewriteNode(BaseSelect, message, dblink, str, lfirst(lc));
7926 _rewriteAlterDomainStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, AlterDomainStmt *node)
7928 delay_string_append_char(message, str, "ALTER DOMAIN ");
7929 _rewriteFuncName(BaseSelect, message, dblink, str, node->typename);
7931 switch (node->subtype)
7936 delay_string_append_char(message, str, " SET DEFAULT ");
7937 _rewriteNode(BaseSelect, message, dblink, str, node->def);
7940 delay_string_append_char(message, str, " DROP DEFAULT");
7944 delay_string_append_char(message, str, " DROP NOT NULL");
7948 delay_string_append_char(message, str, " SET NOT NULL");
7952 delay_string_append_char(message, str, " ADD ");
7953 _rewriteNode(BaseSelect, message, dblink, str, node->def);
7957 delay_string_append_char(message, str, " DROP CONSTRAINT \"");
7958 delay_string_append_char(message, str, node->name);
7959 delay_string_append_char(message, str, "\"");
7960 if (node->behavior == DROP_CASCADE)
7961 delay_string_append_char(message, str, " CASCADE");
7967 _rewriteCreateConversionStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CreateConversionStmt *node)
7969 delay_string_append_char(message, str, "CREATE ");
7971 if (node->def == TRUE)
7972 delay_string_append_char(message, str, "DEFAULT ");
7974 delay_string_append_char(message, str, "CONVERSION ");
7976 _rewriteFuncName(BaseSelect, message, dblink, str, node->conversion_name);
7978 delay_string_append_char(message, str, " FOR '");
7979 delay_string_append_char(message, str, node->for_encoding_name);
7980 delay_string_append_char(message, str, "' TO '");
7981 delay_string_append_char(message, str, node->to_encoding_name);
7982 delay_string_append_char(message, str, " FROM ");
7983 _rewriteFuncName(BaseSelect, message, dblink, str, node->func_name);
7987 _rewritePrepareStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, PrepareStmt *node)
7989 delay_string_append_char(message, str, "PREPARE \"");
7990 delay_string_append_char(message, str, node->name);
7991 delay_string_append_char(message, str, "\" ");
7993 if (node->argtypes != NIL)
7995 delay_string_append_char(message, str, "(");
7996 _rewriteNode(BaseSelect, message, dblink, str, node->argtypes);
7997 delay_string_append_char(message, str, ") ");
8000 delay_string_append_char(message, str, "AS ");
8001 _rewriteNode(BaseSelect, message, dblink, str, node->query);
8005 _rewriteExecuteStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, ExecuteStmt *node)
8009 IntoClause *into = node->into;
8010 RangeVar *rel = into->rel;
8012 delay_string_append_char(message, str, "CREATE ");
8013 if (rel->istemp == TRUE)
8014 delay_string_append_char(message, str, "TEMP ");
8015 delay_string_append_char(message, str, "TABLE ");
8016 _rewriteNode(BaseSelect, message, dblink, str, into->rel);
8017 delay_string_append_char(message, str, " AS ");
8020 delay_string_append_char(message, str, "EXECUTE \"");
8021 delay_string_append_char(message, str, node->name);
8022 delay_string_append_char(message, str, "\" ");
8024 if (node->params != NIL)
8026 delay_string_append_char(message, str, "(");
8027 _rewriteNode(BaseSelect, message, dblink, str, node->params);
8028 delay_string_append_char(message, str, ")");
8033 _rewriteLockStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, LockStmt *node)
8035 delay_string_append_char(message, str, "LOCK TABLE ");
8036 _rewriteNode(BaseSelect, message, dblink, str, node->relations);
8038 delay_string_append_char(message, str, " IN ");
8041 case AccessShareLock:
8042 delay_string_append_char(message, str, "ACCESS SHARE ");
8046 delay_string_append_char(message, str, "ROW SHARE ");
8049 case RowExclusiveLock:
8050 delay_string_append_char(message, str, "ROW EXCLUSIVE ");
8053 case ShareUpdateExclusiveLock:
8054 delay_string_append_char(message, str, "SHARE UPDATE EXCLUSIVE ");
8058 delay_string_append_char(message, str, "SHARE ");
8061 case ShareRowExclusiveLock:
8062 delay_string_append_char(message, str, "SHARE ROW EXCLUSIVE ");
8066 delay_string_append_char(message, str, "EXCLUSIVE ");
8069 case AccessExclusiveLock:
8070 delay_string_append_char(message, str, "ACCESS EXCLUSIVE ");
8073 delay_string_append_char(message, str, "MODE");
8075 if (node->nowait == TRUE)
8076 delay_string_append_char(message, str, " NOWAIT");
8080 _rewriteOperatorArgTypes(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *args)
8082 TypeName *left, *right;
8084 left = linitial(args);
8085 right = lsecond(args);
8088 _rewriteNode(BaseSelect, message, dblink, str, left);
8090 delay_string_append_char(message, str, "NONE");
8091 delay_string_append_char(message, str, ", ");
8093 _rewriteNode(BaseSelect, message, dblink, str, right);
8095 delay_string_append_char(message, str, "NONE");
8099 _rewriteCommentStmt(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CommentStmt *node)
8105 delay_string_append_char(message, str, "COMMENT ON ");
8107 switch (node->objtype)
8109 case OBJECT_AGGREGATE:
8110 delay_string_append_char(message, str, "AGGREGATE ");
8111 _rewriteFuncName(BaseSelect, message, dblink, str, node->objname);
8112 delay_string_append_char(message, str, "(");
8114 t = linitial(node->objargs);
8116 _rewriteNode(BaseSelect, message, dblink, str, t);
8118 delay_string_append_char(message, str, "*");
8119 delay_string_append_char(message, str, ")");
8122 case OBJECT_FUNCTION:
8123 delay_string_append_char(message, str, "FUNCTION ");
8124 _rewriteFuncName(BaseSelect, message, dblink, str, node->objname);
8125 delay_string_append_char(message, str, "(");
8126 _rewriteNode(BaseSelect, message, dblink, str, node->objargs);
8127 delay_string_append_char(message, str, ")");
8130 case OBJECT_OPERATOR:
8131 delay_string_append_char(message, str, "OPERATOR ");
8132 _rewriteOperatorName(BaseSelect, message, dblink, str, node->objname);
8133 delay_string_append_char(message, str, "(");
8134 _rewriteOperatorArgTypes(BaseSelect, message, dblink, str, node->objargs);
8135 delay_string_append_char(message, str, ")");
8138 case OBJECT_CONSTRAINT:
8139 delay_string_append_char(message, str, "CONSTRAINT \"");
8140 v = lsecond(node->objname);
8141 delay_string_append_char(message, str, v->val.str);
8142 delay_string_append_char(message, str, "\" ON ");
8143 _rewriteFuncName(BaseSelect, message, dblink, str, linitial(node->objargs));
8147 delay_string_append_char(message, str, "RULE \"");
8148 v = lsecond(node->objname);
8149 delay_string_append_char(message, str, v->val.str);
8150 delay_string_append_char(message, str, "\" ON ");
8151 _rewriteFuncName(BaseSelect, message, dblink, str, linitial(node->objargs));
8154 case OBJECT_TRIGGER:
8155 delay_string_append_char(message, str, "TRIGGER \"");
8156 v = lsecond(node->objname);
8157 delay_string_append_char(message, str, v->val.str);
8158 delay_string_append_char(message, str, "\" ON ");
8159 _rewriteFuncName(BaseSelect, message, dblink, str, linitial(node->objargs));
8162 case OBJECT_OPCLASS:
8163 delay_string_append_char(message, str, "OPERATOR CLASS ");
8164 _rewriteFuncName(BaseSelect, message, dblink, str, node->objname);
8165 delay_string_append_char(message, str, " USING ");
8166 v = linitial(node->objargs);
8167 delay_string_append_char(message, str, v->val.str);
8170 case OBJECT_LARGEOBJECT:
8171 delay_string_append_char(message, str, "LARGE OBJECT ");
8172 v = linitial(node->objname);
8174 delay_string_append_char(message, str, v->val.str);
8175 else if (IsA(v, Integer))
8177 snprintf(buf, 16, "%ld", v->val.ival);
8178 delay_string_append_char(message, str, buf);
8182 delay_string_append_char(message, str, "CAST (");
8183 _rewriteNode(BaseSelect, message, dblink, str, linitial(node->objname));
8184 delay_string_append_char(message, str, " AS ");
8185 _rewriteNode(BaseSelect, message, dblink, str, linitial(node->objargs));
8186 delay_string_append_char(message, str, ")");
8189 case OBJECT_LANGUAGE:
8190 delay_string_append_char(message, str, "LANGUAGE ");
8191 _rewriteFuncName(BaseSelect, message, dblink, str, node->objname);
8195 switch (node->objtype)
8198 delay_string_append_char(message, str, "COLUMN ");
8200 case OBJECT_DATABASE:
8201 delay_string_append_char(message, str, "DATABASE ");
8204 delay_string_append_char(message, str, "SCHEMA ");
8207 delay_string_append_char(message, str, "INDEX ");
8209 case OBJECT_SEQUENCE:
8210 delay_string_append_char(message, str, "SEQUENCE ");
8213 delay_string_append_char(message, str, "TABLE ");
8216 delay_string_append_char(message, str, "DOMAIN ");
8219 delay_string_append_char(message, str, "TYPE ");
8222 delay_string_append_char(message, str, "VIEW ");
8227 _rewriteFuncName(BaseSelect, message, dblink, str, node->objname);
8231 delay_string_append_char(message, str, " IS ");
8234 delay_string_append_char(message, str, "'");
8235 delay_string_append_char(message, str, node->comment);
8236 delay_string_append_char(message, str, "'");
8239 delay_string_append_char(message, str, "NULL");
8243 _rewriteRangeSubselect(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RangeSubselect *node)
8245 int last = message->current_select;
8246 Alias *alias = node->alias;
8247 char *table_name = alias->aliasname;
8248 int sub_no = message->analyze_num;
8249 int CallFromClause = 0;
8250 int next = message->analyze_num;
8252 if(message->r_code == SELECT_AEXPR)
8254 KeepRewriteQueryReturnCode(message, SELECT_AEXPR_FALSE);
8258 if(message->r_code == SELECT_ANALYZE && message->fromClause)
8261 delay_string_append_char(message, str, "(");
8262 _rewriteNode(BaseSelect, message, dblink, str, node->subquery);
8263 delay_string_append_char(message, str, ")");
8265 if(message->r_code == SELECT_ANALYZE)
8267 AnalyzeSelect *analyze;
8268 analyze=message->analyze[sub_no];
8270 if(node->alias && node->alias->colnames)
8273 int num = list_length(node->alias->colnames);
8274 int ret_num = message->analyze[last + 1]->select_ret->col_num;
8279 col_list = (char **) palloc(sizeof(char *) * num);
8281 foreach(lc,node->alias->colnames)
8283 Node *n = lfirst(lc);
8284 Value *value = (Value *) n;
8285 col_list[i] = value->val.str;
8288 message->analyze[last+1]->select_ret->col_list = col_list;
8292 message->analyze[last]->select_range = true;
8294 pool_debug("_rewriteRangeSubSelect: select range ture %d",sub_no);
8295 build_range_info(message,NULL,NULL,analyze->select_ret,table_name,last,sub_no);
8300 int temp = message->current_select;
8301 /* now Subquery's current_select is set
8302 * change the current_select
8304 message->current_select = last;
8305 build_virtual_table(message,node,next);
8306 message->current_select = temp;
8309 else if(message->r_code == SELECT_DEFAULT && message->ignore_rewrite == -1)
8311 Alias *alias = (Alias *) node->alias;
8312 delay_string_append_char(message, str, " AS ");
8313 delay_string_append_char(message, str, alias->aliasname);
8314 delay_string_append_char(message, str, " ");
8316 if (alias->colnames)
8318 AnalyzeSelect *analyze;
8321 analyze = message->analyze[last + 1];
8322 ret_num = analyze->select_ret->col_num;
8323 delay_string_append_char(message, str, "(");
8325 for (i = 0; i< ret_num; i++)
8328 snprintf(buf, 16, "%d", analyze->select_ret->return_list[i]);
8329 delay_string_append_char(message, str," \"pool_c$");
8330 delay_string_append_char(message, str,buf);
8331 delay_string_append_char(message, str,"\"");
8333 delay_string_append_char(message, str,",");
8335 delay_string_append_char(message, str, ")");
8338 _rewriteNode(BaseSelect, message, dblink, str, node->alias);
8344 _rewriteRangeFunction(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, RangeFunction *node)
8346 _rewriteNode(BaseSelect, message, dblink, str, node->funccallnode);
8349 _rewriteNode(BaseSelect, message, dblink, str, node->alias);
8352 if (node->coldeflist)
8354 delay_string_append_char(message, str, " (");
8355 _rewriteNode(BaseSelect, message, dblink, str, node->coldeflist);
8356 delay_string_append_char(message, str, ")");
8361 _rewriteWithDefinition(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, List *def_list)
8365 if (list_length(def_list) == 1)
8370 elem = linitial(def_list);
8371 v = (Value *)elem->arg;
8372 if (strcmp(elem->defname, "oids") == 0)
8374 Value *v = (Value *)elem->arg;
8375 if (v->val.ival == 1)
8376 delay_string_append_char(message, str, " WITH OIDS ");
8378 delay_string_append_char(message, str, " WITHOUT OIDS ");
8386 delay_string_append_char(message, str, " WITH ");
8387 _rewriteDefinition(BaseSelect, message, dblink, str, def_list);
8391 _rewriteCurrentOfExpr(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, CurrentOfExpr *node)
8393 delay_string_append_char(message, str, "CURRENT OF ");
8394 if (node->cursor_name == NULL)
8397 snprintf(n, sizeof(n), "$%d", node->cursor_param);
8398 delay_string_append_char(message, str, n);
8401 delay_string_append_char(message, str, node->cursor_name);
8406 * converts a Node into ascii string and append it to 'str'
8409 _rewriteNode(Node *BaseSelect, RewriteQuery *message, ConInfoTodblink *dblink, String *str, void *obj)
8413 else if (IsA(obj, List) ||IsA(obj, IntList) || IsA(obj, OidList))
8414 _rewriteList(BaseSelect, message, dblink, str, obj);
8415 else if (IsA(obj, Integer) ||
8418 IsA(obj, BitString))
8420 /* nodeRead does not want to see { } around these! */
8421 _rewriteValue(BaseSelect, message, dblink, str, obj);
8425 switch (nodeTag(obj))
8428 _rewriteAlias(BaseSelect, message, dblink, str, obj);
8431 _rewriteRangeVar(BaseSelect, message, dblink, str, obj);
8434 _rewriteVar(BaseSelect, message, dblink, str, obj);
8437 _rewriteConst(BaseSelect, message, dblink, str, obj);
8440 _rewriteParam(BaseSelect, message, dblink, str, obj);
8443 _rewriteAggref(BaseSelect, message, dblink, str, obj);
8446 _rewriteArrayRef(BaseSelect, message, dblink, str, obj);
8449 _rewriteFuncExpr(BaseSelect, message, dblink, str, obj);
8452 _rewriteOpExpr(BaseSelect, message, dblink, str, obj);
8454 case T_DistinctExpr:
8455 _rewriteDistinctExpr(BaseSelect, message, dblink, str, obj);
8457 case T_ScalarArrayOpExpr:
8458 _rewriteScalarArrayOpExpr(BaseSelect, message, dblink, str, obj);
8461 _rewriteBoolExpr(BaseSelect, message, dblink, str, obj);
8464 _rewriteSubLink(BaseSelect, message, dblink, str, obj);
8467 _rewriteSubPlan(BaseSelect, message, dblink, str, obj);
8470 _rewriteFieldSelect(BaseSelect, message, dblink, str, obj);
8473 _rewriteFieldStore(BaseSelect, message, dblink, str, obj);
8476 _rewriteRelabelType(BaseSelect, message, dblink, str, obj);
8478 case T_ConvertRowtypeExpr:
8479 _rewriteConvertRowtypeExpr(BaseSelect, message, dblink, str, obj);
8482 _rewriteCaseExpr(BaseSelect, message, dblink, str, obj);
8485 _rewriteCaseWhen(BaseSelect, message, dblink, str, obj);
8487 case T_CaseTestExpr:
8488 _rewriteCaseTestExpr(BaseSelect, message, dblink, str, obj);
8491 _rewriteArrayExpr(BaseSelect, message, dblink, str, obj);
8494 _rewriteRowExpr(BaseSelect, message, dblink, str, obj);
8496 case T_CoalesceExpr:
8497 _rewriteCoalesceExpr(BaseSelect, message, dblink, str, obj);
8500 _rewriteMinMaxExpr(BaseSelect, message, dblink, str, obj);
8503 _rewriteNullIfExpr(BaseSelect, message, dblink, str, obj);
8506 _rewriteNullTest(BaseSelect, message, dblink, str, obj);
8509 _rewriteBooleanTest(BaseSelect, message, dblink, str, obj);
8511 case T_CoerceToDomain:
8512 _rewriteCoerceToDomain(BaseSelect, message, dblink, str, obj);
8514 case T_CoerceToDomainValue:
8515 _rewriteCoerceToDomainValue(BaseSelect, message, dblink, str, obj);
8517 case T_SetToDefault:
8518 _rewriteSetToDefault(BaseSelect, message, dblink, str, obj);
8521 _rewriteTargetEntry(BaseSelect, message, dblink, str, obj);
8524 _rewriteRangeTblRef(BaseSelect, message, dblink, str, obj);
8527 _rewriteJoinExpr(BaseSelect, message, dblink, str, obj);
8530 _rewriteFromExpr(BaseSelect, message, dblink, str, obj);
8534 _rewriteCreateStmt(BaseSelect, message, dblink, str, obj);
8537 _rewriteIndexStmt(BaseSelect, message, dblink, str, obj);
8540 _rewriteNotifyStmt(BaseSelect, message, dblink, str, obj);
8542 case T_DeclareCursorStmt:
8543 _rewriteDeclareCursorStmt(BaseSelect, message, dblink, str, obj);
8546 _rewriteSelectStmt(BaseSelect, message, dblink, str, obj);
8549 _rewriteColumnDef(BaseSelect, message, dblink, str, obj);
8552 _rewriteTypeName(BaseSelect, message, dblink, str, obj);
8555 _rewriteTypeCast(BaseSelect, message, dblink, str, obj);
8558 _rewriteIndexElem(BaseSelect, message, dblink, str, obj);
8561 _rewriteSortClause(BaseSelect, message, dblink, str, obj);
8564 _rewriteGroupClause(BaseSelect, message, dblink, str, obj);
8566 case T_SetOperationStmt:
8567 _rewriteSetOperationStmt(BaseSelect, message, dblink, str, obj);
8569 /* case T_RangeTblEntry:
8570 _rewriteRangeTblEntry(BaseSelect, message, dblink, str, obj);
8573 _rewriteAExpr(BaseSelect, message, dblink, str, obj);
8576 _rewriteColumnRef(BaseSelect, message, dblink, str, obj);
8579 _rewriteParamRef(BaseSelect, message, dblink, str, obj);
8582 _rewriteAConst(BaseSelect, message, dblink, str, obj);
8585 _rewriteA_Indices(BaseSelect, message, dblink, str, obj);
8587 case T_A_Indirection:
8588 _rewriteA_Indirection(BaseSelect, message, dblink, str, obj);
8591 _rewriteResTarget(BaseSelect, message, dblink, str, obj);
8594 _rewriteConstraint(BaseSelect, message, dblink, str, obj);
8596 case T_FkConstraint:
8597 _rewriteFkConstraint(BaseSelect, message, dblink, str, obj);
8600 _rewriteFuncCall(BaseSelect, message, dblink, str, obj);
8603 _rewriteDefElem(BaseSelect, message, dblink, str, obj);
8605 case T_LockingClause:
8606 _rewriteLockingClause(BaseSelect, message, dblink, str, obj);
8610 _rewriteSortBy(BaseSelect, message, dblink, str, obj);
8614 _rewriteInsertStmt(BaseSelect, message, dblink, str, obj);
8618 _rewriteUpdateStmt(BaseSelect, message, dblink, str, obj);
8622 _rewriteDeleteStmt(BaseSelect, message, dblink, str, obj);
8625 case T_TransactionStmt:
8626 _rewriteTransactionStmt(BaseSelect, message, dblink, str, obj);
8629 case T_TruncateStmt:
8630 _rewriteTruncateStmt(BaseSelect, message, dblink, str, obj);
8634 _rewriteVacuumStmt(BaseSelect, message, dblink, str, obj);
8638 _rewriteExplainStmt(BaseSelect, message, dblink, str, obj);
8642 _rewriteClusterStmt(BaseSelect, message, dblink, str, obj);
8645 case T_CheckPointStmt:
8646 _rewriteCheckPointStmt(BaseSelect, message, dblink, str, obj);
8649 case T_ClosePortalStmt:
8650 _rewriteClosePortalStmt(BaseSelect, message, dblink, str, obj);
8654 _rewriteListenStmt(BaseSelect, message, dblink, str, obj);
8657 case T_UnlistenStmt:
8658 _rewriteUnlistenStmt(BaseSelect, message, dblink, str, obj);
8662 _rewriteLoadStmt(BaseSelect, message, dblink, str, obj);
8666 _rewriteCopyStmt(BaseSelect, message, dblink, str, obj);
8669 case T_DeallocateStmt:
8670 _rewriteDeallocateStmt(BaseSelect, message, dblink, str, obj);
8674 _rewriteRenameStmt(BaseSelect, message, dblink, str, obj);
8677 case T_CreateRoleStmt:
8678 _rewriteCreateRoleStmt(BaseSelect, message, dblink, str, obj);
8681 case T_AlterRoleStmt:
8682 _rewriteAlterRoleStmt(BaseSelect, message, dblink, str, obj);
8685 case T_AlterRoleSetStmt:
8686 _rewriteAlterRoleSetStmt(BaseSelect, message, dblink, str, obj);
8689 case T_DropRoleStmt:
8690 _rewriteDropRoleStmt(BaseSelect, message, dblink, str, obj);
8693 case T_CreateSchemaStmt:
8694 _rewriteCreateSchemaStmt(BaseSelect, message, dblink, str, obj);
8697 case T_VariableSetStmt:
8698 _rewriteVariableSetStmt(BaseSelect, message, dblink, str, obj);
8701 case T_VariableShowStmt:
8702 _rewriteVariableShowStmt(BaseSelect, message, dblink, str, obj);
8705 case T_ConstraintsSetStmt:
8706 _rewriteConstraintsSetStmt(BaseSelect, message, dblink, str, obj);
8709 case T_AlterTableStmt:
8710 _rewriteAlterTableStmt(BaseSelect, message, dblink, str, obj);
8713 case T_AlterTableCmd:
8714 _rewriteAlterTableCmd(BaseSelect, message, dblink, str, obj);
8717 case T_CreateSeqStmt:
8718 _rewriteCreateSeqStmt(BaseSelect, message, dblink, str, obj);
8721 case T_AlterSeqStmt:
8722 _rewriteAlterSeqStmt(BaseSelect, message, dblink, str, obj);
8725 case T_CreatePLangStmt:
8726 _rewriteCreatePLangStmt(BaseSelect, message, dblink, str, obj);
8729 case T_DropPLangStmt:
8730 _rewriteDropPLangStmt(BaseSelect, message, dblink, str, obj);
8733 case T_CreateTableSpaceStmt:
8734 _rewriteCreateTableSpaceStmt(BaseSelect, message, dblink, str, obj);
8737 case T_DropTableSpaceStmt:
8738 _rewriteDropTableSpaceStmt(BaseSelect, message, dblink, str, obj);
8741 case T_CreateTrigStmt:
8742 _rewriteCreateTrigStmt(BaseSelect, message, dblink, str, obj);
8745 case T_DropPropertyStmt:
8746 _rewriteDropPropertyStmt(BaseSelect, message, dblink, str, obj);
8750 _rewriteDefineStmt(BaseSelect, message, dblink, str, obj);
8753 case T_CreateOpClassStmt:
8754 _rewriteCreateOpClassStmt(BaseSelect, message, dblink, str, obj);
8757 case T_CreateOpClassItem:
8758 _rewriteCreateOpClassItem(BaseSelect, message, dblink, str, obj);
8761 case T_RemoveOpClassStmt:
8762 _rewriteRemoveOpClassStmt(BaseSelect, message, dblink, str, obj);
8766 _rewriteDropStmt(BaseSelect, message, dblink, str, obj);
8770 _rewriteFetchStmt(BaseSelect, message, dblink, str, obj);
8774 _rewriteGrantStmt(BaseSelect, message, dblink, str, obj);
8778 _rewritePrivTarget(BaseSelect, message, dblink, str, obj);
8781 case T_FuncWithArgs:
8782 _rewriteFuncWithArgs(BaseSelect, message, dblink, str, obj);
8785 case T_FunctionParameter:
8786 _rewriteFunctionParameter(BaseSelect, message, dblink, str, obj);
8790 _rewritePrivGrantee(BaseSelect, message, dblink, str, obj);
8793 case T_GrantRoleStmt:
8794 _rewriteGrantRoleStmt(BaseSelect, message, dblink, str, obj);
8797 case T_CreateFunctionStmt:
8798 _rewriteCreateFunctionStmt(BaseSelect, message, dblink, str, obj);
8801 case T_AlterFunctionStmt:
8802 _rewriteAlterFunctionStmt(BaseSelect, message, dblink, str, obj);
8805 case T_RemoveFuncStmt:
8806 _rewriteRemoveFuncStmt(BaseSelect, message, dblink, str, obj);
8809 case T_CreateCastStmt:
8810 _rewriteCreateCastStmt(BaseSelect, message, dblink, str, obj);
8813 case T_DropCastStmt:
8814 _rewriteDropCastStmt(BaseSelect, message, dblink, str, obj);
8818 _rewriteReindexStmt(BaseSelect, message, dblink, str, obj);
8821 case T_AlterObjectSchemaStmt:
8822 _rewriteAlterObjectSchemaStmt(BaseSelect, message, dblink, str, obj);
8825 case T_AlterOwnerStmt:
8826 _rewriteAlterOwnerStmt(BaseSelect, message, dblink, str, obj);
8830 _rewriteRuleStmt(BaseSelect, message, dblink, str, obj);
8834 _rewriteViewStmt(BaseSelect, message, dblink, str, obj);
8837 case T_CreatedbStmt:
8838 _rewriteCreatedbStmt(BaseSelect, message, dblink, str, obj);
8841 case T_AlterDatabaseStmt:
8842 _rewriteAlterDatabaseStmt(BaseSelect, message, dblink, str, obj);
8846 case T_AlterDatabaseSetStmt:
8847 _rewriteAlterDatabaseSetStmt(BaseSelect, message, dblink, str, obj);
8851 _rewriteDropdbStmt(BaseSelect, message, dblink, str, obj);
8854 case T_CreateDomainStmt:
8855 _rewriteCreateDomainStmt(BaseSelect, message, dblink, str, obj);
8858 case T_AlterDomainStmt:
8859 _rewriteAlterDomainStmt(BaseSelect, message, dblink, str, obj);
8862 case T_CreateConversionStmt:
8863 _rewriteCreateConversionStmt(BaseSelect, message, dblink, str, obj);
8867 _rewritePrepareStmt(BaseSelect, message, dblink, str, obj);
8871 _rewriteExecuteStmt(BaseSelect, message, dblink, str, obj);
8875 _rewriteLockStmt(BaseSelect, message, dblink, str, obj);
8879 _rewriteCommentStmt(BaseSelect, message, dblink, str, obj);
8882 case T_RangeSubselect:
8883 _rewriteRangeSubselect(BaseSelect, message, dblink, str, obj);
8886 case T_RangeFunction:
8887 _rewriteRangeFunction(BaseSelect, message, dblink, str, obj);
8890 case T_CurrentOfExpr:
8891 _rewriteCurrentOfExpr(BaseSelect, message, dblink, str, obj);
8895 case T_CreateOpFamilyStmt:
8896 case T_AlterOpFamilyStmt:
8897 case T_RemoveOpFamilyStmt:
8898 case T_CreateEnumStmt:
8899 case T_DropOwnedStmt:
8900 case T_ReassignOwnedStmt:
8901 case T_AlterTSDictionaryStmt:
8902 case T_AlterTSConfigurationStmt:
8903 case T_XmlSerialize:
8908 KeepRewriteQueryCode(message, SELECT_RELATION_ERROR);
8917 * returns the ascii representation of the Node as a palloc'd string
8920 nodeToRewriteString(RewriteQuery *message, ConInfoTodblink *dblink, void *obj)
8924 str = init_string("");
8925 message->analyze_num = 0;
8926 _rewriteNode(NULL, message, dblink, str, obj);
8927 message->rewrite_query = str->data;