nodeFuncs.c File Reference (original) (raw)

2953{

2954

2955

2956

2957

2958

2959#define FLATCOPY(newnode, node, nodetype) \

2960 ( (newnode) = (nodetype *) palloc(sizeof(nodetype)), \

2961 memcpy((newnode), (node), sizeof(nodetype)) )

2962

2963#define MUTATE(newfield, oldfield, fieldtype) \

2964 ( (newfield) = (fieldtype) mutator((Node *) (oldfield), context) )

2965

2966 if (node == NULL)

2967 return NULL;

2968

2969

2971

2973 {

2974

2975

2976

2977

2978

2979 case T_Var:

2980 {

2981 Var *var = (Var *) node;

2982 Var *newnode;

2983

2985

2986 return (Node *) newnode;

2987 }

2988 break;

2989 case T_Const:

2990 {

2993

2995

2996 return (Node *) newnode;

2997 }

2998 break;

2999 case T_Param:

3000 case T_CaseTestExpr:

3001 case T_SQLValueFunction:

3002 case T_JsonFormat:

3003 case T_CoerceToDomainValue:

3004 case T_SetToDefault:

3005 case T_CurrentOfExpr:

3006 case T_NextValueExpr:

3007 case T_RangeTblRef:

3008 case T_SortGroupClause:

3009 case T_CTESearchClause:

3010 case T_MergeSupportFunc:

3012 case T_WithCheckOption:

3013 {

3016

3019 return (Node *) newnode;

3020 }

3021 case T_Aggref:

3022 {

3025

3027

3028 newnode->aggargtypes = list_copy(aggref->aggargtypes);

3034 return (Node *) newnode;

3035 }

3036 break;

3037 case T_GroupingFunc:

3038 {

3041

3043 MUTATE(newnode->args, grouping->args, List *);

3044

3045

3046

3047

3048

3049

3050

3051

3052

3053

3054 newnode->refs = list_copy(grouping->refs);

3055 newnode->cols = list_copy(grouping->cols);

3056

3057 return (Node *) newnode;

3058 }

3059 break;

3060 case T_WindowFunc:

3061 {

3064

3068 return (Node *) newnode;

3069 }

3070 break;

3071 case T_WindowFuncRunCondition:

3072 {

3075

3078 return (Node *) newnode;

3079 }

3080 break;

3081 case T_SubscriptingRef:

3082 {

3085

3095

3096 return (Node *) newnode;

3097 }

3098 break;

3099 case T_FuncExpr:

3100 {

3103

3106 return (Node *) newnode;

3107 }

3108 break;

3109 case T_NamedArgExpr:

3110 {

3113

3116 return (Node *) newnode;

3117 }

3118 break;

3119 case T_OpExpr:

3120 {

3123

3126 return (Node *) newnode;

3127 }

3128 break;

3129 case T_DistinctExpr:

3130 {

3133

3136 return (Node *) newnode;

3137 }

3138 break;

3139 case T_NullIfExpr:

3140 {

3143

3146 return (Node *) newnode;

3147 }

3148 break;

3149 case T_ScalarArrayOpExpr:

3150 {

3153

3156 return (Node *) newnode;

3157 }

3158 break;

3159 case T_BoolExpr:

3160 {

3163

3166 return (Node *) newnode;

3167 }

3168 break;

3169 case T_SubLink:

3170 {

3173

3176

3177

3178

3179

3180

3182 return (Node *) newnode;

3183 }

3184 break;

3185 case T_SubPlan:

3186 {

3189

3191

3193

3195

3196 return (Node *) newnode;

3197 }

3198 break;

3199 case T_AlternativeSubPlan:

3200 {

3203

3206 return (Node *) newnode;

3207 }

3208 break;

3209 case T_FieldSelect:

3210 {

3213

3216 return (Node *) newnode;

3217 }

3218 break;

3219 case T_FieldStore:

3220 {

3223

3227 newnode->fieldnums = list_copy(fstore->fieldnums);

3228 return (Node *) newnode;

3229 }

3230 break;

3231 case T_RelabelType:

3232 {

3235

3238 return (Node *) newnode;

3239 }

3240 break;

3241 case T_CoerceViaIO:

3242 {

3245

3248 return (Node *) newnode;

3249 }

3250 break;

3251 case T_ArrayCoerceExpr:

3252 {

3255

3259 return (Node *) newnode;

3260 }

3261 break;

3262 case T_ConvertRowtypeExpr:

3263 {

3266

3269 return (Node *) newnode;

3270 }

3271 break;

3272 case T_CollateExpr:

3273 {

3276

3279 return (Node *) newnode;

3280 }

3281 break;

3282 case T_CaseExpr:

3283 {

3286

3291 return (Node *) newnode;

3292 }

3293 break;

3294 case T_CaseWhen:

3295 {

3298

3302 return (Node *) newnode;

3303 }

3304 break;

3305 case T_ArrayExpr:

3306 {

3309

3311 MUTATE(newnode->elements, arrayexpr->elements, List *);

3312 return (Node *) newnode;

3313 }

3314 break;

3315 case T_RowExpr:

3316 {

3319

3322

3323 return (Node *) newnode;

3324 }

3325 break;

3326 case T_RowCompareExpr:

3327 {

3330

3334 return (Node *) newnode;

3335 }

3336 break;

3337 case T_CoalesceExpr:

3338 {

3341

3344 return (Node *) newnode;

3345 }

3346 break;

3347 case T_MinMaxExpr:

3348 {

3351

3354 return (Node *) newnode;

3355 }

3356 break;

3357 case T_XmlExpr:

3358 {

3361

3364

3366 return (Node *) newnode;

3367 }

3368 break;

3369 case T_JsonReturning:

3370 {

3373

3376

3377 return (Node *) newnode;

3378 }

3379 case T_JsonValueExpr:

3380 {

3383

3388

3389 return (Node *) newnode;

3390 }

3391 case T_JsonConstructorExpr:

3392 {

3395

3401

3402 return (Node *) newnode;

3403 }

3404 case T_JsonIsPredicate:

3405 {

3408

3412

3413 return (Node *) newnode;

3414 }

3415 case T_JsonExpr:

3416 {

3419

3424

3427 return (Node *) newnode;

3428 }

3429 break;

3430 case T_JsonBehavior:

3431 {

3434

3437 return (Node *) newnode;

3438 }

3439 break;

3440 case T_NullTest:

3441 {

3444

3447 return (Node *) newnode;

3448 }

3449 break;

3450 case T_BooleanTest:

3451 {

3454

3457 return (Node *) newnode;

3458 }

3459 break;

3460 case T_CoerceToDomain:

3461 {

3464

3467 return (Node *) newnode;

3468 }

3469 break;

3470 case T_ReturningExpr:

3471 {

3474

3477 return (Node *) newnode;

3478 }

3479 break;

3480 case T_TargetEntry:

3481 {

3484

3487 return (Node *) newnode;

3488 }

3489 break;

3490 case T_Query:

3491

3492 return node;

3493 case T_WindowClause:

3494 {

3497

3503 return (Node *) newnode;

3504 }

3505 break;

3506 case T_CTECycleClause:

3507 {

3510

3514 return (Node *) newnode;

3515 }

3516 break;

3517 case T_CommonTableExpr:

3518 {

3521

3523

3524

3525

3526

3527

3529

3532

3533 return (Node *) newnode;

3534 }

3535 break;

3536 case T_PartitionBoundSpec:

3537 {

3540

3545 return (Node *) newnode;

3546 }

3547 break;

3548 case T_PartitionRangeDatum:

3549 {

3552

3555 return (Node *) newnode;

3556 }

3557 break;

3558 case T_List:

3559 {

3560

3561

3562

3563

3564

3565 List *resultlist;

3567

3568 resultlist = NIL;

3569 foreach(temp, (List *) node)

3570 {

3571 resultlist = lappend(resultlist,

3573 context));

3574 }

3575 return (Node *) resultlist;

3576 }

3577 break;

3578 case T_FromExpr:

3579 {

3582

3586 return (Node *) newnode;

3587 }

3588 break;

3589 case T_OnConflictExpr:

3590 {

3593

3600

3601 return (Node *) newnode;

3602 }

3603 break;

3604 case T_MergeAction:

3605 {

3608

3612

3613 return (Node *) newnode;

3614 }

3615 break;

3616 case T_PartitionPruneStepOp:

3617 {

3620

3623

3624 return (Node *) newnode;

3625 }

3626 break;

3627 case T_PartitionPruneStepCombine:

3628

3630 case T_JoinExpr:

3631 {

3634

3639

3640 return (Node *) newnode;

3641 }

3642 break;

3643 case T_SetOperationStmt:

3644 {

3647

3651

3652 return (Node *) newnode;

3653 }

3654 break;

3655 case T_IndexClause:

3656 {

3659

3663 return (Node *) newnode;

3664 }

3665 break;

3666 case T_PlaceHolderVar:

3667 {

3670

3672 MUTATE(newnode->phexpr, phv->phexpr, Expr *);

3673

3674 return (Node *) newnode;

3675 }

3676 break;

3677 case T_InferenceElem:

3678 {

3681

3684 return (Node *) newnode;

3685 }

3686 break;

3687 case T_AppendRelInfo:

3688 {

3691

3694

3695 return (Node *) newnode;

3696 }

3697 break;

3698 case T_PlaceHolderInfo:

3699 {

3702

3705

3706 return (Node *) newnode;

3707 }

3708 break;

3709 case T_RangeTblFunction:

3710 {

3713

3716

3717 return (Node *) newnode;

3718 }

3719 break;

3720 case T_TableSampleClause:

3721 {

3724

3728 return (Node *) newnode;

3729 }

3730 break;

3731 case T_TableFunc:

3732 {

3735

3737 MUTATE(newnode->ns_uris, tf->ns_uris, List *);

3741 MUTATE(newnode->coldefexprs, tf->coldefexprs, List *);

3742 MUTATE(newnode->colvalexprs, tf->colvalexprs, List *);

3743 MUTATE(newnode->passingvalexprs, tf->passingvalexprs, List *);

3744 return (Node *) newnode;

3745 }

3746 break;

3747 default:

3748 elog(ERROR, "unrecognized node type: %d",

3750 break;

3751 }

3752

3753 return NULL;

3754}

List * lappend(List *list, void *datum)

List * list_copy(const List *oldlist)

#define FLATCOPY(newnode, node, nodetype)

#define MUTATE(newfield, oldfield, fieldtype)

void check_stack_depth(void)

Node * cycle_mark_default

struct RestrictInfo * rinfo

JsonReturning * returning