/* ------------------------------------------------------------------------- * * parse_expr.cpp * handle expressions in parser * * Portions Copyright (c) 1996-2012, PostgreSQL Global Development Group * Portions Copyright (c) 1994, Regents of the University of California * Portions Copyright (c) 2021, openGauss Contributors * * * IDENTIFICATION * src/commmon/backend/parser/parse_expr.cpp * * ------------------------------------------------------------------------- */ #include "postgres.h" #include "knl/knl_variable.h" #include "catalog/pg_type.h" #include "catalog/pg_proc.h" #include "catalog/gs_package.h" #include "commands/dbcommands.h" #include "commands/sequence.h" #include "db4ai/predict_by.h" #include "executor/node/nodeCtescan.h" #include "foreign/foreign.h" #include "miscadmin.h" #include "nodes/makefuncs.h" #include "nodes/nodeFuncs.h" #include "optimizer/clauses.h" #include "optimizer/var.h" #include "optimizer/planner.h" #include "parser/analyze.h" #include "parser/parser.h" #include "parser/parse_coerce.h" #include "parser/parse_collate.h" #include "parser/parse_expr.h" #include "parser/parse_func.h" #include "parser/parse_oper.h" #include "parser/parse_relation.h" #include "parser/parse_target.h" #include "parser/parse_type.h" #include "parser/parse_agg.h" #include "rewrite/rewriteManip.h" #include "utils/builtins.h" #include "utils/lsyscache.h" #include "utils/plpgsql.h" #include "utils/xml.h" #include "funcapi.h" #include "utils/guc.h" #include "utils/guc_tables.h" extern Node* build_column_default(Relation rel, int attrno, bool isInsertCmd = false, bool needOnUpdate = false); extern Node* makeAConst(Value* v, int location); extern Value* makeStringValue(char* str); static Node* transformParamRef(ParseState* pstate, ParamRef* pref); static Node* transformAExprOp(ParseState* pstate, A_Expr* a); static Node* transformAExprAnd(ParseState* pstate, A_Expr* a); static Node* transformAExprOr(ParseState* pstate, A_Expr* a); static Node* transformAExprNot(ParseState* pstate, A_Expr* a); static Node* transformAExprOpAny(ParseState* pstate, A_Expr* a); static Node* transformAExprOpAll(ParseState* pstate, A_Expr* a); static Node* transformAExprDistinct(ParseState* pstate, A_Expr* a); static Node* transformAExprNullIf(ParseState* pstate, A_Expr* a); static Node* transformAExprOf(ParseState* pstate, A_Expr* a); static Node* transformAExprIn(ParseState* pstate, A_Expr* a); static Node* transformUserSetElem(ParseState* pstate, UserSetElem *elem); static Node* transformUserVar(UserVar *uservar); static Node* transformFuncCall(ParseState* pstate, FuncCall* fn); static Node* transformCaseExpr(ParseState* pstate, CaseExpr* c); static Node* transformSubLink(ParseState* pstate, SubLink* sublink); static Node* transformSelectIntoVarList(ParseState* pstate, SelectIntoVarList* sis); static Node* transformArrayExpr(ParseState* pstate, A_ArrayExpr* a, Oid array_type, Oid element_type, int32 typmod); static Node* transformRowExpr(ParseState* pstate, RowExpr* r); static Node* transformCoalesceExpr(ParseState* pstate, CoalesceExpr* c); static Node* transformMinMaxExpr(ParseState* pstate, MinMaxExpr* m); static Node* transformXmlExpr(ParseState* pstate, XmlExpr* x); static Node* transformXmlSerialize(ParseState* pstate, XmlSerialize* xs); static Node* transformBooleanTest(ParseState* pstate, BooleanTest* b); static Node* transformCurrentOfExpr(ParseState* pstate, CurrentOfExpr* cexpr); static Node* transformPredictByFunction(ParseState* pstate, PredictByFunction* cexpr); static Node* transformWholeRowRef(ParseState* pstate, RangeTblEntry* rte, int location); static Node* transformIndirection(ParseState* pstate, Node* basenode, List* indirection); static Node* transformTypeCast(ParseState* pstate, TypeCast* tc); static Node* transformCollateClause(ParseState* pstate, CollateClause* c); static Node* make_row_comparison_op(ParseState* pstate, List* opname, List* largs, List* rargs, int location); static Node* make_row_distinct_op(ParseState* pstate, List* opname, RowExpr* lrow, RowExpr* rrow, int location); static Node* convertStarToCRef(RangeTblEntry* rte, char* catname, char* nspname, char* relname, int location); static bool IsSequenceFuncCall(Node* filed1, Node* filed2, Node* filed3); static Node* transformSequenceFuncCall(ParseState* pstate, Node* field1, Node* field2, Node* field3, int location); static Node* transformConnectByRootFuncCall(ParseState* pstate, Node* funcNameVal, ColumnRef *cref); static char *ColumnRefFindRelname(ParseState *pstate, const char *colname); static Node *transformStartWithColumnRef(ParseState *pstate, ColumnRef *cref, char **colname); static Node* tryTransformFunc(ParseState* pstate, List* fields, int location); static void SubCheckOutParam(List* exprtargs, Oid funcid); static Node* transformPrefixKey(ParseState* pstate, PrefixKey* pkey); #define OrientedIsCOLorPAX(rte) ((rte)->orientation == REL_COL_ORIENTED || (rte)->orientation == REL_PAX_ORIENTED) #define INDEX_KEY_MAX_PREFIX_LENGTH (int)2676 static inline bool IsAutoIncrementColumn(TupleDesc rdAtt, int attrNo) { return rdAtt->constr && rdAtt->constr->cons_autoinc && rdAtt->constr->cons_autoinc->attnum == attrNo; } static void AddDefaultExprNode(ParseState* pstate) { RightRefState* refState = pstate->rightRefState; if (refState->isInsertHasRightRef) { return; } pstate->rightRefState->isInsertHasRightRef = true; Relation relation = (Relation)linitial(pstate->p_target_relation); TupleDesc rdAtt = relation->rd_att; int fieldCnt = rdAtt->natts; refState->constValues = (Const**)palloc0(sizeof(Const) * fieldCnt); for (int i = 0; i < fieldCnt; ++i) { Form_pg_attribute attTup = rdAtt->attrs[i]; if (IsAutoIncrementColumn(rdAtt, i + 1)) { refState->constValues[i] = makeConst(attTup->atttypid, -1, attTup->attcollation, attTup->attlen, (Datum)0, false, attTup->attbyval); } else if (ISGENERATEDCOL(rdAtt, i)) { refState->constValues[i] = nullptr; } else { Node* expr = build_column_default(relation, i + 1, true); if (expr && IsA(expr, Const)) { refState->constValues[i] = (Const*)expr; } else { refState->constValues[i] = nullptr; } } } } /* * transformExpr - * Analyze and transform expressions. Type checking and type casting is * done here. The optimizer and the executor cannot handle the original * (raw) expressions collected by the parse tree. Hence the transformation * here. * * NOTE: there are various cases in which this routine will get applied to * an already-transformed expression. Some examples: * 1. At least one construct (BETWEEN/AND) puts the same nodes * into two branches of the parse tree; hence, some nodes * are transformed twice. * 2. Another way it can happen is that coercion of an operator or * function argument to the required type (via coerce_type()) * can apply transformExpr to an already-transformed subexpression. * An example here is "SELECT count(*) + 1.0 FROM table". * 3. CREATE TABLE t1 (LIKE t2 INCLUDING INDEXES) can pass in * already-transformed index expressions. * While it might be possible to eliminate these cases, the path of * least resistance so far has been to ensure that transformExpr() does * no damage if applied to an already-transformed tree. This is pretty * easy for cases where the transformation replaces one node type with * another, such as A_Const => Const; we just do nothing when handed * a Const. More care is needed for node types that are used as both * input and output of transformExpr; see SubLink for example. */ Node* transformExpr(ParseState* pstate, Node* expr) { Node* result = NULL; if (expr == NULL) { return NULL; } /* Guard against stack overflow due to overly complex expressions */ check_stack_depth(); switch (nodeTag(expr)) { case T_ColumnRef: result = transformColumnRef(pstate, (ColumnRef*)expr); if (IS_SUPPORT_RIGHT_REF(pstate->rightRefState)) { if (pstate->rightRefState->isUpsert) { pstate->rightRefState->isUpsertHasRightRef = true; } else { AddDefaultExprNode(pstate); } } break; case T_ParamRef: result = transformParamRef(pstate, (ParamRef*)expr); break; case T_A_Const: { A_Const* con = (A_Const*)expr; Value* val = &con->val; result = (Node*)make_const(pstate, val, con->location); break; } case T_A_Indirection: { A_Indirection* ind = (A_Indirection*)expr; result = transformExpr(pstate, ind->arg); result = transformIndirection(pstate, result, ind->indirection); break; } case T_A_ArrayExpr: result = transformArrayExpr(pstate, (A_ArrayExpr*)expr, InvalidOid, InvalidOid, -1); break; case T_TypeCast: { TypeCast* tc = (TypeCast*)expr; /* * If the subject of the typecast is an ARRAY[] construct and * the target type is an array type, we invoke * transformArrayExpr() directly so that we can pass down the * type information. This avoids some cases where * transformArrayExpr() might not infer the correct type. */ if (IsA(tc->arg, A_ArrayExpr)) { Oid targetType; Oid elementType; int32 targetTypmod; typenameTypeIdAndMod(pstate, tc->typname, &targetType, &targetTypmod); /* * If target is a domain over array, work with the base * array type here. transformTypeCast below will cast the * array type to the domain. In the usual case that the * target is not a domain, transformTypeCast is a no-op. */ targetType = getBaseTypeAndTypmod(targetType, &targetTypmod); elementType = get_element_type(targetType); if (OidIsValid(elementType)) { tc = (TypeCast*)copyObject(tc); tc->arg = transformArrayExpr(pstate, (A_ArrayExpr*)tc->arg, targetType, elementType, targetTypmod); } } result = transformTypeCast(pstate, tc); break; } case T_CollateClause: result = transformCollateClause(pstate, (CollateClause*)expr); break; case T_A_Expr: { A_Expr* a = (A_Expr*)expr; switch (a->kind) { case AEXPR_OP: result = transformAExprOp(pstate, a); break; case AEXPR_AND: result = transformAExprAnd(pstate, a); break; case AEXPR_OR: result = transformAExprOr(pstate, a); break; case AEXPR_NOT: result = transformAExprNot(pstate, a); break; case AEXPR_OP_ANY: result = transformAExprOpAny(pstate, a); break; case AEXPR_OP_ALL: result = transformAExprOpAll(pstate, a); break; case AEXPR_DISTINCT: result = transformAExprDistinct(pstate, a); break; case AEXPR_NULLIF: result = transformAExprNullIf(pstate, a); break; case AEXPR_OF: result = transformAExprOf(pstate, a); break; case AEXPR_IN: result = transformAExprIn(pstate, a); break; default: ereport(ERROR, (errcode(ERRCODE_UNRECOGNIZED_NODE_TYPE), errmsg("unrecognized A_Expr kind: %d", a->kind))); } break; } case T_UserSetElem: { result = transformUserSetElem(pstate, (UserSetElem *)expr); break; } case T_UserVar: { result = transformUserVar((UserVar *)expr); break; } case T_FuncCall: result = transformFuncCall(pstate, (FuncCall*)expr); break; case T_NamedArgExpr: { NamedArgExpr* na = (NamedArgExpr*)expr; na->arg = (Expr*)transformExpr(pstate, (Node*)na->arg); result = expr; break; } case T_SubLink: result = transformSubLink(pstate, (SubLink*)expr); break; case T_SelectIntoVarList: result = transformSelectIntoVarList(pstate, (SelectIntoVarList*)expr); break; case T_CaseExpr: result = transformCaseExpr(pstate, (CaseExpr*)expr); break; case T_RowExpr: result = transformRowExpr(pstate, (RowExpr*)expr); break; case T_CoalesceExpr: result = transformCoalesceExpr(pstate, (CoalesceExpr*)expr); break; case T_MinMaxExpr: result = transformMinMaxExpr(pstate, (MinMaxExpr*)expr); break; case T_GroupingFunc: result = transformGroupingFunc(pstate, (GroupingFunc*)expr); break; case T_XmlExpr: result = transformXmlExpr(pstate, (XmlExpr*)expr); break; case T_XmlSerialize: result = transformXmlSerialize(pstate, (XmlSerialize*)expr); break; case T_NullTest: { NullTest* n = (NullTest*)expr; n->arg = (Expr*)transformExpr(pstate, (Node*)n->arg); /* the argument can be any type, so don't coerce it */ n->argisrow = type_is_rowtype(exprType((Node*)n->arg)); result = expr; break; } case T_BooleanTest: result = transformBooleanTest(pstate, (BooleanTest*)expr); break; case T_CurrentOfExpr: result = transformCurrentOfExpr(pstate, (CurrentOfExpr*)expr); break; case T_PredictByFunction: result = transformPredictByFunction(pstate, (PredictByFunction*) expr); break; case T_PrefixKey: result = transformPrefixKey(pstate, (PrefixKey*)expr); break; case T_SetVariableExpr: result = transformSetVariableExpr((SetVariableExpr*)expr); break; /********************************************* * Quietly accept node types that may be presented when we are * called on an already-transformed tree. * * Do any other node types need to be accepted? For now we are * taking a conservative approach, and only accepting node * types that are demonstrably necessary to accept. *********************************************/ case T_Var: case T_Const: case T_Param: case T_Aggref: case T_WindowFunc: case T_ArrayRef: case T_FuncExpr: case T_Rownum: case T_OpExpr: case T_DistinctExpr: case T_NullIfExpr: case T_ScalarArrayOpExpr: case T_BoolExpr: case T_FieldSelect: case T_FieldStore: case T_RelabelType: case T_CoerceViaIO: case T_ArrayCoerceExpr: case T_ConvertRowtypeExpr: case T_CollateExpr: case T_CaseTestExpr: case T_ArrayExpr: case T_CoerceToDomain: case T_CoerceToDomainValue: case T_SetToDefault: { result = (Node*)expr; break; } default: /* should not reach here */ ereport(ERROR, (errcode(ERRCODE_UNRECOGNIZED_NODE_TYPE), errmsg("unrecognized node type: %d", (int)nodeTag(expr)))); break; } return result; } /* * helper routine for delivering "column does not exist" error message * * (Usually we don't have to work this hard, but the general case of field * selection from an arbitrary node needs it.) */ static void unknown_attribute(ParseState* pstate, Node* relref, char* attname, int location) { RangeTblEntry* rte = NULL; if (IsA(relref, Var) && ((Var*)relref)->varattno == InvalidAttrNumber) { /* Reference the RTE by alias not by actual table name */ rte = GetRTEByRangeTablePosn(pstate, ((Var*)relref)->varno, ((Var*)relref)->varlevelsup); ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("column %s.%s does not exist", rte->eref->aliasname, attname), parser_errposition(pstate, location))); } else { /* Have to do it by reference to the type of the expression */ Oid relTypeId = exprType(relref); if (ISCOMPLEX(relTypeId)) { ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("column \"%s\" not found in data type %s", attname, format_type_be(relTypeId)), parser_errposition(pstate, location))); } else if (relTypeId == RECORDOID) { ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("could not identify column \"%s\" in record data type", attname), parser_errposition(pstate, location))); } else { ereport(ERROR, (errcode(ERRCODE_WRONG_OBJECT_TYPE), errmsg("column notation .%s applied to type %s, " "which is not a composite type", attname, format_type_be(relTypeId)), parser_errposition(pstate, location))); } } } static Node* transformIndirection(ParseState* pstate, Node* basenode, List* indirection) { Node* result = basenode; List* subscripts = NIL; int location = exprLocation(basenode); ListCell* i = NULL; /* * We have to split any field-selection operations apart from * subscripting. Adjacent A_Indices nodes have to be treated as a single * multidimensional subscript operation. */ foreach (i, indirection) { Node* n = (Node*)lfirst(i); if (IsA(n, A_Indices)) { subscripts = lappend(subscripts, n); } else if (IsA(n, A_Star)) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("row expansion via \"*\" is not supported here"), parser_errposition(pstate, location))); } else { Node* newresult = NULL; AssertEreport(IsA(n, String), MOD_OPT, ""); /* process subscripts before this field selection */ if (subscripts != NIL) { result = (Node*)transformArraySubscripts( pstate, result, exprType(result), InvalidOid, exprTypmod(result), subscripts, NULL); } subscripts = NIL; newresult = ParseFuncOrColumn(pstate, list_make1(n), list_make1(result), NULL, location); if (newresult == NULL) { unknown_attribute(pstate, result, strVal(n), location); } result = newresult; } } /* process trailing subscripts, if any */ if (subscripts != NIL) { result = (Node*)transformArraySubscripts( pstate, result, exprType(result), InvalidOid, exprTypmod(result), subscripts, NULL); } return result; } static Node* replaceExprAliasIfNecessary(ParseState* pstate, char* colname, ColumnRef* cref) { ListCell* lc = NULL; bool isFind = false; Expr* matchExpr = NULL; TargetEntry* tle = NULL; foreach (lc, pstate->p_target_list) { tle = (TargetEntry*)lfirst(lc); /* * 1. in a select stmt in stored procudre, a columnref may be a param(e.g. a declared var or the stored * procedure's arg), which is not a alias, so can not be matched here. * 2. in a select stmt in stored procudre such like a[1],a[2],a[3], they have same name, * so, we should pass this target. */ bool isArrayParam = IsA(tle->expr, ArrayRef) && ((ArrayRef*)tle->expr)->refexpr != NULL && IsA(((ArrayRef*)tle->expr)->refexpr, Param); if (tle->resname != NULL && !IsA(tle->expr, Param) && !isArrayParam && strncmp(tle->resname, colname, strlen(colname) + 1) == 0) { if (checkExprHasWindowFuncs((Node*)tle->expr)) { ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("Alias \"%s\" reference with window function included is not supported.", colname), parser_errposition(pstate, cref->location))); #ifndef ENABLE_MULTIPLE_NODES } else if (ContainRownumExpr((Node*)tle->expr)) { ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("Alias \"%s\" reference with ROWNUM included is invalid.", colname), parser_errposition(pstate, cref->location))); #endif } else if (contain_volatile_functions((Node*)tle->expr)) { ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("Alias \"%s\" reference with volatile function included is not supported.", colname), parser_errposition(pstate, cref->location))); } else { if (!isFind) { matchExpr = tle->expr; isFind = true; } else { ereport(ERROR, (errcode(ERRCODE_UNDEFINED_COLUMN), errmsg("Alias \"%s\" is ambiguous.", colname), parser_errposition(pstate, cref->location))); return NULL; } } } } return (Node*)copyObject(matchExpr); } static Node* ParseColumnRef(ParseState* pstate, RangeTblEntry* rte, char* colname, ColumnRef* cref) { Node* node = NULL; /* Try to identify as a column of the RTE */ node = scanRTEForColumn(pstate, rte, colname, cref->location); if (node == NULL) { /* Try it as a function call on the whole row */ node = transformWholeRowRef(pstate, rte, cref->location); node = ParseFuncOrColumn(pstate, list_make1(makeString(colname)), list_make1(node), NULL, cref->location); } return node; } static ColumnRef *fixSWNameSubLevel(RangeTblEntry *rte, char *rname, char **colname) { ListCell *lc = NULL; foreach(lc, rte->eref->colnames) { Value *val = (Value *)lfirst(lc); if (strstr(strVal(val), *colname)) { *colname = pstrdup(strVal(val)); break; } } ColumnRef* c = makeNode(ColumnRef); c->fields = list_make2((Node*)makeString(rname), (Node*)makeString(*colname)); c->location = -1; return c; } /* * Transform a ColumnRef. * * If you find yourself changing this code, see also ExpandColumnRefStar. */ Node* transformColumnRef(ParseState* pstate, ColumnRef* cref) { Node* node = NULL; char* nspname = NULL; char* relname = NULL; char* colname = NULL; RangeTblEntry* rte = NULL; int levels_up; bool hasplus = false; enum { CRERR_NO_COLUMN, CRERR_NO_RTE, CRERR_WRONG_DB, CRERR_TOO_MANY } crerr = CRERR_NO_COLUMN; /* * Give the PreParseColumnRefHook, if any, first shot. If it returns * non-null then that's all, folks. */ if (pstate->p_pre_columnref_hook != NULL) { node = (*pstate->p_pre_columnref_hook)(pstate, cref); if (node != NULL) { return node; } } /* * First to check if last cref->fields is "(+)" we have to evaluate the previous * elements can costructe a */ int fields_len = list_length(cref->fields); hasplus = IsColumnRefPlusOuterJoin(cref); if (hasplus) { /* * Report error when found operator "(+)" and ignoreplus is false. * Actually we only set ignoreplus be true in WhereClause of Select Satatement for now. */ if (!pstate->ignoreplus) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("Operator \"(+)\" can only be used in WhereClause of Select-Statement or Subquery."), parser_errposition(pstate, cref->location))); } /* If identify it is a "(+)" we need minus the length first */ fields_len--; } /* ---------- * The allowed syntaxes are: * * A First try to resolve as unqualified column name; * if no luck, try to resolve as unqualified table name (A.*). * A.B A is an unqualified table name; B is either a * column or function name (trying column name first). * A.B.C schema A, table B, col or func name C. * A.B.C.D catalog A, schema B, table C, col or func D. * A.* A is an unqualified table name; means whole-row value. * A.B.* whole-row value of table B in schema A. * A.B.C.* whole-row value of table C in schema B in catalog A. * * We do not need to cope with bare "*"; that will only be accepted by * the grammar at the top level of a SELECT list, and transformTargetList * will take care of it before it ever gets here. Also, "A.*" etc will * be expanded by transformTargetList if they appear at SELECT top level, * so here we are only going to see them as function or operator inputs. * * Currently, if a catalog name is given then it must equal the current * database name; we check it here and then discard it. * ---------- */ switch (fields_len) { case 1: { Node* field1 = (Node*)linitial(cref->fields); AssertEreport(IsA(field1, String), MOD_OPT, ""); colname = strVal(field1); if (pstate->p_hasStartWith) { Node *expr = transformStartWithColumnRef(pstate, cref, &colname); /* function case, return directly */ if (expr != NULL) { return expr; } } /* * Try to identify as an unqualified column * * if hasplus, only consider current pstate level */ node = colNameToVar(pstate, colname, hasplus, cref->location, &rte); if (hasplus && node == NULL) { ereport(ERROR, (errcode(ERRCODE_AMBIGUOUS_COLUMN), errmsg("column reference \"%s\" is ambiguous.", colname), errhint("\"%s\" with \"(+)\" can only reference relation in current query level.", colname), parser_errposition(pstate, cref->location))); } if (node == NULL) { /* * Not known as a column of any range-table entry. * * Consider the possibility that it's VALUE in a domain * check expression. (We handle VALUE as a name, not a * keyword, to avoid breaking a lot of applications that * have used VALUE as a column name in the past.) */ if (pstate->p_value_substitute != NULL && strcmp(colname, "value") == 0) { node = (Node*)copyObject(pstate->p_value_substitute); /* * Try to propagate location knowledge. This should * be extended if p_value_substitute can ever take on * other node types. */ if (IsA(node, CoerceToDomainValue)) { ((CoerceToDomainValue*)node)->location = cref->location; } break; } /* * Try to find the name as a relation. Note that only * relations already entered into the rangetable will be * recognized. * * This is a hack for backwards compatibility with * PostQUEL-inspired syntax. The preferred form now is * "rel.*". */ rte = refnameRangeTblEntry(pstate, NULL, colname, cref->location, &levels_up); if (rte != NULL) { if ((OrientedIsCOLorPAX(rte) || RelIsSpecifiedFTbl(rte, HDFS) || RelIsSpecifiedFTbl(rte, OBS)) && ((rte->alias && (strcmp(rte->alias->aliasname, colname) == 0)) || (strcmp(rte->relname, colname) == 0))) { Node* row_expr = convertStarToCRef(rte, NULL, NULL, colname, cref->location); node = transformExpr(pstate, row_expr); } else { node = transformWholeRowRef(pstate, rte, cref->location); } break; } /*expr of target_list replace of node*/ node = replaceExprAliasIfNecessary(pstate, colname, cref); if (!pstate->isAliasReplace && contain_subplans(node)) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg( "Alias \"%s\" contains subplan, which is not supported to use in grouping() function", colname))); } /* * Now give the p_bind_variable_columnref_hook, check column index. only DBE_SQL can get here. */ if (node == NULL) { if (pstate->p_bind_variable_columnref_hook != NULL) { node = (*pstate->p_bind_variable_columnref_hook)(pstate, cref); if (node != NULL) { return node; } } if (pstate->p_bind_describe_hook != NULL) { node = (*pstate->p_bind_describe_hook)(pstate, cref); return node; } } } break; } case 2: { Node* field1 = (Node*)linitial(cref->fields); Node* field2 = (Node*)lsecond(cref->fields); AssertEreport(IsA(field1, String), MOD_OPT, ""); relname = strVal(field1); /* Locate the referenced RTE */ if (hasplus) { rte = refnameRangeTblEntry(pstate, nspname, relname, cref->location, NULL); } else { rte = refnameRangeTblEntry(pstate, nspname, relname, cref->location, &levels_up); } /* check if it's sequence function call, like: sequence1.nextval */ if (rte == NULL && IsSequenceFuncCall(NULL, field1, field2)) { return transformSequenceFuncCall(pstate, NULL, field1, field2, cref->location); } else if (rte == NULL) { crerr = CRERR_NO_RTE; break; } /* Whole-row reference? */ if (IsA(field2, A_Star)) { if (OrientedIsCOLorPAX(rte) || RelIsSpecifiedFTbl(rte, HDFS) || RelIsSpecifiedFTbl(rte, OBS)) { Node* row_expr = convertStarToCRef(rte, NULL, NULL, relname, cref->location); node = transformExpr(pstate, row_expr); } else { node = transformWholeRowRef(pstate, rte, cref->location); } break; } AssertEreport(IsA(field2, String), MOD_OPT, ""); colname = strVal(field2); if (rte->rtekind == RTE_SUBQUERY && rte->swSubExist) { cref = fixSWNameSubLevel(rte, relname, &colname); } if (pstate->p_hasStartWith || rte->swConverted) { Node *expr = transformStartWithColumnRef(pstate, cref, &colname); /* function case, return directly */ if (expr != NULL) { return expr; } if (strstr(colname, "@")) { ListCell *lc = NULL; foreach(lc, pstate->p_rtable) { RangeTblEntry *tbl = (RangeTblEntry *)lfirst(lc); if (tbl->relname != NULL && strcmp(tbl->relname, "tmp_reuslt") == 0) { rte = tbl; break; } } } } node = ParseColumnRef(pstate, rte, colname, cref); break; } case 3: { Node* field1 = (Node*)linitial(cref->fields); Node* field2 = (Node*)lsecond(cref->fields); Node* field3 = (Node*)lthird(cref->fields); AssertEreport(IsA(field1, String), MOD_OPT, ""); nspname = strVal(field1); AssertEreport(IsA(field2, String), MOD_OPT, ""); relname = strVal(field2); /* Locate the referenced RTE */ if (hasplus) { rte = refnameRangeTblEntry(pstate, nspname, relname, cref->location, NULL); } else { rte = refnameRangeTblEntry(pstate, nspname, relname, cref->location, &levels_up); } /* check if it's sequence function call, like: nsp.sequence.nextval */ if (rte == NULL && IsSequenceFuncCall(field1, field2, field3)) { return transformSequenceFuncCall(pstate, field1, field2, field3, cref->location); } else if (rte == NULL) { crerr = CRERR_NO_RTE; break; } /* Whole-row reference? */ if (IsA(field3, A_Star)) { if (OrientedIsCOLorPAX(rte) || RelIsSpecifiedFTbl(rte, HDFS) || RelIsSpecifiedFTbl(rte, OBS)) { Node* row_expr = convertStarToCRef(rte, NULL, nspname, relname, cref->location); node = transformExpr(pstate, row_expr); } else { node = transformWholeRowRef(pstate, rte, cref->location); } break; } AssertEreport(IsA(field3, String), MOD_OPT, ""); colname = strVal(field3); node = ParseColumnRef(pstate, rte, colname, cref); break; } case 4: { Node* field1 = (Node*)linitial(cref->fields); Node* field2 = (Node*)lsecond(cref->fields); Node* field3 = (Node*)lthird(cref->fields); Node* field4 = (Node*)lfourth(cref->fields); char* catname = NULL; AssertEreport(IsA(field1, String), MOD_OPT, ""); catname = strVal(field1); AssertEreport(IsA(field2, String), MOD_OPT, ""); nspname = strVal(field2); AssertEreport(IsA(field3, String), MOD_OPT, ""); relname = strVal(field3); /* * We check the catalog name and then ignore it. */ if (strcmp(catname, get_and_check_db_name(u_sess->proc_cxt.MyDatabaseId, true)) != 0) { crerr = CRERR_WRONG_DB; break; } /* Locate the referenced RTE */ if (hasplus) { rte = refnameRangeTblEntry(pstate, nspname, relname, cref->location, NULL); } else { rte = refnameRangeTblEntry(pstate, nspname, relname, cref->location, &levels_up); } /* check if it's sequence function call, like: nsp.sequence.nextval */ if (rte == NULL && IsSequenceFuncCall(field2, field3, field4)) { return transformSequenceFuncCall(pstate, field2, field3, field4, cref->location); } else if (rte == NULL) { crerr = CRERR_NO_RTE; break; } /* Whole-row reference? */ if (IsA(field4, A_Star)) { if (OrientedIsCOLorPAX(rte) || RelIsSpecifiedFTbl(rte, HDFS) || RelIsSpecifiedFTbl(rte, OBS)) { Node* row_expr = convertStarToCRef(rte, catname, nspname, relname, cref->location); node = transformExpr(pstate, row_expr); } else { node = transformWholeRowRef(pstate, rte, cref->location); } break; } AssertEreport(IsA(field4, String), MOD_OPT, ""); colname = strVal(field4); node = ParseColumnRef(pstate, rte, colname, cref); break; } default: crerr = CRERR_TOO_MANY; /* too many dotted names */ break; } /* * Now give the PostParseColumnRefHook, if any, a chance. We pass the * translation-so-far so that it can throw an error if it wishes in the * case that it has a conflicting interpretation of the ColumnRef. (If it * just translates anyway, we'll throw an error, because we can't undo * whatever effects the preceding steps may have had on the pstate.) If it * returns NULL, use the standard translation, or throw a suitable error * if there is none. */ if (pstate->p_post_columnref_hook != NULL) { Node* hookresult = NULL; /* * if node is not a table column, we should pass a null to the hook, * or it will misjudge the columnref as ambiguous. */ hookresult = (*pstate->p_post_columnref_hook)(pstate, cref, node); if (node == NULL) { node = hookresult; } else if (hookresult != NULL) { if (IS_SUPPORT_RIGHT_REF(pstate->rightRefState)) { node = hookresult; } else { ereport(ERROR, (errcode(ERRCODE_AMBIGUOUS_COLUMN), errmsg("column reference \"%s\" is ambiguous", NameListToString(cref->fields)), parser_errposition(pstate, cref->location))); } } } if (node == NULL && u_sess->attr.attr_sql.sql_compatibility == A_FORMAT) { node = tryTransformFunc(pstate, cref->fields, cref->location); if (node) { return node; } } /* check current column match request index or not, use value in func in A_FORMAT */ if (u_sess->attr.attr_sql.sql_compatibility == A_FORMAT) { Node* check = plpgsql_check_match_var(node, pstate, cref); if (check) { return check; } } /* * Throw error if no translation found. */ if (node == NULL) { switch (crerr) { case CRERR_NO_COLUMN: errorMissingColumn(pstate, relname, colname, cref->location); break; case CRERR_NO_RTE: errorMissingRTE(pstate, makeRangeVar(nspname, relname, cref->location), hasplus); break; case CRERR_WRONG_DB: ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cross-database references are not implemented: %s", NameListToString(cref->fields)), parser_errposition(pstate, cref->location))); break; case CRERR_TOO_MANY: ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("improper qualified name (too many dotted names): %s", NameListToString(cref->fields)), parser_errposition(pstate, cref->location))); break; default: break; } } /* Only when hanlde operator "(+)" in WhereClause need recode the RTE info */ if (pstate->p_plusjoin_rte_info != NULL && pstate->p_plusjoin_rte_info->needrecord && rte != NULL) { pstate->p_plusjoin_rte_info->info = lappend(pstate->p_plusjoin_rte_info->info, makePlusJoinRTEItem(rte, hasplus)); } return node; } static bool isCol2Function(List* fields) { char* schemaname = NULL; char* pkgname = NULL; char* funcname = NULL; DeconstructQualifiedName(fields, &schemaname, &funcname, &pkgname); Oid npsOid = InvalidOid; Oid pkgOid = InvalidOid; if (schemaname != NULL) { npsOid = get_namespace_oid(schemaname, true); } else { npsOid = getCurrentNamespace(); } if (pkgname != NULL) { pkgOid = PackageNameListGetOid(fields, true); } bool is_found = false; /* check args and if have return arg*/ CatCList *catlist = NULL; #ifndef ENABLE_MULTIPLE_NODES if (t_thrd.proc->workingVersionNum < 92470) { catlist = SearchSysCacheList1(PROCNAMEARGSNSP, CStringGetDatum(funcname)); } else { catlist = SearchSysCacheList1(PROCALLARGS, CStringGetDatum(funcname)); } #else catlist = SearchSysCacheList1(PROCNAMEARGSNSP, CStringGetDatum(funcname)); #endif for (int i = 0; i < catlist->n_members; i++) { HeapTuple proctup = t_thrd.lsc_cxt.FetchTupleFromCatCList(catlist, i); Form_pg_proc procform = (Form_pg_proc)GETSTRUCT(proctup); /* get function all args */ Oid *p_argtypes = NULL; char **p_argnames = NULL; char *p_argmodes = NULL; int allArgs = get_func_arg_info(proctup, &p_argtypes, &p_argnames, &p_argmodes); if (allArgs > 0 || !OidIsValid(procform->prorettype)) { continue; } if (OidIsValid(npsOid)) { /* Consider only procs in specified namespace */ if (procform->pronamespace != npsOid) { continue; } } if (OidIsValid(pkgOid)) { bool isNull = false; Datum packageid_datum = SysCacheGetAttr(PROCOID, proctup, Anum_pg_proc_packageid, &isNull); Oid packageid = ObjectIdGetDatum(packageid_datum); if (packageid != pkgOid) { continue; } } is_found = true; } ReleaseSysCacheList(catlist); return is_found; } static Node* tryTransformFunc(ParseState* pstate, List* fields, int location) { if (!isCol2Function(fields)) { return NULL; } Node* result = NULL; FuncCall *fn = makeNode(FuncCall); fn->funcname = fields; fn->args = NIL; fn->agg_order = NIL; fn->agg_star = FALSE; fn->agg_distinct = FALSE; fn->func_variadic = FALSE; fn->over = NULL; fn->location = location; fn->call_func = false; /* function must have 0 args */ List* targs = NIL; /* ... and hand off to ParseFuncOrColumn */ result = ParseFuncOrColumn(pstate, fn->funcname, targs, fn, fn->location, fn->call_func); /* extract out parameter for package function */ if (IsPackageFunction(fn->funcname) && result != NULL && nodeTag(result) == T_FuncExpr && fn->call_func) { FuncExpr* funcexpr = (FuncExpr*)result; int funcoid = funcexpr->funcid; funcexpr->args = extract_function_outarguments(funcoid, funcexpr->args, fn->funcname); } return result; } static Node* transformParamRef(ParseState* pstate, ParamRef* pref) { Node* result = NULL; /* * The core parser knows nothing about Params. If a hook is supplied, * call it. If not, or if the hook returns NULL, throw a generic error. */ if (pstate->p_paramref_hook != NULL) { result = (*pstate->p_paramref_hook)(pstate, pref); } else { result = NULL; } if (result == NULL) { ereport(ERROR, (errcode(ERRCODE_UNDEFINED_PARAMETER), errmsg("there is no parameter $%d", pref->number), parser_errposition(pstate, pref->location))); } return result; } /* Test whether an a_expr is a plain NULL constant or not */ static bool exprIsNullConstant(Node* arg) { if (arg && IsA(arg, A_Const)) { A_Const* con = (A_Const*)arg; if (con->val.type == T_Null) { return true; } } return false; } static Node* transformAExprOp(ParseState* pstate, A_Expr* a) { Node* lexpr = a->lexpr; Node* rexpr = a->rexpr; Node* result = NULL; /* * Special-case "foo = NULL" and "NULL = foo" for compatibility with * standards-broken products (like Microsoft's). Turn these into IS NULL * exprs. (If either side is a CaseTestExpr, then the expression was * generated internally from a CASE-WHEN expression, and * transform_null_equals does not apply.) */ if (u_sess->attr.attr_sql.Transform_null_equals && list_length(a->name) == 1 && strcmp(strVal(linitial(a->name)), "=") == 0 && (exprIsNullConstant(lexpr) || exprIsNullConstant(rexpr)) && (!IsA(lexpr, CaseTestExpr) && !IsA(rexpr, CaseTestExpr))) { NullTest* n = makeNode(NullTest); n->nulltesttype = IS_NULL; n->arg = exprIsNullConstant(lexpr) ? (Expr *)rexpr : (Expr *)lexpr; result = transformExpr(pstate, (Node*)n); } else if (lexpr && IsA(lexpr, RowExpr) && rexpr && IsA(rexpr, SubLink) && ((SubLink*)rexpr)->subLinkType == EXPR_SUBLINK) { /* * Convert "row op subselect" into a ROWCOMPARE sublink. Formerly the * grammar did this, but now that a row construct is allowed anywhere * in expressions, it's easier to do it here. */ SubLink* s = (SubLink*)rexpr; s->subLinkType = ROWCOMPARE_SUBLINK; s->testexpr = lexpr; s->operName = a->name; s->location = a->location; result = transformExpr(pstate, (Node*)s); } else if (lexpr && IsA(lexpr, RowExpr) && rexpr && IsA(rexpr, RowExpr)) { /* "row op row" */ lexpr = transformExpr(pstate, lexpr); rexpr = transformExpr(pstate, rexpr); AssertEreport(IsA(lexpr, RowExpr), MOD_OPT, ""); AssertEreport(IsA(rexpr, RowExpr), MOD_OPT, ""); result = make_row_comparison_op(pstate, a->name, ((RowExpr*)lexpr)->args, ((RowExpr*)rexpr)->args, a->location); } else { /* Ordinary scalar operator */ lexpr = transformExpr(pstate, lexpr); rexpr = transformExpr(pstate, rexpr); result = (Node*)make_op(pstate, a->name, lexpr, rexpr, a->location); } return result; } static Node* transformAExprAnd(ParseState* pstate, A_Expr* a) { Node* lexpr = transformExpr(pstate, a->lexpr); Node* rexpr = transformExpr(pstate, a->rexpr); lexpr = coerce_to_boolean(pstate, lexpr, "AND"); rexpr = coerce_to_boolean(pstate, rexpr, "AND"); return (Node*)makeBoolExpr(AND_EXPR, list_make2(lexpr, rexpr), a->location); } static Node* transformAExprOr(ParseState* pstate, A_Expr* a) { Node* lexpr = transformExpr(pstate, a->lexpr); Node* rexpr = transformExpr(pstate, a->rexpr); lexpr = coerce_to_boolean(pstate, lexpr, "OR"); rexpr = coerce_to_boolean(pstate, rexpr, "OR"); return (Node*)makeBoolExpr(OR_EXPR, list_make2(lexpr, rexpr), a->location); } static Node* transformAExprNot(ParseState* pstate, A_Expr* a) { Node* rexpr = transformExpr(pstate, a->rexpr); rexpr = coerce_to_boolean(pstate, rexpr, "NOT"); return (Node*)makeBoolExpr(NOT_EXPR, list_make1(rexpr), a->location); } static Node* transformAExprOpAny(ParseState* pstate, A_Expr* a) { Node* lexpr = transformExpr(pstate, a->lexpr); Node* rexpr = transformExpr(pstate, a->rexpr); return (Node*)make_scalar_array_op(pstate, a->name, true, lexpr, rexpr, a->location); } static Node* transformAExprOpAll(ParseState* pstate, A_Expr* a) { Node* lexpr = transformExpr(pstate, a->lexpr); Node* rexpr = transformExpr(pstate, a->rexpr); return (Node*)make_scalar_array_op(pstate, a->name, false, lexpr, rexpr, a->location); } static Node* transformAExprDistinct(ParseState* pstate, A_Expr* a) { Node* lexpr = transformExpr(pstate, a->lexpr); Node* rexpr = transformExpr(pstate, a->rexpr); if (lexpr && IsA(lexpr, RowExpr) && rexpr && IsA(rexpr, RowExpr)) { /* "row op row" */ return make_row_distinct_op(pstate, a->name, (RowExpr*)lexpr, (RowExpr*)rexpr, a->location); } else { /* Ordinary scalar operator */ return (Node*)make_distinct_op(pstate, a->name, lexpr, rexpr, a->location); } } static Node* transformAExprNullIf(ParseState* pstate, A_Expr* a) { Node* lexpr = transformExpr(pstate, a->lexpr); Node* rexpr = transformExpr(pstate, a->rexpr); OpExpr* result = NULL; result = (OpExpr*)make_op(pstate, a->name, lexpr, rexpr, a->location); /* * The comparison operator itself should yield boolean ... */ if (result->opresulttype != BOOLOID) { ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("NULLIF requires = operator to yield boolean"), parser_errposition(pstate, a->location))); } /* * ... but the NullIfExpr will yield the first operand's type. */ result->opresulttype = exprType((Node*)linitial(result->args)); /* * We rely on NullIfExpr and OpExpr being the same struct */ NodeSetTag(result, T_NullIfExpr); return (Node*)result; } static Node* transformAExprOf(ParseState* pstate, A_Expr* a) { /* * Checking an expression for match to a list of type names. Will result * in a boolean constant node. */ Node* lexpr = transformExpr(pstate, a->lexpr); Const* result = NULL; ListCell* telem = NULL; Oid ltype, rtype; bool matched = false; ltype = exprType(lexpr); foreach (telem, (List*)a->rexpr) { rtype = typenameTypeId(pstate, (const TypeName*)lfirst(telem)); matched = (rtype == ltype); if (matched) { break; } } /* * We have two forms: equals or not equals. Flip the sense of the result * for not equals. */ if (strcmp(strVal(linitial(a->name)), "<>") == 0) { matched = (!matched); } result = (Const*)makeBoolConst(matched, false); /* Make the result have the original input's parse location */ result->location = exprLocation((Node*)a); return (Node*)result; } static Node* transformAExprIn(ParseState* pstate, A_Expr* a) { Node* result = NULL; Node* lexpr = NULL; List* rexprs = NIL; List* rvars = NIL; List* rnonvars = NIL; bool useOr = false; bool haveRowExpr = false; bool haveSetType = false; ListCell* l = NULL; /* * If the operator is <>, combine with AND not OR. */ if (strcmp(strVal(linitial(a->name)), "<>") == 0) { useOr = false; } else { useOr = true; } /* * We try to generate a ScalarArrayOpExpr from IN/NOT IN, but this is only * possible if the inputs are all scalars (no RowExprs) and there is a * suitable array type available. If not, we fall back to a boolean * condition tree with multiple copies of the lefthand expression. Also, * any IN-list items that contain Vars are handled as separate boolean * conditions, because that gives the planner more scope for optimization * on such clauses. * * First step: transform all the inputs, and detect whether any are * RowExprs or contain Vars. */ lexpr = transformExpr(pstate, a->lexpr); haveRowExpr = (lexpr && IsA(lexpr, RowExpr)); haveSetType = type_is_set(exprType(lexpr)); rexprs = rvars = rnonvars = NIL; foreach (l, (List*)a->rexpr) { Node* rexpr = (Node*)transformExpr(pstate, (Node*)lfirst(l)); haveRowExpr = haveRowExpr || (rexpr && IsA(rexpr, RowExpr)); haveSetType = haveSetType || type_is_set(exprType(rexpr)); rexprs = lappend(rexprs, rexpr); if (contain_vars_of_level(rexpr, 0)) { rvars = lappend(rvars, rexpr); } else { rnonvars = lappend(rnonvars, rexpr); } } /* * ScalarArrayOpExpr is only going to be useful if there's more than one * non-Var righthand item. Also, it won't work for RowExprs. */ if (!haveRowExpr && list_length(rnonvars) > 1) { List* allexprs = NIL; Oid scalar_type; Oid array_type; const char *context = haveSetType ? "IN" : NULL; /* * Try to select a common type for the array elements. Note that * since the LHS' type is first in the list, it will be preferred when * there is doubt (eg, when all the RHS items are unknown literals). * * Note: use list_concat here not lcons, to avoid damaging rnonvars. */ allexprs = list_concat(list_make1(lexpr), rnonvars); scalar_type = select_common_type(pstate, allexprs, context, NULL); /* Do we have an array type to use? */ if (OidIsValid(scalar_type)) { array_type = get_array_type(scalar_type); } else { array_type = InvalidOid; } if (array_type != InvalidOid) { /* * OK: coerce all the right-hand non-Var inputs to the common type * and build an ArrayExpr for them. */ List* aexprs = NIL; ArrayExpr* newa = NULL; aexprs = NIL; foreach (l, rnonvars) { Node* rexpr = (Node*)lfirst(l); rexpr = coerce_to_common_type(pstate, rexpr, scalar_type, "IN"); aexprs = lappend(aexprs, rexpr); } newa = makeNode(ArrayExpr); newa->array_typeid = array_type; /* array_collid will be set by parse_collate.c */ newa->element_typeid = scalar_type; newa->elements = aexprs; newa->multidims = false; newa->location = -1; result = (Node*)make_scalar_array_op(pstate, a->name, useOr, lexpr, (Node*)newa, a->location); /* Consider only the Vars (if any) in the loop below */ rexprs = rvars; } } /* * Must do it the hard way, ie, with a boolean expression tree. */ foreach (l, rexprs) { Node* rexpr = (Node*)lfirst(l); Node* cmp = NULL; if (haveRowExpr) { if (!IsA(lexpr, RowExpr) || !IsA(rexpr, RowExpr)) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("arguments of row IN must all be row expressions"), parser_errposition(pstate, a->location))); } cmp = make_row_comparison_op( pstate, a->name, (List*)copyObject(((RowExpr*)lexpr)->args), ((RowExpr*)rexpr)->args, a->location); } else { cmp = (Node*)make_op(pstate, a->name, (Node*)copyObject(lexpr), rexpr, a->location); } cmp = coerce_to_boolean(pstate, cmp, "IN"); if (result == NULL) { result = cmp; } else { result = (Node*)makeBoolExpr(useOr ? OR_EXPR : AND_EXPR, list_make2(result, cmp), a->location); } } return result; } bool IsStartWithFunction(FuncExpr* result) { return result->funcid == SYS_CONNECT_BY_PATH_FUNCOID || result->funcid == CONNECT_BY_ROOT_FUNCOID; } static bool NeedExtractOutParam(FuncCall* fn, Node* result) { if (result == NULL || nodeTag(result) != T_FuncExpr) { return false; } /* Always extract for called package functions */ if (IsPackageFunction(fn->funcname) && fn->call_func) { return true; } /* * When proc_outparam_override is on, extract all but select func */ FuncExpr* funcexpr = (FuncExpr*)result; Oid schema_oid = get_func_namespace(funcexpr->funcid); if (IsAformatStyleFunctionOid(schema_oid) && enable_out_param_override()) { return false; } if (is_function_with_plpgsql_language_and_outparam(funcexpr->funcid) && !fn->call_func) { return true; } char prokind = get_func_prokind(funcexpr->funcid); if (!PROC_IS_PRO(prokind) && !fn->call_func) { return false; } #ifndef ENABLE_MULTIPLE_NODES return enable_out_param_override(); #else return false; #endif } /* * rewrite userSetElem. * extract name from old userSetElem into new userSetElem, * such as, @var_name1 := @var_name2 := @var_name3 := ... := expr. */ static Node* transformUserSetElem(ParseState* pstate, UserSetElem *elem) { UserSetElem *result = makeNode(UserSetElem); result->name = elem->name; Node *value = transformExpr(pstate, (Node*)elem->val); if (IsA(elem->val, UserSetElem)) { result->name = list_concat(result->name, ((UserSetElem *)value)->name); result->val = ((UserSetElem *)value)->val; } else { result->val = (Expr *)value; } return (Node *)result; } /* * Get user_defined varibales from hash table, * if not found, NULL is returned. */ static Node* transformUserVar(UserVar *uservar) { bool found = false; GucUserParamsEntry *entry = (GucUserParamsEntry *)hash_search(u_sess->utils_cxt.set_user_params_htab, uservar->name, HASH_FIND, &found); if (!found) { /* return a null const */ Const *nullValue = makeConst(UNKNOWNOID, -1, InvalidOid, -2, (Datum)0, true, false); return (Node *)nullValue; } UserVar *result = makeNode(UserVar); result->name = uservar->name; result->value = (Expr *)copyObject(entry->value); return (Node *)result; } static Node* transformFuncCall(ParseState* pstate, FuncCall* fn) { List* targs = NIL; ListCell* args = NULL; Node* result = NULL; /* Transform the list of arguments ... */ targs = NIL; foreach (args, fn->args) { targs = lappend(targs, transformExpr(pstate, (Node*)lfirst(args))); } if (fn->agg_within_group) { Assert(fn->agg_order != NIL); foreach (args, fn->agg_order) { SortBy* arg = (SortBy*)lfirst(args); targs = lappend(targs, transformExpr(pstate, arg->node)); } } /* ... and hand off to ParseFuncOrColumn */ result = ParseFuncOrColumn(pstate, fn->funcname, targs, fn, fn->location, fn->call_func); if (IsStartWithFunction((FuncExpr*)result) && !pstate->p_hasStartWith) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmodule(MOD_OPT), errmsg("Invalid function call."), errdetail("START WITH CONNECT BY function found in non-hierarchical query."), errcause("Incorrect query input"), erraction("Please check and revise your query"))); } #ifndef ENABLE_MULTIPLE_NODES if (u_sess->plsql_cxt.curr_compile_context != NULL) { if (result != NULL && nodeTag(result) == T_FuncExpr) { FuncExpr* funcexpr = (FuncExpr*)result; SubCheckOutParam(targs, funcexpr->funcid); } } #endif /* extract out parameter for package function */ if (NeedExtractOutParam(fn, result)) { FuncExpr* funcexpr = (FuncExpr*)result; int funcoid = funcexpr->funcid; funcexpr->args = extract_function_outarguments(funcoid, funcexpr->args, fn->funcname); } /* lock nextval on cn when transformFuncExpr to avoid dead lock with alter sequence */ lockSeqForNextvalFunc(result); return result; } /* * @Description: We should lock sequence on CN when use nextval to avoid deadlock on dn * with alter sequence. * @in node - FuncExpr node */ void lockSeqForNextvalFunc(Node* node) { if (node != NULL && IsA(node, FuncExpr) && ((FuncExpr*)node)->funcid == NEXTVALFUNCOID) { FuncExpr* funcexpr = (FuncExpr*)node; Assert(funcexpr->args->length == 1); if (IsA(linitial(funcexpr->args), Const)) { Const* con = (Const*)linitial(funcexpr->args); /* lock sequence and hold the lock */ Oid relid = DatumGetObjectId(con->constvalue); lockNextvalOnCn(relid); } } } /* * @Description: get function's oid for overlaod function * @in fun_expr - function call statement * @in expr - plpgsql expr * @return - function's oid */ Oid getMultiFuncInfo(char* fun_expr, PLpgSQL_expr* expr, bool isoutparamcheck) { List* raw_parser_list = raw_parser(fun_expr); ListCell* parsetree_item = NULL; foreach (parsetree_item, raw_parser_list) { Node* parsetree = (Node*)lfirst(parsetree_item); ParseState* pstate = make_parsestate(NULL); plpgsql_parser_setup(pstate, expr); if (nodeTag(parsetree) == T_SelectStmt) { SelectStmt* stmt = (SelectStmt*)parsetree; List* frmList = isoutparamcheck ? stmt->targetList : stmt->fromClause; ListCell* fl = NULL; foreach (fl, frmList) { Node* n = (Node*)lfirst(fl); List* targs = NIL; ListCell* args = NULL; FuncCall* fn = NULL; if (IsA(n, RangeFunction)) { RangeFunction* r = (RangeFunction*)n; if (r->funccallnode != NULL && nodeTag(r->funccallnode) == T_FuncCall) { fn = (FuncCall*)(r->funccallnode); } } else if (isoutparamcheck && IsA(n, ResTarget)) { ResTarget* r = (ResTarget*)n; if (r->val != NULL && nodeTag(r->val) == T_FuncCall) { fn = (FuncCall*)(r->val); } } if (fn == NULL) { continue; } foreach (args, fn->args) { targs = lappend(targs, transformExpr(pstate, (Node*)lfirst(args))); } Node* result = ParseFuncOrColumn(pstate, fn->funcname, targs, fn, fn->location, true); if (result != NULL && nodeTag(result) == T_FuncExpr) { FuncExpr* funcexpr = (FuncExpr*)result; if (isoutparamcheck) { SubCheckOutParam(targs, funcexpr->funcid); } return funcexpr->funcid; } } } } return InvalidOid; } static void SubCheckOutParam(List* exprtargs, Oid funcid) { if (OidIsValid(funcid)) { HeapTuple proctup = SearchSysCache(PROCOID, ObjectIdGetDatum(funcid), 0, 0, 0); /* * function may be deleted after clist be searched. */ if (!HeapTupleIsValid(proctup)) { ereport(ERROR, (errcode(ERRCODE_UNDEFINED_FUNCTION), errmsg("function Oid \"%d\" doesn't exist ", funcid))); } Oid *p_argtypes = NULL; char **p_argnames = NULL; char *p_argmodes = NULL; /* get the all args informations, only "in" parameters if p_argmodes is null */ int all_arg = get_func_arg_info(proctup, &p_argtypes, &p_argnames, &p_argmodes); Form_pg_proc procStruct = (Form_pg_proc) GETSTRUCT(proctup); char *funcname = NameStr(procStruct->proname); ReleaseSysCache(proctup); if ((0 == all_arg || NULL == p_argmodes || all_arg != list_length(exprtargs))) { return; } ListCell* cell1 = NULL; int i = 0; foreach(cell1, exprtargs) { if (nodeTag(((Node*)lfirst(cell1))) != T_Param && (p_argmodes[i] == 'o' || p_argmodes[i] == 'b')) { StringInfoData buf; initStringInfo(&buf); appendStringInfo(&buf, "$%d", i); char *p_argname = p_argnames != NULL ? p_argnames[i]:buf.data; ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("when invoking function %s, no destination for argments num \"%s\"", funcname, p_argname))); } i++; } } } void CheckOutParamIsConst(PLpgSQL_expr* expr) { PLpgSQL_function *function = NULL; PLpgSQL_execstate *estate = (PLpgSQL_execstate*)palloc(sizeof(PLpgSQL_execstate)); expr->func = (PLpgSQL_function *) palloc0(sizeof(PLpgSQL_function)); function = expr->func; function->fn_is_trigger = false; function->fn_input_collation = InvalidOid; function->out_param_varno = -1; /* set up for no OUT param */ function->resolve_option = GetResolveOption(); function->fn_cxt = CurrentMemoryContext; PLpgSQL_compile_context* curr_compile = u_sess->plsql_cxt.curr_compile_context; estate->ndatums = curr_compile->plpgsql_nDatums; estate->datums = (PLpgSQL_datum **)palloc(sizeof(PLpgSQL_datum *) * curr_compile->plpgsql_nDatums); for (int i = 0; i < curr_compile->plpgsql_nDatums; i++) estate->datums[i] = curr_compile->plpgsql_Datums[i]; function->cur_estate = estate; function->cur_estate->func = function; (void)getMultiFuncInfo(expr->query, expr, true); if (expr->func != NULL) pfree_ext(expr->func); if (estate->datums != NULL) pfree_ext(estate->datums); if (estate != NULL) pfree_ext(estate); expr->func = NULL; } static Node* transformCaseExpr(ParseState* pstate, CaseExpr* c) { CaseExpr* newc = NULL; Node* arg = NULL; CaseTestExpr* placeholder = NULL; List* newargs = NIL; List* resultexprs = NIL; ListCell* l = NULL; Node* defresult = NULL; Oid ptype; /* If we already transformed this node, do nothing */ if (OidIsValid(c->casetype)) { return (Node*)c; } bool saved_is_case_when = pstate->p_is_case_when; pstate->p_is_case_when = true; newc = makeNode(CaseExpr); /* transform the test expression, if any */ arg = transformExpr(pstate, (Node*)c->arg); /* generate placeholder for test expression */ if (arg != NULL) { /* * If test expression is an untyped literal, force it to text. We have * to do something now because we won't be able to do this coercion on * the placeholder. This is not as flexible as what was done in 7.4 * and before, but it's good enough to handle the sort of silly coding * commonly seen. */ if (exprType(arg) == UNKNOWNOID) { arg = coerce_to_common_type(pstate, arg, TEXTOID, "CASE"); } /* * Run collation assignment on the test expression so that we know * what collation to mark the placeholder with. In principle we could * leave it to parse_collate.c to do that later, but propagating the * result to the CaseTestExpr would be unnecessarily complicated. */ assign_expr_collations(pstate, arg); placeholder = makeNode(CaseTestExpr); placeholder->typeId = exprType(arg); placeholder->typeMod = exprTypmod(arg); placeholder->collation = exprCollation(arg); } else { placeholder = NULL; } newc->arg = (Expr*)arg; /* transform the list of arguments */ newargs = NIL; resultexprs = NIL; foreach (l, c->args) { CaseWhen* w = (CaseWhen*)lfirst(l); CaseWhen* neww = makeNode(CaseWhen); Node* warg = NULL; AssertEreport(IsA(w, CaseWhen), MOD_OPT, ""); warg = (Node*)w->expr; if (placeholder != NULL) { /* shorthand form was specified, so expand... */ warg = (Node*)makeSimpleA_Expr(AEXPR_OP, "=", (Node*)placeholder, warg, w->location); } neww->expr = (Expr*)transformExpr(pstate, warg); neww->expr = (Expr*)coerce_to_boolean(pstate, (Node*)neww->expr, "CASE/WHEN"); warg = (Node*)w->result; neww->result = (Expr*)transformExpr(pstate, warg); neww->location = w->location; newargs = lappend(newargs, neww); resultexprs = lappend(resultexprs, neww->result); } newc->args = newargs; /* transform the default clause */ defresult = (Node*)c->defresult; if (defresult == NULL) { A_Const* n = makeNode(A_Const); n->val.type = T_Null; n->location = -1; defresult = (Node*)n; } newc->defresult = (Expr*)transformExpr(pstate, defresult); /* check results in resultexprs and defresult whether all are in the whitelist. */ List* defresultexprs = NIL; defresultexprs = lappend(defresultexprs, newc->defresult); bool allInWhitelist = check_all_in_whitelist(resultexprs) && check_all_in_whitelist(defresultexprs); list_free_ext(defresultexprs); /* * Note: default result is considered the most significant type in * determining preferred type. This is how the code worked before, but it * seems a little bogus to me --- tgl * * For A format, result1 is considered the most significant type in * determining preferred type. So append default result to the end of * the list. Make sure result1 is the first element of the list. */ if (u_sess->attr.attr_sql.sql_compatibility == A_FORMAT && ENABLE_SQL_BETA_FEATURE(A_STYLE_COERCE) && allInWhitelist) { resultexprs = lappend(resultexprs, newc->defresult); } else { resultexprs = lcons(newc->defresult, resultexprs); } ptype = select_common_type(pstate, resultexprs, "CASE", NULL); AssertEreport(OidIsValid(ptype), MOD_OPT, ""); newc->casetype = ptype; /* casecollid will be set by parse_collate.c */ /* Convert default result clause, if necessary */ newc->defresult = (Expr*)coerce_to_common_type(pstate, (Node*)newc->defresult, ptype, "CASE/ELSE"); /* Convert when-clause results, if necessary */ foreach (l, newc->args) { CaseWhen* w = (CaseWhen*)lfirst(l); w->result = (Expr*)coerce_to_common_type(pstate, (Node*)w->result, ptype, "CASE/WHEN"); } newc->location = c->location; pstate->p_is_case_when = saved_is_case_when; return (Node*)newc; } /* * transformSetVariableExpr gets variable's value according to name and saves it in ConstExpr */ Node* transformSetVariableExpr(SetVariableExpr* set) { SetVariableExpr *result = makeNode(SetVariableExpr); result->name = set->name; result->is_session = set->is_session; result->is_global = set->is_global; Const *values = setValueToConstExpr(set); result->value = (Expr*)copyObject(values); return (Node *)result; } static Node* transformSelectIntoVarList(ParseState* pstate, SelectIntoVarList* sis) { SubLink* sublink = (SubLink *)sis->sublink; Query* qtree = NULL; if (IsA(sublink->subselect, Query)) { return (Node *)sis; } pstate->p_hasSubLinks = true; qtree = parse_sub_analyze(sublink->subselect, pstate, NULL, false, true); if (!IsA(qtree, Query) || qtree->commandType != CMD_SELECT || qtree->utilityStmt != NULL) { ereport(ERROR, (errcode(ERRCODE_INVALID_OPERATION), errmsg("unexpected non-SELECT command in SubLink"))); } sublink->subselect = (Node*)qtree; if (list_length(qtree->targetList) != list_length(sis->userVarList)) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("number of variables must equal the number of columns"), parser_errposition(pstate, sublink->location))); } return (Node *)sis; } static Node* transformSubLink(ParseState* pstate, SubLink* sublink) { Node* result = (Node*)sublink; Query* qtree = NULL; /* If we already transformed this node, do nothing */ if (IsA(sublink->subselect, Query)) { return result; } pstate->p_hasSubLinks = true; qtree = parse_sub_analyze(sublink->subselect, pstate, NULL, false, true); /* * Check that we got something reasonable. Many of these conditions are * impossible given restrictions of the grammar, but check 'em anyway. */ if (!IsA(qtree, Query) || qtree->commandType != CMD_SELECT || qtree->utilityStmt != NULL) { ereport(ERROR, (errcode(ERRCODE_INVALID_OPERATION), errmsg("unexpected non-SELECT command in SubLink"))); } sublink->subselect = (Node*)qtree; if (sublink->subLinkType == EXISTS_SUBLINK) { /* * EXISTS needs no test expression or combining operator. These fields * should be null already, but make sure. */ sublink->testexpr = NULL; sublink->operName = NIL; } else if (sublink->subLinkType == EXPR_SUBLINK || sublink->subLinkType == ARRAY_SUBLINK) { ListCell* tlist_item = list_head(qtree->targetList); /* * Make sure the subselect delivers a single column (ignoring resjunk * targets). */ if (tlist_item == NULL || ((TargetEntry*)lfirst(tlist_item))->resjunk) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("subquery must return a column"), parser_errposition(pstate, sublink->location))); } while ((tlist_item = lnext(tlist_item)) != NULL) { if (!((TargetEntry*)lfirst(tlist_item))->resjunk) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("subquery must return only one column"), parser_errposition(pstate, sublink->location))); } } /* * EXPR and ARRAY need no test expression or combining operator. These * fields should be null already, but make sure. */ sublink->testexpr = NULL; sublink->operName = NIL; } else { /* ALL, ANY, or ROWCOMPARE: generate row-comparing expression */ Node* lefthand = NULL; List* left_list = NIL; List* right_list = NIL; ListCell* l = NULL; /* * Transform lefthand expression, and convert to a list */ lefthand = transformExpr(pstate, sublink->testexpr); if (lefthand && IsA(lefthand, RowExpr)) { left_list = ((RowExpr*)lefthand)->args; } else { left_list = list_make1(lefthand); } /* * Build a list of PARAM_SUBLINK nodes representing the output columns * of the subquery. */ right_list = NIL; foreach (l, qtree->targetList) { TargetEntry* tent = (TargetEntry*)lfirst(l); Param* param = NULL; if (tent->resjunk) { continue; } param = makeNode(Param); param->paramkind = PARAM_SUBLINK; param->paramid = tent->resno; param->paramtype = exprType((Node*)tent->expr); param->paramtypmod = exprTypmod((Node*)tent->expr); param->paramcollid = exprCollation((Node*)tent->expr); param->location = -1; param->tableOfIndexTypeList = NULL; right_list = lappend(right_list, param); } /* * We could rely on make_row_comparison_op to complain if the list * lengths differ, but we prefer to generate a more specific error * message. */ if (list_length(left_list) < list_length(right_list)) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("subquery has too many columns"), parser_errposition(pstate, sublink->location))); } if (list_length(left_list) > list_length(right_list)) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("subquery has too few columns"), parser_errposition(pstate, sublink->location))); } /* * Identify the combining operator(s) and generate a suitable * row-comparison expression. */ sublink->testexpr = make_row_comparison_op(pstate, sublink->operName, left_list, right_list, sublink->location); } return result; } /* * transformArrayExpr * * If the caller specifies the target type, the resulting array will * be of exactly that type. Otherwise we try to infer a common type * for the elements using select_common_type(). */ static Node* transformArrayExpr(ParseState* pstate, A_ArrayExpr* a, Oid array_type, Oid element_type, int32 typmod) { ArrayExpr* newa = makeNode(ArrayExpr); List* newelems = NIL; List* newcoercedelems = NIL; ListCell* element = NULL; Oid coerce_type; bool coerce_hard = false; /* * Transform the element expressions * * Assume that the array is one-dimensional unless we find an array-type * element expression. */ newa->multidims = false; foreach (element, a->elements) { Node* e = (Node*)lfirst(element); Node* newe = NULL; /* * If an element is itself an A_ArrayExpr, recurse directly so that we * can pass down any target type we were given. */ if (IsA(e, A_ArrayExpr)) { newe = transformArrayExpr(pstate, (A_ArrayExpr*)e, array_type, element_type, typmod); /* we certainly have an array here */ AssertEreport(array_type == InvalidOid || array_type == exprType(newe), MOD_OPT, ""); newa->multidims = true; } else { newe = transformExpr(pstate, e); /* * Check for sub-array expressions, if we haven't already found * one. */ if (!newa->multidims && type_is_array(exprType(newe))) { newa->multidims = true; } } newelems = lappend(newelems, newe); } /* * Select a target type for the elements. * * If we haven't been given a target array type, we must try to deduce a * common type based on the types of the individual elements present. */ if (OidIsValid(array_type)) { /* Caller must ensure array_type matches element_type */ AssertEreport(OidIsValid(element_type), MOD_OPT, ""); coerce_type = (newa->multidims ? array_type : element_type); coerce_hard = true; } else { /* Can't handle an empty array without a target type */ if (newelems == NIL) { ereport(ERROR, (errcode(ERRCODE_INDETERMINATE_DATATYPE), errmsg("cannot determine type of empty array"), errhint("Explicitly cast to the desired type, " "for example ARRAY[]::integer[]."), parser_errposition(pstate, a->location))); } /* Select a common type for the elements */ coerce_type = select_common_type(pstate, newelems, "ARRAY", NULL); if (newa->multidims) { array_type = coerce_type; element_type = get_element_type(array_type); if (!OidIsValid(element_type)) { ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("could not find element type for data type %s", format_type_be(array_type)), parser_errposition(pstate, a->location))); } } else { element_type = coerce_type; array_type = get_array_type(element_type); if (!OidIsValid(array_type)) { ereport(ERROR, (errcode(ERRCODE_UNDEFINED_OBJECT), errmsg("could not find array type for data type %s", format_type_be(element_type)), parser_errposition(pstate, a->location))); } } coerce_hard = false; } /* * Coerce elements to target type * * If the array has been explicitly cast, then the elements are in turn * explicitly coerced. * * If the array's type was merely derived from the common type of its * elements, then the elements are implicitly coerced to the common type. * This is consistent with other uses of select_common_type(). */ foreach (element, newelems) { Node* e = (Node*)lfirst(element); Node* newe = NULL; if (coerce_hard) { newe = coerce_to_target_type( pstate, e, exprType(e), coerce_type, typmod, COERCION_EXPLICIT, COERCE_EXPLICIT_CAST, -1); if (newe == NULL) { ereport(ERROR, (errcode(ERRCODE_CANNOT_COERCE), errmsg("cannot cast type %s to %s", format_type_be(exprType(e)), format_type_be(coerce_type)), parser_errposition(pstate, exprLocation(e)))); } } else { newe = coerce_to_common_type(pstate, e, coerce_type, "ARRAY"); } newcoercedelems = lappend(newcoercedelems, newe); } newa->array_typeid = array_type; /* array_collid will be set by parse_collate.c */ newa->element_typeid = element_type; newa->elements = newcoercedelems; newa->location = a->location; return (Node*)newa; } static Node* transformRowExpr(ParseState* pstate, RowExpr* r) { RowExpr* newr = NULL; char fname[16]; int fnum; ListCell* lc = NULL; /* If we already transformed this node, do nothing */ if (OidIsValid(r->row_typeid)) { return (Node*)r; } newr = makeNode(RowExpr); /* Transform the field expressions */ newr->args = transformExpressionList(pstate, r->args); /* Barring later casting, we consider the type RECORD */ newr->row_typeid = RECORDOID; newr->row_format = COERCE_IMPLICIT_CAST; /* ROW() has anonymous columns, so invent some field names */ newr->colnames = NIL; fnum = 1; foreach (lc, newr->args) { int rcs; rcs = snprintf_s(fname, sizeof(fname), sizeof(fname) - 1, "f%d", fnum++); securec_check_ss_c(rcs, "\0", "\0"); newr->colnames = lappend(newr->colnames, makeString(pstrdup(fname))); } newr->location = r->location; return (Node*)newr; } static Node* transformCoalesceExpr(ParseState* pstate, CoalesceExpr* c) { CoalesceExpr* newc = makeNode(CoalesceExpr); List* newargs = NIL; List* newcoercedargs = NIL; ListCell* args = NULL; foreach (args, c->args) { Node* e = (Node*)lfirst(args); Node* newe = NULL; newe = transformExpr(pstate, e); newargs = lappend(newargs, newe); } // supports implicit convert if (c->isnvl) { newc->coalescetype = select_common_type(pstate, newargs, "NVL", NULL); } else { newc->coalescetype = select_common_type(pstate, newargs, "COALESCE", NULL); } /* coalescecollid will be set by parse_collate.c */ /* Convert arguments if necessary */ foreach (args, newargs) { Node* e = (Node*)lfirst(args); Node* newe = NULL; newe = coerce_to_common_type(pstate, e, newc->coalescetype, "COALESCE"); newcoercedargs = lappend(newcoercedargs, newe); } newc->args = newcoercedargs; newc->location = c->location; return (Node*)newc; } static Node* transformMinMaxExpr(ParseState* pstate, MinMaxExpr* m) { MinMaxExpr* newm = makeNode(MinMaxExpr); List* newargs = NIL; List* newcoercedargs = NIL; const char* funcname = (m->op == IS_GREATEST) ? "GREATEST" : "LEAST"; ListCell* args = NULL; newm->op = m->op; foreach (args, m->args) { Node* e = (Node*)lfirst(args); Node* newe = NULL; newe = transformExpr(pstate, e); newargs = lappend(newargs, newe); } newm->minmaxtype = select_common_type(pstate, newargs, funcname, NULL); /* minmaxcollid and inputcollid will be set by parse_collate.c */ /* Convert arguments if necessary */ foreach (args, newargs) { Node* e = (Node*)lfirst(args); Node* newe = NULL; newe = coerce_to_common_type(pstate, e, newm->minmaxtype, funcname); newcoercedargs = lappend(newcoercedargs, newe); } newm->args = newcoercedargs; newm->location = m->location; return (Node*)newm; } static Node* transformXmlExpr(ParseState* pstate, XmlExpr* x) { XmlExpr* newx = NULL; ListCell* lc = NULL; int i; /* If we already transformed this node, do nothing */ if (OidIsValid(x->type)) { return (Node*)x; } newx = makeNode(XmlExpr); newx->op = x->op; if (x->name) { newx->name = map_sql_identifier_to_xml_name(x->name, false, false); } else { newx->name = NULL; } newx->xmloption = x->xmloption; newx->type = XMLOID; /* this just marks the node as transformed */ newx->typmod = -1; newx->location = x->location; /* * gram.y built the named args as a list of ResTarget. Transform each, * and break the names out as a separate list. */ newx->named_args = NIL; newx->arg_names = NIL; foreach (lc, x->named_args) { ResTarget* r = (ResTarget*)lfirst(lc); Node* expr = NULL; char* argname = NULL; AssertEreport(IsA(r, ResTarget), MOD_OPT, ""); expr = transformExpr(pstate, r->val); if (r->name) { argname = map_sql_identifier_to_xml_name(r->name, false, false); } else if (IsA(r->val, ColumnRef)) { argname = map_sql_identifier_to_xml_name(FigureColname(r->val), true, false); } else { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), x->op == IS_XMLELEMENT ? errmsg("unnamed XML attribute value must be a column reference") : errmsg("unnamed XML element value must be a column reference"), parser_errposition(pstate, r->location))); argname = NULL; /* keep compiler quiet */ } /* reject duplicate argnames in XMLELEMENT only */ if (x->op == IS_XMLELEMENT) { ListCell* lc2 = NULL; foreach (lc2, newx->arg_names) { if (strcmp(argname, strVal(lfirst(lc2))) == 0) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("XML attribute name \"%s\" appears more than once", argname), parser_errposition(pstate, r->location))); } } } newx->named_args = lappend(newx->named_args, expr); newx->arg_names = lappend(newx->arg_names, makeString(argname)); } /* The other arguments are of varying types depending on the function */ newx->args = NIL; i = 0; foreach (lc, x->args) { Node* e = (Node*)lfirst(lc); Node* newe = NULL; newe = transformExpr(pstate, e); switch (x->op) { case IS_XMLCONCAT: newe = coerce_to_specific_type(pstate, newe, XMLOID, "XMLCONCAT"); break; case IS_XMLELEMENT: /* no coercion necessary */ break; case IS_XMLFOREST: newe = coerce_to_specific_type(pstate, newe, XMLOID, "XMLFOREST"); break; case IS_XMLPARSE: if (i == 0) { newe = coerce_to_specific_type(pstate, newe, TEXTOID, "XMLPARSE"); } else { newe = coerce_to_boolean(pstate, newe, "XMLPARSE"); } break; case IS_XMLPI: newe = coerce_to_specific_type(pstate, newe, TEXTOID, "XMLPI"); break; case IS_XMLROOT: if (i == 0) { newe = coerce_to_specific_type(pstate, newe, XMLOID, "XMLROOT"); } else if (i == 1) { newe = coerce_to_specific_type(pstate, newe, TEXTOID, "XMLROOT"); } else { newe = coerce_to_specific_type(pstate, newe, INT4OID, "XMLROOT"); } break; case IS_XMLSERIALIZE: /* not handled here */ Assert(false); break; case IS_DOCUMENT: newe = coerce_to_specific_type(pstate, newe, XMLOID, "IS DOCUMENT"); break; default: break; } newx->args = lappend(newx->args, newe); i++; } return (Node*)newx; } static Node* transformXmlSerialize(ParseState* pstate, XmlSerialize* xs) { Node* result = NULL; XmlExpr* xexpr = NULL; Oid targetType; int32 targetTypmod; xexpr = makeNode(XmlExpr); xexpr->op = IS_XMLSERIALIZE; xexpr->args = list_make1(coerce_to_specific_type(pstate, transformExpr(pstate, xs->expr), XMLOID, "XMLSERIALIZE")); typenameTypeIdAndMod(pstate, xs->typname, &targetType, &targetTypmod); xexpr->xmloption = xs->xmloption; xexpr->location = xs->location; /* We actually only need these to be able to parse back the expression. */ xexpr->type = targetType; xexpr->typmod = targetTypmod; /* * The actual target type is determined this way. SQL allows char and * varchar as target types. We allow anything that can be cast implicitly * from text. This way, user-defined text-like data types automatically * fit in. */ result = coerce_to_target_type( pstate, (Node*)xexpr, TEXTOID, targetType, targetTypmod, COERCION_IMPLICIT, COERCE_IMPLICIT_CAST, -1); if (result == NULL) { ereport(ERROR, (errcode(ERRCODE_CANNOT_COERCE), errmsg("cannot cast XMLSERIALIZE result to %s", format_type_be(targetType)), parser_errposition(pstate, xexpr->location))); } return result; } static Node* transformBooleanTest(ParseState* pstate, BooleanTest* b) { const char* clausename = NULL; switch (b->booltesttype) { case IS_TRUE: clausename = "IS TRUE"; break; case IS_NOT_TRUE: clausename = "IS NOT TRUE"; break; case IS_FALSE: clausename = "IS FALSE"; break; case IS_NOT_FALSE: clausename = "IS NOT FALSE"; break; case IS_UNKNOWN: clausename = "IS UNKNOWN"; break; case IS_NOT_UNKNOWN: clausename = "IS NOT UNKNOWN"; break; default: ereport(ERROR, (errcode(ERRCODE_UNRECOGNIZED_NODE_TYPE), errmsg("unrecognized booltesttype: %d", (int)b->booltesttype))); clausename = NULL; /* keep compiler quiet */ } b->arg = (Expr*)transformExpr(pstate, (Node*)b->arg); b->arg = (Expr*)coerce_to_boolean(pstate, (Node*)b->arg, clausename); return (Node*)b; } static Node* transformCurrentOfExpr(ParseState* pstate, CurrentOfExpr* cexpr) { int sublevels_up; #ifdef PGXC ereport(ERROR, (errcode(ERRCODE_STATEMENT_TOO_COMPLEX), (errmsg("WHERE CURRENT OF clause not yet supported")))); #endif /* CURRENT OF can only appear at top level of UPDATE/DELETE */ AssertEreport(pstate->p_target_rangetblentry != NULL, MOD_OPT, ""); cexpr->cvarno = RTERangeTablePosn(pstate, (RangeTblEntry*)linitial(pstate->p_target_rangetblentry), &sublevels_up); AssertEreport(sublevels_up == 0, MOD_OPT, ""); /* * Check to see if the cursor name matches a parameter of type REFCURSOR. * If so, replace the raw name reference with a parameter reference. (This * is a hack for the convenience of plpgsql.) */ if (cexpr->cursor_name != NULL) { /* in case already transformed */ ColumnRef* cref = makeNode(ColumnRef); Node* node = NULL; /* Build an unqualified ColumnRef with the given name */ cref->fields = list_make1(makeString(cexpr->cursor_name)); cref->location = -1; /* See if there is a translation available from a parser hook */ if (pstate->p_pre_columnref_hook != NULL) { node = (*pstate->p_pre_columnref_hook)(pstate, cref); } if (node == NULL && pstate->p_post_columnref_hook != NULL) { node = (*pstate->p_post_columnref_hook)(pstate, cref, NULL); } /* * XXX Should we throw an error if we get a translation that isn't a * refcursor Param? For now it seems best to silently ignore false * matches. */ if (node != NULL && IsA(node, Param)) { Param* p = (Param*)node; if (p->paramkind == PARAM_EXTERN && p->paramtype == REFCURSOROID) { /* Matches, so convert CURRENT OF to a param reference */ cexpr->cursor_name = NULL; cexpr->cursor_param = p->paramid; } } } return (Node*)cexpr; } // Locate in the system catalog the information for a model name static char* select_prediction_function(const Model* model){ char* result; switch(model->return_type){ case BOOLOID: result = "db4ai_predict_by_bool"; break; case FLOAT4OID: result = "db4ai_predict_by_float4"; break; case FLOAT8OID: result = "db4ai_predict_by_float8"; break; case FLOAT8ARRAYOID: result = "db4ai_predict_by_float8_array"; break; case INT1OID: case INT2OID: case INT4OID: result = "db4ai_predict_by_int32"; break; case INT8OID: result = "db4ai_predict_by_int64"; break; case NUMERICOID: result = "db4ai_predict_by_numeric"; break; case VARCHAROID: case BPCHAROID: case CHAROID: case TEXTOID: result = "db4ai_predict_by_text"; break; default: ereport(ERROR, (errmodule(MOD_DB4AI), errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("Cannot trigger prediction for model with oid %u", model->return_type))); result = NULL; break; } return result; } // Convert the PredictByFunction created during parsing phase into the function // call that computes the prediction of the model. We cannot do this during parsing // because at that moment we do not know the return type of the model, which is obtained // from the catalog static Node* transformPredictByFunction(ParseState* pstate, PredictByFunction* p) { FuncCall* n = makeNode(FuncCall); if (p->model_name == NULL) { ereport(ERROR, (errmodule(MOD_DB4AI), errcode(ERRCODE_INVALID_PARAMETER_VALUE), errmsg("Model name for prediction cannot be null"))); } const Model* model = get_model(p->model_name, true); if (model == NULL) { ereport(ERROR, (errmsg( "No model found with name %s", p->model_name))); } // Locate the proper function according to the model name char* function_name = select_prediction_function(model); ereport(DEBUG1, (errmsg( "Selecting prediction function %s for model %s", function_name, p->model_name))); n->funcname = list_make1(makeString(function_name)); n->colname = p->model_name; // Fill model name parameter A_Const* model_name_aconst = makeNode(A_Const); model_name_aconst->val.type = T_String; model_name_aconst->val.val.str = p->model_name; model_name_aconst->location = p->model_name_location; // Copy other parameters n->args = list_make1(model_name_aconst); if (list_length(p->model_args) > 0) { n->args = lappend3(n->args, p->model_args); }else{ ereport(ERROR, (errmodule(MOD_DB4AI), errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("Innput features for the model not specified"))); } n->agg_order = NULL; n->agg_star = FALSE; n->agg_distinct = FALSE; n->func_variadic = FALSE; n->over = NULL; n->location = p->model_args_location; n->call_func = false; return transformExpr(pstate, (Node*)n); } /* * Construct a whole-row reference to represent the notation "relation.*". */ static Node* transformWholeRowRef(ParseState* pstate, RangeTblEntry* rte, int location) { Var* result = NULL; int vnum; int sublevels_up; /* Find the RTE's rangetable location */ vnum = RTERangeTablePosn(pstate, rte, &sublevels_up); /* * Build the appropriate referencing node. Note that if the RTE is a * function returning scalar, we create just a plain reference to the * function value, not a composite containing a single column. This is * pretty inconsistent at first sight, but it's what we've done * historically. One argument for it is that "rel" and "rel.*" mean the * same thing for composite relations, so why not for scalar functions... */ result = makeWholeRowVar(rte, vnum, sublevels_up, true); if (result == NULL) { ereport(ERROR,(errcode(ERRCODE_UNDEFINED_FILE),errmsg("Fail to build a referencing node."))); return NULL; } /* location is not filled in by makeWholeRowVar */ result->location = location; /* mark relation as requiring whole-row SELECT access */ markVarForSelectPriv(pstate, result, rte); return (Node*)result; } /* * Handle an explicit CAST construct. * * Transform the argument, then look up the type name and apply any necessary * coercion function(s). */ static Node* transformTypeCast(ParseState* pstate, TypeCast* tc) { Node* result = NULL; Node* expr = transformExpr(pstate, tc->arg); Oid inputType = exprType(expr); Oid targetType; int32 targetTypmod; int location; typenameTypeIdAndMod(pstate, tc->typname, &targetType, &targetTypmod); if (inputType == InvalidOid) { return expr; /* do nothing if NULL input */ } /* * Location of the coercion is preferentially the location of the :: or * CAST symbol, but if there is none then use the location of the type * name (this can happen in TypeName 'string' syntax, for instance). */ location = tc->location; if (location < 0) { location = tc->typname->location; } result = coerce_to_target_type( pstate, expr, inputType, targetType, targetTypmod, COERCION_EXPLICIT, COERCE_EXPLICIT_CAST, location); if (result == NULL) { ereport(ERROR, (errcode(ERRCODE_CANNOT_COERCE), errmsg("cannot cast type %s to %s", format_type_be(inputType), format_type_be(targetType)), parser_coercion_errposition(pstate, location, expr))); } return result; } /* * Handle an explicit COLLATE clause. * * Transform the argument, and look up the collation name. */ static Node* transformCollateClause(ParseState* pstate, CollateClause* c) { CollateExpr* newc = NULL; Oid argtype; newc = makeNode(CollateExpr); newc->arg = (Expr*)transformExpr(pstate, c->arg); argtype = exprType((Node*)newc->arg); /* * The unknown type is not collatable, but coerce_type() takes care of it * separately, so we'll let it go here. */ if (!type_is_collatable(argtype) && argtype != UNKNOWNOID) { ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("collations are not supported by type %s", format_type_be(argtype)), parser_errposition(pstate, c->location))); } newc->collOid = LookupCollation(pstate, c->collname, c->location); newc->location = c->location; return (Node*)newc; } static char *add_double_quotes(const char *src) { unsigned long max_len = strlen("\"") + strlen(src) + strlen("\"") + 1; char *tmp_buffer = (char *)palloc0(max_len); int rt = sprintf_s(tmp_buffer, max_len, "\"%s\"", src); securec_check_ss(rt, "\0", "\0"); return tmp_buffer; } static Node* transformSequenceFuncCall(ParseState* pstate, Node* field1, Node* field2, Node* field3, int location) { Value* arg = NULL; List* funcname = list_make1((Value*)field3); if (field1 != NULL) { StringInfoData buf; initStringInfo(&buf); appendStringInfo(&buf, "%s.%s", strVal(field1), strVal(field2)); arg = makeString(buf.data); } else { arg = (Value*)field2; if (arg->type == T_String) { char *new_str = add_double_quotes(arg->val.str); arg->val.str = new_str; } } List* args = list_make1(makeAConst(arg, location)); FuncCall* fn = makeFuncCall(funcname, args, location); return transformFuncCall(pstate, fn); } /* * Transform a "row compare-op row" construct * * The inputs are lists of already-transformed expressions. * As with coerce_type, pstate may be NULL if no special unknown-Param * processing is wanted. * * The output may be a single OpExpr, an AND or OR combination of OpExprs, * or a RowCompareExpr. In all cases it is guaranteed to return boolean. * The AND, OR, and RowCompareExpr cases further imply things about the * behavior of the operators (ie, they behave as =, <>, or < <= > >=). */ static Node* make_row_comparison_op(ParseState* pstate, List* opname, List* largs, List* rargs, int location) { RowCompareExpr* rcexpr = NULL; RowCompareType rctype; List* opexprs = NIL; List* opnos = NIL; List* opfamilies = NIL; ListCell *l = NULL, *r = NULL; List** opinfo_lists = NULL; Bitmapset* strats = NULL; int nopers; int i; nopers = list_length(largs); if (nopers != list_length(rargs)) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("unequal number of entries in row expressions"), parser_errposition(pstate, location))); } /* * We can't compare zero-length rows because there is no principled basis * for figuring out what the operator is. */ if (nopers == 0) { ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("cannot compare rows of zero length"), parser_errposition(pstate, location))); } /* * Identify all the pairwise operators, using make_op so that behavior is * the same as in the simple scalar case. */ opexprs = NIL; forboth(l, largs, r, rargs) { Node* larg = (Node*)lfirst(l); Node* rarg = (Node*)lfirst(r); OpExpr* cmp = NULL; cmp = (OpExpr*)make_op(pstate, opname, larg, rarg, location); AssertEreport(IsA(cmp, OpExpr), MOD_OPT, ""); /* * We don't use coerce_to_boolean here because we insist on the * operator yielding boolean directly, not via coercion. If it * doesn't yield bool it won't be in any index opfamilies... */ if (cmp->opresulttype != BOOLOID) { ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("row comparison operator must yield type boolean, " "not type %s", format_type_be(cmp->opresulttype)), parser_errposition(pstate, location))); } if (expression_returns_set((Node*)cmp)) { ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("row comparison operator must not return a set"), parser_errposition(pstate, location))); } opexprs = lappend(opexprs, cmp); } /* * If rows are length 1, just return the single operator. In this case we * don't insist on identifying btree semantics for the operator (but we * still require it to return boolean). */ if (nopers == 1) { return (Node*)linitial(opexprs); } /* * Now we must determine which row comparison semantics (= <> < <= > >=) * apply to this set of operators. We look for btree opfamilies * containing the operators, and see which interpretations (strategy * numbers) exist for each operator. */ opinfo_lists = (List**)palloc(nopers * sizeof(List*)); strats = NULL; i = 0; foreach (l, opexprs) { Oid opno = ((OpExpr*)lfirst(l))->opno; Bitmapset* this_strats = NULL; ListCell* j = NULL; opinfo_lists[i] = get_op_btree_interpretation(opno); /* * convert strategy numbers into a Bitmapset to make the intersection * calculation easy. */ this_strats = NULL; foreach (j, opinfo_lists[i]) { OpBtreeInterpretation* opinfo = (OpBtreeInterpretation*)lfirst(j); this_strats = bms_add_member(this_strats, opinfo->strategy); } if (i == 0) { strats = this_strats; } else { strats = bms_int_members(strats, this_strats); bms_free_ext(this_strats); } i++; } /* * If there are multiple common interpretations, we may use any one of * them ... this coding arbitrarily picks the lowest btree strategy * number. */ i = bms_first_member(strats); if (i < 0) { /* No common interpretation, so fail */ ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("could not determine interpretation of row comparison operator %s", strVal(llast(opname))), errhint("Row comparison operators must be associated with btree operator families."), parser_errposition(pstate, location))); } rctype = (RowCompareType)i; /* * For = and <> cases, we just combine the pairwise operators with AND or * OR respectively. * * Note: this is presently the only place where the parser generates * BoolExpr with more than two arguments. Should be OK since the rest of * the system thinks BoolExpr is N-argument anyway. */ if (rctype == ROWCOMPARE_EQ) { return (Node*)makeBoolExpr(AND_EXPR, opexprs, location); } if (rctype == ROWCOMPARE_NE) { return (Node*)makeBoolExpr(OR_EXPR, opexprs, location); } /* * Otherwise we need to choose exactly which opfamily to associate with * each operator. */ opfamilies = NIL; for (i = 0; i < nopers; i++) { Oid opfamily = InvalidOid; ListCell* j = NULL; foreach (j, opinfo_lists[i]) { OpBtreeInterpretation* opinfo = (OpBtreeInterpretation*)lfirst(j); if (opinfo->strategy == rctype) { opfamily = opinfo->opfamily_id; break; } } if (OidIsValid(opfamily)) { opfamilies = lappend_oid(opfamilies, opfamily); } else { /* should not happen */ ereport(ERROR, (errcode(ERRCODE_FEATURE_NOT_SUPPORTED), errmsg("could not determine interpretation of row comparison operator %s", strVal(llast(opname))), errdetail("There are multiple equally-plausible candidates."), parser_errposition(pstate, location))); } } /* * Now deconstruct the OpExprs and create a RowCompareExpr. * * Note: can't just reuse the passed largs/rargs lists, because of * possibility that make_op inserted coercion operations. */ opnos = NIL; largs = NIL; rargs = NIL; foreach (l, opexprs) { OpExpr* cmp = (OpExpr*)lfirst(l); opnos = lappend_oid(opnos, cmp->opno); largs = lappend(largs, linitial(cmp->args)); rargs = lappend(rargs, lsecond(cmp->args)); } rcexpr = makeNode(RowCompareExpr); rcexpr->rctype = rctype; rcexpr->opnos = opnos; rcexpr->opfamilies = opfamilies; rcexpr->inputcollids = NIL; /* assign_expr_collations will fix this */ rcexpr->largs = largs; rcexpr->rargs = rargs; return (Node*)rcexpr; } /* * Transform a "row IS DISTINCT FROM row" construct * * The input RowExprs are already transformed */ static Node* make_row_distinct_op(ParseState* pstate, List* opname, RowExpr* lrow, RowExpr* rrow, int location) { Node* result = NULL; List* largs = lrow->args; List* rargs = rrow->args; ListCell *l = NULL, *r = NULL; if (list_length(largs) != list_length(rargs)) { ereport(ERROR, (errcode(ERRCODE_SYNTAX_ERROR), errmsg("unequal number of entries in row expressions"), parser_errposition(pstate, location))); } forboth(l, largs, r, rargs) { Node* larg = (Node*)lfirst(l); Node* rarg = (Node*)lfirst(r); Node* cmp = NULL; cmp = (Node*)make_distinct_op(pstate, opname, larg, rarg, location); if (result == NULL) { result = cmp; } else { result = (Node*)makeBoolExpr(OR_EXPR, list_make2(result, cmp), location); } } if (result == NULL) { /* zero-length rows? Generate constant FALSE */ result = makeBoolConst(false, false); } return result; } /* * make the node for an IS DISTINCT FROM operator */ Expr* make_distinct_op(ParseState* pstate, List* opname, Node* ltree, Node* rtree, int location) { Expr* result = NULL; result = make_op(pstate, opname, ltree, rtree, location); if (((OpExpr*)result)->opresulttype != BOOLOID) { ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("IS DISTINCT FROM requires = operator to yield boolean"), parser_errposition(pstate, location))); } /* * We rely on DistinctExpr and OpExpr being same struct */ NodeSetTag(result, T_DistinctExpr); return result; } /* * Convert table.* to table.col1, table.col2, ...., table.coln. * * Only the following three cases are considered * A.* A is an unqualified table name; means whole-row value. * A.B.* whole-row value of table B in schema A. * A.B.C.* whole-row value of table C in schema B in catalog A. * * Currently, if a catalog name is given then it must equal the current * database name; we check it here and then discard it. * */ static Node* convertStarToCRef(RangeTblEntry* rte, char* catname, char* nspname, char* relname, int location) { RowExpr* re = makeNode(RowExpr); ListCell* c = NULL; foreach (c, rte->eref->colnames) { ColumnRef* column = makeNode(ColumnRef); char* theField = strVal(lfirst(c)); /* skip the dropped column */ if (NULL != theField && (*theField) == '\0') { continue; } column->fields = list_make1(makeString(pstrdup(theField))); /* deal with A.* */ if (relname != NULL) { column->fields = lcons(makeString(relname), column->fields); } /* deal with A.B.* */ if (nspname != NULL) { AssertEreport(relname, MOD_OPT, ""); column->fields = lcons(makeString(nspname), column->fields); } /* deal with A.B.C.* */ if (catname != NULL) { AssertEreport(relname, MOD_OPT, ""); AssertEreport(nspname, MOD_OPT, ""); column->fields = lcons(makeString(catname), column->fields); } column->location = -1; re->args = lappend(re->args, column); } re->row_typeid = InvalidOid; /* not analyzed yet */ re->colnames = NIL; /* to be filled in during analysis */ re->location = location; return (Node*)re; } /* * Check if the * */ static bool IsSequenceFuncCall(Node* filed1, Node* filed2, Node* filed3) { if (!IsA(filed3, String)) { return false; } char* relname = strVal(filed2); char* funcname = strVal(filed3); char* nspname = NULL; Oid nspid = InvalidOid; Assert(relname != NULL && funcname != NULL); if (filed1 != NULL) { nspname = strVal(filed1); nspid = get_namespace_oid(nspname, true); if (nspid == InvalidOid) { return false; } } if (strcmp(funcname, "nextval") == 0 || strcmp(funcname, "currval") == 0) { if (filed1 != NULL && RELKIND_IS_SEQUENCE(get_rel_relkind(get_relname_relid(relname, nspid)))) { return true; } else if (filed1 == NULL && RELKIND_IS_SEQUENCE(get_rel_relkind(RelnameGetRelid(relname)))) { return true; } } return false; } /* * start with transform support */ static Node *transformStartWithColumnRef(ParseState *pstate, ColumnRef *cref, char **colname) { Assert (*colname != NULL); Node *field1 = NULL; Node *field2 = NULL; char *local_column_ref = *colname; int len = list_length(cref->fields); switch (len) { case 1: { field1 = (Node*)linitial(cref->fields); if (pg_strcasecmp(local_column_ref, "connect_by_root") == 0 ) { Node *funexpr = transformConnectByRootFuncCall(pstate, field1, cref); /* * Return function funexpr, otherwise process * connect_by_root as regular case */ if (funexpr != NULL) { return funexpr; } } /* for pseudo column, we don't do column name replacement */ if (IsPseudoReturnColumn(local_column_ref) || pg_strcasecmp(local_column_ref, "connect_by_root") == 0) { return NULL; } char *relname = ColumnRefFindRelname(pstate, local_column_ref); if (relname == NULL) { elog(LOG, "do not find colname %s in sw-aborted RTE, maybe it's a normal column", *colname); return NULL; } *colname = makeStartWithDummayColname(relname, local_column_ref); field1 = (Node*)makeString(pstrdup(*colname)); cref->fields = list_make1(field1); break; } case 2: { field1 = (Node*)linitial(cref->fields); field2 = (Node*)lsecond(cref->fields); char *relname = strVal(field1); /* Already rewrite column once relname equal tmp_reuslt */ if (pg_strcasecmp(relname, "tmp_reuslt") == 0) { return NULL; } *colname = makeStartWithDummayColname(relname, local_column_ref); field1 = (Node *)makeString("tmp_reuslt"); field2 = (Node*)makeString(pstrdup(*colname)); cref->fields = list_make2(field1, field2); break; } default: break; } return NULL; } static Node* transformConnectByRootFuncCall(ParseState* pstate, Node* funcNameVal, ColumnRef *cref) { Assert (pg_strcasecmp(strVal(funcNameVal), "connect_by_root") == 0 && IsA(pstate->p_sw_selectstmt, SelectStmt)); /* find the targe column name */ List *targetlist = pstate->p_sw_selectstmt->targetList; ListCell *lc = NULL; char *relname = NULL; char *colname = NULL; /* scan SelectStmt's targetlist to find corresponding ColumnRef */ foreach (lc, targetlist) { ResTarget *rt = (ResTarget *)lfirst(lc); if (equal(rt->val, cref)) { colname = rt->name; /* * Indicate we do not find a case "connect_by_root column", so return to * transformColumnRef and treat conect_by_column as a regular RTE's entry */ if (colname == NULL) { return NULL; } relname = ColumnRefFindRelname(pstate, colname); if (relname == NULL) { elog(ERROR, "do not find colname %s in sw-aborted RTE", colname); return NULL; } colname = makeStartWithDummayColname(relname, colname); break; } } /* construct function call expr */ Value* argExpr = (Value *)makeColumnRef("tmp_reuslt", colname, -1); List* args = list_make1(argExpr); List* funcExpr = list_make1((Value*)funcNameVal); FuncCall* fn = makeFuncCall(funcExpr, args, cref->location); return transformFuncCall(pstate, fn); } /* * Note, currently, only support 1 fild ColumnRef, will expand to support multiple case */ static char *ColumnRefFindRelname(ParseState *pstate, const char *colname) { ListCell *lc1 = NULL; ListCell *lc2 = NULL; char *relname = NULL; int count = 0; while (pstate != NULL) { foreach(lc1, pstate->p_rtable) { RangeTblEntry *rte = (RangeTblEntry *)lfirst(lc1); if (!rte->swAborted) { continue; } if (rte->rtekind == RTE_RELATION || rte->rtekind == RTE_SUBQUERY || rte->rtekind == RTE_CTE) { List *colnames = rte->eref->colnames; foreach(lc2, colnames) { Value *col = (Value *)lfirst(lc2); if (strcmp(colname, strVal(col)) == 0) { if (rte->rtekind == RTE_RELATION) { relname = (rte->alias && rte->alias->aliasname) ? rte->alias->aliasname : rte->relname; } else if (rte->rtekind == RTE_SUBQUERY) { relname = rte->alias->aliasname; } else if (rte->rtekind == RTE_CTE) { relname = (rte->alias && rte->alias->aliasname) ? rte->alias->aliasname : rte->ctename; } count++; } } } } /* If we found just break */ if (count > 1) { ereport(ERROR, (errcode(ERRCODE_AMBIGUOUS_COLUMN), errmsg("column reference \"%s\" is ambiguous", colname))); } if (count == 1) { break; } pstate = pstate->parentParseState; } return relname; } /* * Transform a PrefixKey. */ static Node* transformPrefixKey(ParseState* pstate, PrefixKey* pkey) { Node *argnode = (Node*)pkey->arg; int maxlen; int location = ((ColumnRef*)argnode)->location; Assert(nodeTag(argnode) == T_ColumnRef); if (pkey->length <= 0 || pkey->length > INDEX_KEY_MAX_PREFIX_LENGTH) { ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("index key prefix length(%d) must be positive and cannot exceed %d", pkey->length, INDEX_KEY_MAX_PREFIX_LENGTH), parser_errposition(pstate, location))); } argnode = transformExpr(pstate, argnode); Assert(nodeTag(argnode) == T_Var); switch (((Var*)argnode)->vartype) { case TEXTOID: case CLOBOID: case BPCHAROID: case VARCHAROID: case NVARCHAR2OID: case BLOBOID: case RAWOID: case BYTEAOID: pkey->arg = (Expr*)argnode; break; default: ereport(ERROR, (errcode(ERRCODE_DATATYPE_MISMATCH), errmsg("index prefix key are not supported by column type %s", format_type_be(((Var*)argnode)->vartype)), parser_errposition(pstate, location))); } maxlen = ((Var*)argnode)->vartypmod; if (maxlen > 0) { maxlen -= VARHDRSZ; if (pkey->length > maxlen) { ereport(ERROR, (errcode(ERRCODE_PROGRAM_LIMIT_EXCEEDED), errmsg("index key prefix length(%d) too long for type %s(%d)", pkey->length, format_type_be(((Var*)argnode)->vartype), maxlen), parser_errposition(pstate, location))); } } return (Node*)pkey; }