copyfuncs.c

Go to the documentation of this file.

/*-------------------------------------------------------------------------
 *
 * copyfuncs.c
 *    Copy functions for Postgres tree nodes.
 *
 * NOTE: we currently support copying all node types found in parse and
 * plan trees.  We do not support copying executor state trees; there
 * is no need for that, and no point in maintaining all the code that
 * would be needed.  We also do not support copying Path trees, mainly
 * because the circular linkages between RelOptInfo and Path nodes can't
 * be handled easily in a simple depth-first traversal.
 *
 *
 * Portions Copyright (c) 1996-2022, PostgreSQL Global Development Group
 * Portions Copyright (c) 1994, Regents of the University of California
 *
 * IDENTIFICATION
 *    src/backend/nodes/copyfuncs.c
 *
 *-------------------------------------------------------------------------
 */
 
#include "postgres.h"
 
#include "miscadmin.h"
#include "nodes/extensible.h"
#include "nodes/pathnodes.h"
#include "nodes/plannodes.h"
#include "utils/datum.h"
#include "utils/rel.h"
 
 
/*
 * Macros to simplify copying of different kinds of fields.  Use these
 * wherever possible to reduce the chance for silly typos.  Note that these
 * hard-wire the convention that the local variables in a Copy routine are
 * named 'newnode' and 'from'.
 */
 
/* Copy a simple scalar field (int, float, bool, enum, etc) */
#define COPY_SCALAR_FIELD(fldname) \
    (newnode->fldname = from->fldname)
 
/* Copy a field that is a pointer to some kind of Node or Node tree */
#define COPY_NODE_FIELD(fldname) \
    (newnode->fldname = copyObjectImpl(from->fldname))
 
/* Copy a field that is a pointer to a Bitmapset */
#define COPY_BITMAPSET_FIELD(fldname) \
    (newnode->fldname = bms_copy(from->fldname))
 
/* Copy a field that is a pointer to a C string, or perhaps NULL */
#define COPY_STRING_FIELD(fldname) \
    (newnode->fldname = from->fldname ? pstrdup(from->fldname) : (char *) NULL)
 
/* Copy a field that is an inline array */
#define COPY_ARRAY_FIELD(fldname) \
    memcpy(newnode->fldname, from->fldname, sizeof(newnode->fldname))
 
/* Copy a field that is a pointer to a simple palloc'd object of size sz */
#define COPY_POINTER_FIELD(fldname, sz) \
    do { \
        Size    _size = (sz); \
        if (_size > 0) \
        { \
            newnode->fldname = palloc(_size); \
            memcpy(newnode->fldname, from->fldname, _size); \
        } \
    } while (0)
 
/* Copy a parse location field (for Copy, this is same as scalar case) */
#define COPY_LOCATION_FIELD(fldname) \
    (newnode->fldname = from->fldname)
 
 
/* ****************************************************************
 *                   plannodes.h copy functions
 * ****************************************************************
 */
 
/*
 * _copyPlannedStmt
 */
static PlannedStmt *
_copyPlannedStmt(const PlannedStmt *from)
{
    PlannedStmt *newnode = makeNode(PlannedStmt);
 
    COPY_SCALAR_FIELD(commandType);
    COPY_SCALAR_FIELD(queryId);
    COPY_SCALAR_FIELD(hasReturning);
    COPY_SCALAR_FIELD(hasModifyingCTE);
    COPY_SCALAR_FIELD(canSetTag);
    COPY_SCALAR_FIELD(transientPlan);
    COPY_SCALAR_FIELD(dependsOnRole);
    COPY_SCALAR_FIELD(parallelModeNeeded);
    COPY_SCALAR_FIELD(jitFlags);
    COPY_NODE_FIELD(planTree);
    COPY_NODE_FIELD(rtable);
    COPY_NODE_FIELD(resultRelations);
    COPY_NODE_FIELD(appendRelations);
    COPY_NODE_FIELD(subplans);
    COPY_BITMAPSET_FIELD(rewindPlanIDs);
    COPY_NODE_FIELD(rowMarks);
    COPY_NODE_FIELD(relationOids);
    COPY_NODE_FIELD(invalItems);
    COPY_NODE_FIELD(paramExecTypes);
    COPY_NODE_FIELD(utilityStmt);
    COPY_LOCATION_FIELD(stmt_location);
    COPY_SCALAR_FIELD(stmt_len);
 
    return newnode;
}
 
/*
 * CopyPlanFields
 *
 *      This function copies the fields of the Plan node.  It is used by
 *      all the copy functions for classes which inherit from Plan.
 */
static void
CopyPlanFields(const Plan *from, Plan *newnode)
{
    COPY_SCALAR_FIELD(startup_cost);
    COPY_SCALAR_FIELD(total_cost);
    COPY_SCALAR_FIELD(plan_rows);
    COPY_SCALAR_FIELD(plan_width);
    COPY_SCALAR_FIELD(parallel_aware);
    COPY_SCALAR_FIELD(parallel_safe);
    COPY_SCALAR_FIELD(async_capable);
    COPY_SCALAR_FIELD(plan_node_id);
    COPY_NODE_FIELD(targetlist);
    COPY_NODE_FIELD(qual);
    COPY_NODE_FIELD(lefttree);
    COPY_NODE_FIELD(righttree);
    COPY_NODE_FIELD(initPlan);
    COPY_BITMAPSET_FIELD(extParam);
    COPY_BITMAPSET_FIELD(allParam);
}
 
/*
 * _copyPlan
 */
static Plan *
_copyPlan(const Plan *from)
{
    Plan       *newnode = makeNode(Plan);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields(from, newnode);
 
    return newnode;
}
 
 
/*
 * _copyResult
 */
static Result *
_copyResult(const Result *from)
{
    Result     *newnode = makeNode(Result);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_NODE_FIELD(resconstantqual);
 
    return newnode;
}
 
/*
 * _copyProjectSet
 */
static ProjectSet *
_copyProjectSet(const ProjectSet *from)
{
    ProjectSet *newnode = makeNode(ProjectSet);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    return newnode;
}
 
/*
 * _copyModifyTable
 */
static ModifyTable *
_copyModifyTable(const ModifyTable *from)
{
    ModifyTable *newnode = makeNode(ModifyTable);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(operation);
    COPY_SCALAR_FIELD(canSetTag);
    COPY_SCALAR_FIELD(nominalRelation);
    COPY_SCALAR_FIELD(rootRelation);
    COPY_SCALAR_FIELD(partColsUpdated);
    COPY_NODE_FIELD(resultRelations);
    COPY_NODE_FIELD(updateColnosLists);
    COPY_NODE_FIELD(withCheckOptionLists);
    COPY_NODE_FIELD(returningLists);
    COPY_NODE_FIELD(fdwPrivLists);
    COPY_BITMAPSET_FIELD(fdwDirectModifyPlans);
    COPY_NODE_FIELD(rowMarks);
    COPY_SCALAR_FIELD(epqParam);
    COPY_SCALAR_FIELD(onConflictAction);
    COPY_NODE_FIELD(arbiterIndexes);
    COPY_NODE_FIELD(onConflictSet);
    COPY_NODE_FIELD(onConflictCols);
    COPY_NODE_FIELD(onConflictWhere);
    COPY_SCALAR_FIELD(exclRelRTI);
    COPY_NODE_FIELD(exclRelTlist);
    COPY_NODE_FIELD(mergeActionLists);
 
    return newnode;
}
 
/*
 * _copyAppend
 */
static Append *
_copyAppend(const Append *from)
{
    Append     *newnode = makeNode(Append);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_BITMAPSET_FIELD(apprelids);
    COPY_NODE_FIELD(appendplans);
    COPY_SCALAR_FIELD(nasyncplans);
    COPY_SCALAR_FIELD(first_partial_plan);
    COPY_NODE_FIELD(part_prune_info);
 
    return newnode;
}
 
/*
 * _copyMergeAppend
 */
static MergeAppend *
_copyMergeAppend(const MergeAppend *from)
{
    MergeAppend *newnode = makeNode(MergeAppend);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_BITMAPSET_FIELD(apprelids);
    COPY_NODE_FIELD(mergeplans);
    COPY_SCALAR_FIELD(numCols);
    COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
    COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid));
    COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid));
    COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool));
    COPY_NODE_FIELD(part_prune_info);
 
    return newnode;
}
 
/*
 * _copyRecursiveUnion
 */
static RecursiveUnion *
_copyRecursiveUnion(const RecursiveUnion *from)
{
    RecursiveUnion *newnode = makeNode(RecursiveUnion);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(wtParam);
    COPY_SCALAR_FIELD(numCols);
    COPY_POINTER_FIELD(dupColIdx, from->numCols * sizeof(AttrNumber));
    COPY_POINTER_FIELD(dupOperators, from->numCols * sizeof(Oid));
    COPY_POINTER_FIELD(dupCollations, from->numCols * sizeof(Oid));
    COPY_SCALAR_FIELD(numGroups);
 
    return newnode;
}
 
/*
 * _copyBitmapAnd
 */
static BitmapAnd *
_copyBitmapAnd(const BitmapAnd *from)
{
    BitmapAnd  *newnode = makeNode(BitmapAnd);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_NODE_FIELD(bitmapplans);
 
    return newnode;
}
 
/*
 * _copyBitmapOr
 */
static BitmapOr *
_copyBitmapOr(const BitmapOr *from)
{
    BitmapOr   *newnode = makeNode(BitmapOr);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(isshared);
    COPY_NODE_FIELD(bitmapplans);
 
    return newnode;
}
 
/*
 * _copyGather
 */
static Gather *
_copyGather(const Gather *from)
{
    Gather     *newnode = makeNode(Gather);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(num_workers);
    COPY_SCALAR_FIELD(rescan_param);
    COPY_SCALAR_FIELD(single_copy);
    COPY_SCALAR_FIELD(invisible);
    COPY_BITMAPSET_FIELD(initParam);
 
    return newnode;
}
 
/*
 * _copyGatherMerge
 */
static GatherMerge *
_copyGatherMerge(const GatherMerge *from)
{
    GatherMerge *newnode = makeNode(GatherMerge);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(num_workers);
    COPY_SCALAR_FIELD(rescan_param);
    COPY_SCALAR_FIELD(numCols);
    COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
    COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid));
    COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid));
    COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool));
    COPY_BITMAPSET_FIELD(initParam);
 
    return newnode;
}
 
/*
 * CopyScanFields
 *
 *      This function copies the fields of the Scan node.  It is used by
 *      all the copy functions for classes which inherit from Scan.
 */
static void
CopyScanFields(const Scan *from, Scan *newnode)
{
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    COPY_SCALAR_FIELD(scanrelid);
}
 
/*
 * _copyScan
 */
static Scan *
_copyScan(const Scan *from)
{
    Scan       *newnode = makeNode(Scan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    return newnode;
}
 
/*
 * _copySeqScan
 */
static SeqScan *
_copySeqScan(const SeqScan *from)
{
    SeqScan    *newnode = makeNode(SeqScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    return newnode;
}
 
/*
 * _copySampleScan
 */
static SampleScan *
_copySampleScan(const SampleScan *from)
{
    SampleScan *newnode = makeNode(SampleScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_NODE_FIELD(tablesample);
 
    return newnode;
}
 
/*
 * _copyIndexScan
 */
static IndexScan *
_copyIndexScan(const IndexScan *from)
{
    IndexScan  *newnode = makeNode(IndexScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(indexid);
    COPY_NODE_FIELD(indexqual);
    COPY_NODE_FIELD(indexqualorig);
    COPY_NODE_FIELD(indexorderby);
    COPY_NODE_FIELD(indexorderbyorig);
    COPY_NODE_FIELD(indexorderbyops);
    COPY_SCALAR_FIELD(indexorderdir);
 
    return newnode;
}
 
/*
 * _copyIndexOnlyScan
 */
static IndexOnlyScan *
_copyIndexOnlyScan(const IndexOnlyScan *from)
{
    IndexOnlyScan *newnode = makeNode(IndexOnlyScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(indexid);
    COPY_NODE_FIELD(indexqual);
    COPY_NODE_FIELD(recheckqual);
    COPY_NODE_FIELD(indexorderby);
    COPY_NODE_FIELD(indextlist);
    COPY_SCALAR_FIELD(indexorderdir);
 
    return newnode;
}
 
/*
 * _copyBitmapIndexScan
 */
static BitmapIndexScan *
_copyBitmapIndexScan(const BitmapIndexScan *from)
{
    BitmapIndexScan *newnode = makeNode(BitmapIndexScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(indexid);
    COPY_SCALAR_FIELD(isshared);
    COPY_NODE_FIELD(indexqual);
    COPY_NODE_FIELD(indexqualorig);
 
    return newnode;
}
 
/*
 * _copyBitmapHeapScan
 */
static BitmapHeapScan *
_copyBitmapHeapScan(const BitmapHeapScan *from)
{
    BitmapHeapScan *newnode = makeNode(BitmapHeapScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_NODE_FIELD(bitmapqualorig);
 
    return newnode;
}
 
/*
 * _copyTidScan
 */
static TidScan *
_copyTidScan(const TidScan *from)
{
    TidScan    *newnode = makeNode(TidScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_NODE_FIELD(tidquals);
 
    return newnode;
}
 
/*
 * _copyTidRangeScan
 */
static TidRangeScan *
_copyTidRangeScan(const TidRangeScan *from)
{
    TidRangeScan *newnode = makeNode(TidRangeScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_NODE_FIELD(tidrangequals);
 
    return newnode;
}
 
/*
 * _copySubqueryScan
 */
static SubqueryScan *
_copySubqueryScan(const SubqueryScan *from)
{
    SubqueryScan *newnode = makeNode(SubqueryScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_NODE_FIELD(subplan);
    COPY_SCALAR_FIELD(scanstatus);
 
    return newnode;
}
 
/*
 * _copyFunctionScan
 */
static FunctionScan *
_copyFunctionScan(const FunctionScan *from)
{
    FunctionScan *newnode = makeNode(FunctionScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_NODE_FIELD(functions);
    COPY_SCALAR_FIELD(funcordinality);
 
    return newnode;
}
 
/*
 * _copyTableFuncScan
 */
static TableFuncScan *
_copyTableFuncScan(const TableFuncScan *from)
{
    TableFuncScan *newnode = makeNode(TableFuncScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_NODE_FIELD(tablefunc);
 
    return newnode;
}
 
/*
 * _copyValuesScan
 */
static ValuesScan *
_copyValuesScan(const ValuesScan *from)
{
    ValuesScan *newnode = makeNode(ValuesScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_NODE_FIELD(values_lists);
 
    return newnode;
}
 
/*
 * _copyCteScan
 */
static CteScan *
_copyCteScan(const CteScan *from)
{
    CteScan    *newnode = makeNode(CteScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(ctePlanId);
    COPY_SCALAR_FIELD(cteParam);
 
    return newnode;
}
 
/*
 * _copyNamedTuplestoreScan
 */
static NamedTuplestoreScan *
_copyNamedTuplestoreScan(const NamedTuplestoreScan *from)
{
    NamedTuplestoreScan *newnode = makeNode(NamedTuplestoreScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_STRING_FIELD(enrname);
 
    return newnode;
}
 
/*
 * _copyWorkTableScan
 */
static WorkTableScan *
_copyWorkTableScan(const WorkTableScan *from)
{
    WorkTableScan *newnode = makeNode(WorkTableScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(wtParam);
 
    return newnode;
}
 
/*
 * _copyForeignScan
 */
static ForeignScan *
_copyForeignScan(const ForeignScan *from)
{
    ForeignScan *newnode = makeNode(ForeignScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(operation);
    COPY_SCALAR_FIELD(resultRelation);
    COPY_SCALAR_FIELD(fs_server);
    COPY_NODE_FIELD(fdw_exprs);
    COPY_NODE_FIELD(fdw_private);
    COPY_NODE_FIELD(fdw_scan_tlist);
    COPY_NODE_FIELD(fdw_recheck_quals);
    COPY_BITMAPSET_FIELD(fs_relids);
    COPY_SCALAR_FIELD(fsSystemCol);
 
    return newnode;
}
 
/*
 * _copyCustomScan
 */
static CustomScan *
_copyCustomScan(const CustomScan *from)
{
    CustomScan *newnode = makeNode(CustomScan);
 
    /*
     * copy node superclass fields
     */
    CopyScanFields((const Scan *) from, (Scan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(flags);
    COPY_NODE_FIELD(custom_plans);
    COPY_NODE_FIELD(custom_exprs);
    COPY_NODE_FIELD(custom_private);
    COPY_NODE_FIELD(custom_scan_tlist);
    COPY_BITMAPSET_FIELD(custom_relids);
 
    /*
     * NOTE: The method field of CustomScan is required to be a pointer to a
     * static table of callback functions.  So we don't copy the table itself,
     * just reference the original one.
     */
    COPY_SCALAR_FIELD(methods);
 
    return newnode;
}
 
/*
 * CopyJoinFields
 *
 *      This function copies the fields of the Join node.  It is used by
 *      all the copy functions for classes which inherit from Join.
 */
static void
CopyJoinFields(const Join *from, Join *newnode)
{
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    COPY_SCALAR_FIELD(jointype);
    COPY_SCALAR_FIELD(inner_unique);
    COPY_NODE_FIELD(joinqual);
}
 
 
/*
 * _copyJoin
 */
static Join *
_copyJoin(const Join *from)
{
    Join       *newnode = makeNode(Join);
 
    /*
     * copy node superclass fields
     */
    CopyJoinFields(from, newnode);
 
    return newnode;
}
 
 
/*
 * _copyNestLoop
 */
static NestLoop *
_copyNestLoop(const NestLoop *from)
{
    NestLoop   *newnode = makeNode(NestLoop);
 
    /*
     * copy node superclass fields
     */
    CopyJoinFields((const Join *) from, (Join *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_NODE_FIELD(nestParams);
 
    return newnode;
}
 
 
/*
 * _copyMergeJoin
 */
static MergeJoin *
_copyMergeJoin(const MergeJoin *from)
{
    MergeJoin  *newnode = makeNode(MergeJoin);
    int         numCols;
 
    /*
     * copy node superclass fields
     */
    CopyJoinFields((const Join *) from, (Join *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(skip_mark_restore);
    COPY_NODE_FIELD(mergeclauses);
    numCols = list_length(from->mergeclauses);
    COPY_POINTER_FIELD(mergeFamilies, numCols * sizeof(Oid));
    COPY_POINTER_FIELD(mergeCollations, numCols * sizeof(Oid));
    COPY_POINTER_FIELD(mergeStrategies, numCols * sizeof(int));
    COPY_POINTER_FIELD(mergeNullsFirst, numCols * sizeof(bool));
 
    return newnode;
}
 
/*
 * _copyHashJoin
 */
static HashJoin *
_copyHashJoin(const HashJoin *from)
{
    HashJoin   *newnode = makeNode(HashJoin);
 
    /*
     * copy node superclass fields
     */
    CopyJoinFields((const Join *) from, (Join *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_NODE_FIELD(hashclauses);
    COPY_NODE_FIELD(hashoperators);
    COPY_NODE_FIELD(hashcollations);
    COPY_NODE_FIELD(hashkeys);
 
    return newnode;
}
 
 
/*
 * _copyMaterial
 */
static Material *
_copyMaterial(const Material *from)
{
    Material   *newnode = makeNode(Material);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    return newnode;
}
 
 
/*
 * _copyMemoize
 */
static Memoize *
_copyMemoize(const Memoize *from)
{
    Memoize    *newnode = makeNode(Memoize);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(numKeys);
    COPY_POINTER_FIELD(hashOperators, sizeof(Oid) * from->numKeys);
    COPY_POINTER_FIELD(collations, sizeof(Oid) * from->numKeys);
    COPY_NODE_FIELD(param_exprs);
    COPY_SCALAR_FIELD(singlerow);
    COPY_SCALAR_FIELD(binary_mode);
    COPY_SCALAR_FIELD(est_entries);
    COPY_BITMAPSET_FIELD(keyparamids);
 
    return newnode;
}
 
 
/*
 * CopySortFields
 *
 *      This function copies the fields of the Sort node.  It is used by
 *      all the copy functions for classes which inherit from Sort.
 */
static void
CopySortFields(const Sort *from, Sort *newnode)
{
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    COPY_SCALAR_FIELD(numCols);
    COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
    COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid));
    COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid));
    COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool));
}
 
/*
 * _copySort
 */
static Sort *
_copySort(const Sort *from)
{
    Sort       *newnode = makeNode(Sort);
 
    /*
     * copy node superclass fields
     */
    CopySortFields(from, newnode);
 
    return newnode;
}
 
 
/*
 * _copyIncrementalSort
 */
static IncrementalSort *
_copyIncrementalSort(const IncrementalSort *from)
{
    IncrementalSort *newnode = makeNode(IncrementalSort);
 
    /*
     * copy node superclass fields
     */
    CopySortFields((const Sort *) from, (Sort *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(nPresortedCols);
 
    return newnode;
}
 
 
/*
 * _copyGroup
 */
static Group *
_copyGroup(const Group *from)
{
    Group      *newnode = makeNode(Group);
 
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    COPY_SCALAR_FIELD(numCols);
    COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
    COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid));
    COPY_POINTER_FIELD(grpCollations, from->numCols * sizeof(Oid));
 
    return newnode;
}
 
/*
 * _copyAgg
 */
static Agg *
_copyAgg(const Agg *from)
{
    Agg        *newnode = makeNode(Agg);
 
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    COPY_SCALAR_FIELD(aggstrategy);
    COPY_SCALAR_FIELD(aggsplit);
    COPY_SCALAR_FIELD(numCols);
    COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
    COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid));
    COPY_POINTER_FIELD(grpCollations, from->numCols * sizeof(Oid));
    COPY_SCALAR_FIELD(numGroups);
    COPY_SCALAR_FIELD(transitionSpace);
    COPY_BITMAPSET_FIELD(aggParams);
    COPY_NODE_FIELD(groupingSets);
    COPY_NODE_FIELD(chain);
 
    return newnode;
}
 
/*
 * _copyWindowAgg
 */
static WindowAgg *
_copyWindowAgg(const WindowAgg *from)
{
    WindowAgg  *newnode = makeNode(WindowAgg);
 
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    COPY_SCALAR_FIELD(winref);
    COPY_SCALAR_FIELD(partNumCols);
    COPY_POINTER_FIELD(partColIdx, from->partNumCols * sizeof(AttrNumber));
    COPY_POINTER_FIELD(partOperators, from->partNumCols * sizeof(Oid));
    COPY_POINTER_FIELD(partCollations, from->partNumCols * sizeof(Oid));
    COPY_SCALAR_FIELD(ordNumCols);
    COPY_POINTER_FIELD(ordColIdx, from->ordNumCols * sizeof(AttrNumber));
    COPY_POINTER_FIELD(ordOperators, from->ordNumCols * sizeof(Oid));
    COPY_POINTER_FIELD(ordCollations, from->ordNumCols * sizeof(Oid));
    COPY_SCALAR_FIELD(frameOptions);
    COPY_NODE_FIELD(startOffset);
    COPY_NODE_FIELD(endOffset);
    COPY_NODE_FIELD(runCondition);
    COPY_NODE_FIELD(runConditionOrig);
    COPY_SCALAR_FIELD(startInRangeFunc);
    COPY_SCALAR_FIELD(endInRangeFunc);
    COPY_SCALAR_FIELD(inRangeColl);
    COPY_SCALAR_FIELD(inRangeAsc);
    COPY_SCALAR_FIELD(inRangeNullsFirst);
    COPY_SCALAR_FIELD(topWindow);
 
    return newnode;
}
 
/*
 * _copyUnique
 */
static Unique *
_copyUnique(const Unique *from)
{
    Unique     *newnode = makeNode(Unique);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(numCols);
    COPY_POINTER_FIELD(uniqColIdx, from->numCols * sizeof(AttrNumber));
    COPY_POINTER_FIELD(uniqOperators, from->numCols * sizeof(Oid));
    COPY_POINTER_FIELD(uniqCollations, from->numCols * sizeof(Oid));
 
    return newnode;
}
 
/*
 * _copyHash
 */
static Hash *
_copyHash(const Hash *from)
{
    Hash       *newnode = makeNode(Hash);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_NODE_FIELD(hashkeys);
    COPY_SCALAR_FIELD(skewTable);
    COPY_SCALAR_FIELD(skewColumn);
    COPY_SCALAR_FIELD(skewInherit);
    COPY_SCALAR_FIELD(rows_total);
 
    return newnode;
}
 
/*
 * _copySetOp
 */
static SetOp *
_copySetOp(const SetOp *from)
{
    SetOp      *newnode = makeNode(SetOp);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_SCALAR_FIELD(cmd);
    COPY_SCALAR_FIELD(strategy);
    COPY_SCALAR_FIELD(numCols);
    COPY_POINTER_FIELD(dupColIdx, from->numCols * sizeof(AttrNumber));
    COPY_POINTER_FIELD(dupOperators, from->numCols * sizeof(Oid));
    COPY_POINTER_FIELD(dupCollations, from->numCols * sizeof(Oid));
    COPY_SCALAR_FIELD(flagColIdx);
    COPY_SCALAR_FIELD(firstFlag);
    COPY_SCALAR_FIELD(numGroups);
 
    return newnode;
}
 
/*
 * _copyLockRows
 */
static LockRows *
_copyLockRows(const LockRows *from)
{
    LockRows   *newnode = makeNode(LockRows);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_NODE_FIELD(rowMarks);
    COPY_SCALAR_FIELD(epqParam);
 
    return newnode;
}
 
/*
 * _copyLimit
 */
static Limit *
_copyLimit(const Limit *from)
{
    Limit      *newnode = makeNode(Limit);
 
    /*
     * copy node superclass fields
     */
    CopyPlanFields((const Plan *) from, (Plan *) newnode);
 
    /*
     * copy remainder of node
     */
    COPY_NODE_FIELD(limitOffset);
    COPY_NODE_FIELD(limitCount);
    COPY_SCALAR_FIELD(limitOption);
    COPY_SCALAR_FIELD(uniqNumCols);
    COPY_POINTER_FIELD(uniqColIdx, from->uniqNumCols * sizeof(AttrNumber));
    COPY_POINTER_FIELD(uniqOperators, from->uniqNumCols * sizeof(Oid));
    COPY_POINTER_FIELD(uniqCollations, from->uniqNumCols * sizeof(Oid));
 
    return newnode;
}
 
/*
 * _copyNestLoopParam
 */
static NestLoopParam *
_copyNestLoopParam(const NestLoopParam *from)
{
    NestLoopParam *newnode = makeNode(NestLoopParam);
 
    COPY_SCALAR_FIELD(paramno);
    COPY_NODE_FIELD(paramval);
 
    return newnode;
}
 
/*
 * _copyPlanRowMark
 */
static PlanRowMark *
_copyPlanRowMark(const PlanRowMark *from)
{
    PlanRowMark *newnode = makeNode(PlanRowMark);
 
    COPY_SCALAR_FIELD(rti);
    COPY_SCALAR_FIELD(prti);
    COPY_SCALAR_FIELD(rowmarkId);
    COPY_SCALAR_FIELD(markType);
    COPY_SCALAR_FIELD(allMarkTypes);
    COPY_SCALAR_FIELD(strength);
    COPY_SCALAR_FIELD(waitPolicy);
    COPY_SCALAR_FIELD(isParent);
 
    return newnode;
}
 
static PartitionPruneInfo *
_copyPartitionPruneInfo(const PartitionPruneInfo *from)
{
    PartitionPruneInfo *newnode = makeNode(PartitionPruneInfo);
 
    COPY_NODE_FIELD(prune_infos);
    COPY_BITMAPSET_FIELD(other_subplans);
 
    return newnode;
}
 
static PartitionedRelPruneInfo *
_copyPartitionedRelPruneInfo(const PartitionedRelPruneInfo *from)
{
    PartitionedRelPruneInfo *newnode = makeNode(PartitionedRelPruneInfo);
 
    COPY_SCALAR_FIELD(rtindex);
    COPY_BITMAPSET_FIELD(present_parts);
    COPY_SCALAR_FIELD(nparts);
    COPY_POINTER_FIELD(subplan_map, from->nparts * sizeof(int));
    COPY_POINTER_FIELD(subpart_map, from->nparts * sizeof(int));
    COPY_POINTER_FIELD(relid_map, from->nparts * sizeof(Oid));
    COPY_NODE_FIELD(initial_pruning_steps);
    COPY_NODE_FIELD(exec_pruning_steps);
    COPY_BITMAPSET_FIELD(execparamids);
 
    return newnode;
}
 
/*
 * _copyPartitionPruneStepOp
 */
static PartitionPruneStepOp *
_copyPartitionPruneStepOp(const PartitionPruneStepOp *from)
{
    PartitionPruneStepOp *newnode = makeNode(PartitionPruneStepOp);
 
    COPY_SCALAR_FIELD(step.step_id);
    COPY_SCALAR_FIELD(opstrategy);
    COPY_NODE_FIELD(exprs);
    COPY_NODE_FIELD(cmpfns);
    COPY_BITMAPSET_FIELD(nullkeys);
 
    return newnode;
}
 
/*
 * _copyPartitionPruneStepCombine
 */
static PartitionPruneStepCombine *
_copyPartitionPruneStepCombine(const PartitionPruneStepCombine *from)
{
    PartitionPruneStepCombine *newnode = makeNode(PartitionPruneStepCombine);
 
    COPY_SCALAR_FIELD(step.step_id);
    COPY_SCALAR_FIELD(combineOp);
    COPY_NODE_FIELD(source_stepids);
 
    return newnode;
}
 
/*
 * _copyPlanInvalItem
 */
static PlanInvalItem *
_copyPlanInvalItem(const PlanInvalItem *from)
{
    PlanInvalItem *newnode = makeNode(PlanInvalItem);
 
    COPY_SCALAR_FIELD(cacheId);
    COPY_SCALAR_FIELD(hashValue);
 
    return newnode;
}
 
/* ****************************************************************
 *                     primnodes.h copy functions
 * ****************************************************************
 */
 
/*
 * _copyAlias
 */
static Alias *
_copyAlias(const Alias *from)
{
    Alias      *newnode = makeNode(Alias);
 
    COPY_STRING_FIELD(aliasname);
    COPY_NODE_FIELD(colnames);
 
    return newnode;
}
 
/*
 * _copyRangeVar
 */
static RangeVar *
_copyRangeVar(const RangeVar *from)
{
    RangeVar   *newnode = makeNode(RangeVar);
 
    COPY_STRING_FIELD(catalogname);
    COPY_STRING_FIELD(schemaname);
    COPY_STRING_FIELD(relname);
    COPY_SCALAR_FIELD(inh);
    COPY_SCALAR_FIELD(relpersistence);
    COPY_NODE_FIELD(alias);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyTableFunc
 */
static TableFunc *
_copyTableFunc(const TableFunc *from)
{
    TableFunc  *newnode = makeNode(TableFunc);
 
    COPY_SCALAR_FIELD(functype);
    COPY_NODE_FIELD(ns_uris);
    COPY_NODE_FIELD(ns_names);
    COPY_NODE_FIELD(docexpr);
    COPY_NODE_FIELD(rowexpr);
    COPY_NODE_FIELD(colnames);
    COPY_NODE_FIELD(coltypes);
    COPY_NODE_FIELD(coltypmods);
    COPY_NODE_FIELD(colcollations);
    COPY_NODE_FIELD(colexprs);
    COPY_NODE_FIELD(coldefexprs);
    COPY_NODE_FIELD(colvalexprs);
    COPY_BITMAPSET_FIELD(notnulls);
    COPY_NODE_FIELD(plan);
    COPY_SCALAR_FIELD(ordinalitycol);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyIntoClause
 */
static IntoClause *
_copyIntoClause(const IntoClause *from)
{
    IntoClause *newnode = makeNode(IntoClause);
 
    COPY_NODE_FIELD(rel);
    COPY_NODE_FIELD(colNames);
    COPY_STRING_FIELD(accessMethod);
    COPY_NODE_FIELD(options);
    COPY_SCALAR_FIELD(onCommit);
    COPY_STRING_FIELD(tableSpaceName);
    COPY_NODE_FIELD(viewQuery);
    COPY_SCALAR_FIELD(skipData);
 
    return newnode;
}
 
/*
 * We don't need a _copyExpr because Expr is an abstract supertype which
 * should never actually get instantiated.  Also, since it has no common
 * fields except NodeTag, there's no need for a helper routine to factor
 * out copying the common fields...
 */
 
/*
 * _copyVar
 */
static Var *
_copyVar(const Var *from)
{
    Var        *newnode = makeNode(Var);
 
    COPY_SCALAR_FIELD(varno);
    COPY_SCALAR_FIELD(varattno);
    COPY_SCALAR_FIELD(vartype);
    COPY_SCALAR_FIELD(vartypmod);
    COPY_SCALAR_FIELD(varcollid);
    COPY_SCALAR_FIELD(varlevelsup);
    COPY_SCALAR_FIELD(varnosyn);
    COPY_SCALAR_FIELD(varattnosyn);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyConst
 */
static Const *
_copyConst(const Const *from)
{
    Const      *newnode = makeNode(Const);
 
    COPY_SCALAR_FIELD(consttype);
    COPY_SCALAR_FIELD(consttypmod);
    COPY_SCALAR_FIELD(constcollid);
    COPY_SCALAR_FIELD(constlen);
 
    if (from->constbyval || from->constisnull)
    {
        /*
         * passed by value so just copy the datum. Also, don't try to copy
         * struct when value is null!
         */
        newnode->constvalue = from->constvalue;
    }
    else
    {
        /*
         * passed by reference.  We need a palloc'd copy.
         */
        newnode->constvalue = datumCopy(from->constvalue,
                                        from->constbyval,
                                        from->constlen);
    }
 
    COPY_SCALAR_FIELD(constisnull);
    COPY_SCALAR_FIELD(constbyval);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyParam
 */
static Param *
_copyParam(const Param *from)
{
    Param      *newnode = makeNode(Param);
 
    COPY_SCALAR_FIELD(paramkind);
    COPY_SCALAR_FIELD(paramid);
    COPY_SCALAR_FIELD(paramtype);
    COPY_SCALAR_FIELD(paramtypmod);
    COPY_SCALAR_FIELD(paramcollid);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyAggref
 */
static Aggref *
_copyAggref(const Aggref *from)
{
    Aggref     *newnode = makeNode(Aggref);
 
    COPY_SCALAR_FIELD(aggfnoid);
    COPY_SCALAR_FIELD(aggtype);
    COPY_SCALAR_FIELD(aggcollid);
    COPY_SCALAR_FIELD(inputcollid);
    COPY_SCALAR_FIELD(aggtranstype);
    COPY_NODE_FIELD(aggargtypes);
    COPY_NODE_FIELD(aggdirectargs);
    COPY_NODE_FIELD(args);
    COPY_NODE_FIELD(aggorder);
    COPY_NODE_FIELD(aggdistinct);
    COPY_NODE_FIELD(aggfilter);
    COPY_SCALAR_FIELD(aggstar);
    COPY_SCALAR_FIELD(aggvariadic);
    COPY_SCALAR_FIELD(aggkind);
    COPY_SCALAR_FIELD(agglevelsup);
    COPY_SCALAR_FIELD(aggsplit);
    COPY_SCALAR_FIELD(aggno);
    COPY_SCALAR_FIELD(aggtransno);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyGroupingFunc
 */
static GroupingFunc *
_copyGroupingFunc(const GroupingFunc *from)
{
    GroupingFunc *newnode = makeNode(GroupingFunc);
 
    COPY_NODE_FIELD(args);
    COPY_NODE_FIELD(refs);
    COPY_NODE_FIELD(cols);
    COPY_SCALAR_FIELD(agglevelsup);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyWindowFunc
 */
static WindowFunc *
_copyWindowFunc(const WindowFunc *from)
{
    WindowFunc *newnode = makeNode(WindowFunc);
 
    COPY_SCALAR_FIELD(winfnoid);
    COPY_SCALAR_FIELD(wintype);
    COPY_SCALAR_FIELD(wincollid);
    COPY_SCALAR_FIELD(inputcollid);
    COPY_NODE_FIELD(args);
    COPY_NODE_FIELD(aggfilter);
    COPY_SCALAR_FIELD(winref);
    COPY_SCALAR_FIELD(winstar);
    COPY_SCALAR_FIELD(winagg);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copySubscriptingRef
 */
static SubscriptingRef *
_copySubscriptingRef(const SubscriptingRef *from)
{
    SubscriptingRef *newnode = makeNode(SubscriptingRef);
 
    COPY_SCALAR_FIELD(refcontainertype);
    COPY_SCALAR_FIELD(refelemtype);
    COPY_SCALAR_FIELD(refrestype);
    COPY_SCALAR_FIELD(reftypmod);
    COPY_SCALAR_FIELD(refcollid);
    COPY_NODE_FIELD(refupperindexpr);
    COPY_NODE_FIELD(reflowerindexpr);
    COPY_NODE_FIELD(refexpr);
    COPY_NODE_FIELD(refassgnexpr);
 
    return newnode;
}
 
/*
 * _copyFuncExpr
 */
static FuncExpr *
_copyFuncExpr(const FuncExpr *from)
{
    FuncExpr   *newnode = makeNode(FuncExpr);
 
    COPY_SCALAR_FIELD(funcid);
    COPY_SCALAR_FIELD(funcresulttype);
    COPY_SCALAR_FIELD(funcretset);
    COPY_SCALAR_FIELD(funcvariadic);
    COPY_SCALAR_FIELD(funcformat);
    COPY_SCALAR_FIELD(funccollid);
    COPY_SCALAR_FIELD(inputcollid);
    COPY_NODE_FIELD(args);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyNamedArgExpr *
 */
static NamedArgExpr *
_copyNamedArgExpr(const NamedArgExpr *from)
{
    NamedArgExpr *newnode = makeNode(NamedArgExpr);
 
    COPY_NODE_FIELD(arg);
    COPY_STRING_FIELD(name);
    COPY_SCALAR_FIELD(argnumber);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyOpExpr
 */
static OpExpr *
_copyOpExpr(const OpExpr *from)
{
    OpExpr     *newnode = makeNode(OpExpr);
 
    COPY_SCALAR_FIELD(opno);
    COPY_SCALAR_FIELD(opfuncid);
    COPY_SCALAR_FIELD(opresulttype);
    COPY_SCALAR_FIELD(opretset);
    COPY_SCALAR_FIELD(opcollid);
    COPY_SCALAR_FIELD(inputcollid);
    COPY_NODE_FIELD(args);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyDistinctExpr (same as OpExpr)
 */
static DistinctExpr *
_copyDistinctExpr(const DistinctExpr *from)
{
    DistinctExpr *newnode = makeNode(DistinctExpr);
 
    COPY_SCALAR_FIELD(opno);
    COPY_SCALAR_FIELD(opfuncid);
    COPY_SCALAR_FIELD(opresulttype);
    COPY_SCALAR_FIELD(opretset);
    COPY_SCALAR_FIELD(opcollid);
    COPY_SCALAR_FIELD(inputcollid);
    COPY_NODE_FIELD(args);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyNullIfExpr (same as OpExpr)
 */
static NullIfExpr *
_copyNullIfExpr(const NullIfExpr *from)
{
    NullIfExpr *newnode = makeNode(NullIfExpr);
 
    COPY_SCALAR_FIELD(opno);
    COPY_SCALAR_FIELD(opfuncid);
    COPY_SCALAR_FIELD(opresulttype);
    COPY_SCALAR_FIELD(opretset);
    COPY_SCALAR_FIELD(opcollid);
    COPY_SCALAR_FIELD(inputcollid);
    COPY_NODE_FIELD(args);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyScalarArrayOpExpr
 */
static ScalarArrayOpExpr *
_copyScalarArrayOpExpr(const ScalarArrayOpExpr *from)
{
    ScalarArrayOpExpr *newnode = makeNode(ScalarArrayOpExpr);
 
    COPY_SCALAR_FIELD(opno);
    COPY_SCALAR_FIELD(opfuncid);
    COPY_SCALAR_FIELD(hashfuncid);
    COPY_SCALAR_FIELD(negfuncid);
    COPY_SCALAR_FIELD(useOr);
    COPY_SCALAR_FIELD(inputcollid);
    COPY_NODE_FIELD(args);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyBoolExpr
 */
static BoolExpr *
_copyBoolExpr(const BoolExpr *from)
{
    BoolExpr   *newnode = makeNode(BoolExpr);
 
    COPY_SCALAR_FIELD(boolop);
    COPY_NODE_FIELD(args);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copySubLink
 */
static SubLink *
_copySubLink(const SubLink *from)
{
    SubLink    *newnode = makeNode(SubLink);
 
    COPY_SCALAR_FIELD(subLinkType);
    COPY_SCALAR_FIELD(subLinkId);
    COPY_NODE_FIELD(testexpr);
    COPY_NODE_FIELD(operName);
    COPY_NODE_FIELD(subselect);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copySubPlan
 */
static SubPlan *
_copySubPlan(const SubPlan *from)
{
    SubPlan    *newnode = makeNode(SubPlan);
 
    COPY_SCALAR_FIELD(subLinkType);
    COPY_NODE_FIELD(testexpr);
    COPY_NODE_FIELD(paramIds);
    COPY_SCALAR_FIELD(plan_id);
    COPY_STRING_FIELD(plan_name);
    COPY_SCALAR_FIELD(firstColType);
    COPY_SCALAR_FIELD(firstColTypmod);
    COPY_SCALAR_FIELD(firstColCollation);
    COPY_SCALAR_FIELD(useHashTable);
    COPY_SCALAR_FIELD(unknownEqFalse);
    COPY_SCALAR_FIELD(parallel_safe);
    COPY_NODE_FIELD(setParam);
    COPY_NODE_FIELD(parParam);
    COPY_NODE_FIELD(args);
    COPY_SCALAR_FIELD(startup_cost);
    COPY_SCALAR_FIELD(per_call_cost);
 
    return newnode;
}
 
/*
 * _copyAlternativeSubPlan
 */
static AlternativeSubPlan *
_copyAlternativeSubPlan(const AlternativeSubPlan *from)
{
    AlternativeSubPlan *newnode = makeNode(AlternativeSubPlan);
 
    COPY_NODE_FIELD(subplans);
 
    return newnode;
}
 
/*
 * _copyFieldSelect
 */
static FieldSelect *
_copyFieldSelect(const FieldSelect *from)
{
    FieldSelect *newnode = makeNode(FieldSelect);
 
    COPY_NODE_FIELD(arg);
    COPY_SCALAR_FIELD(fieldnum);
    COPY_SCALAR_FIELD(resulttype);
    COPY_SCALAR_FIELD(resulttypmod);
    COPY_SCALAR_FIELD(resultcollid);
 
    return newnode;
}
 
/*
 * _copyFieldStore
 */
static FieldStore *
_copyFieldStore(const FieldStore *from)
{
    FieldStore *newnode = makeNode(FieldStore);
 
    COPY_NODE_FIELD(arg);
    COPY_NODE_FIELD(newvals);
    COPY_NODE_FIELD(fieldnums);
    COPY_SCALAR_FIELD(resulttype);
 
    return newnode;
}
 
/*
 * _copyRelabelType
 */
static RelabelType *
_copyRelabelType(const RelabelType *from)
{
    RelabelType *newnode = makeNode(RelabelType);
 
    COPY_NODE_FIELD(arg);
    COPY_SCALAR_FIELD(resulttype);
    COPY_SCALAR_FIELD(resulttypmod);
    COPY_SCALAR_FIELD(resultcollid);
    COPY_SCALAR_FIELD(relabelformat);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyCoerceViaIO
 */
static CoerceViaIO *
_copyCoerceViaIO(const CoerceViaIO *from)
{
    CoerceViaIO *newnode = makeNode(CoerceViaIO);
 
    COPY_NODE_FIELD(arg);
    COPY_SCALAR_FIELD(resulttype);
    COPY_SCALAR_FIELD(resultcollid);
    COPY_SCALAR_FIELD(coerceformat);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyArrayCoerceExpr
 */
static ArrayCoerceExpr *
_copyArrayCoerceExpr(const ArrayCoerceExpr *from)
{
    ArrayCoerceExpr *newnode = makeNode(ArrayCoerceExpr);
 
    COPY_NODE_FIELD(arg);
    COPY_NODE_FIELD(elemexpr);
    COPY_SCALAR_FIELD(resulttype);
    COPY_SCALAR_FIELD(resulttypmod);
    COPY_SCALAR_FIELD(resultcollid);
    COPY_SCALAR_FIELD(coerceformat);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyConvertRowtypeExpr
 */
static ConvertRowtypeExpr *
_copyConvertRowtypeExpr(const ConvertRowtypeExpr *from)
{
    ConvertRowtypeExpr *newnode = makeNode(ConvertRowtypeExpr);
 
    COPY_NODE_FIELD(arg);
    COPY_SCALAR_FIELD(resulttype);
    COPY_SCALAR_FIELD(convertformat);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyCollateExpr
 */
static CollateExpr *
_copyCollateExpr(const CollateExpr *from)
{
    CollateExpr *newnode = makeNode(CollateExpr);
 
    COPY_NODE_FIELD(arg);
    COPY_SCALAR_FIELD(collOid);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyCaseExpr
 */
static CaseExpr *
_copyCaseExpr(const CaseExpr *from)
{
    CaseExpr   *newnode = makeNode(CaseExpr);
 
    COPY_SCALAR_FIELD(casetype);
    COPY_SCALAR_FIELD(casecollid);
    COPY_NODE_FIELD(arg);
    COPY_NODE_FIELD(args);
    COPY_NODE_FIELD(defresult);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyCaseWhen
 */
static CaseWhen *
_copyCaseWhen(const CaseWhen *from)
{
    CaseWhen   *newnode = makeNode(CaseWhen);
 
    COPY_NODE_FIELD(expr);
    COPY_NODE_FIELD(result);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyCaseTestExpr
 */
static CaseTestExpr *
_copyCaseTestExpr(const CaseTestExpr *from)
{
    CaseTestExpr *newnode = makeNode(CaseTestExpr);
 
    COPY_SCALAR_FIELD(typeId);
    COPY_SCALAR_FIELD(typeMod);
    COPY_SCALAR_FIELD(collation);
 
    return newnode;
}
 
/*
 * _copyArrayExpr
 */
static ArrayExpr *
_copyArrayExpr(const ArrayExpr *from)
{
    ArrayExpr  *newnode = makeNode(ArrayExpr);
 
    COPY_SCALAR_FIELD(array_typeid);
    COPY_SCALAR_FIELD(array_collid);
    COPY_SCALAR_FIELD(element_typeid);
    COPY_NODE_FIELD(elements);
    COPY_SCALAR_FIELD(multidims);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyRowExpr
 */
static RowExpr *
_copyRowExpr(const RowExpr *from)
{
    RowExpr    *newnode = makeNode(RowExpr);
 
    COPY_NODE_FIELD(args);
    COPY_SCALAR_FIELD(row_typeid);
    COPY_SCALAR_FIELD(row_format);
    COPY_NODE_FIELD(colnames);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyRowCompareExpr
 */
static RowCompareExpr *
_copyRowCompareExpr(const RowCompareExpr *from)
{
    RowCompareExpr *newnode = makeNode(RowCompareExpr);
 
    COPY_SCALAR_FIELD(rctype);
    COPY_NODE_FIELD(opnos);
    COPY_NODE_FIELD(opfamilies);
    COPY_NODE_FIELD(inputcollids);
    COPY_NODE_FIELD(largs);
    COPY_NODE_FIELD(rargs);
 
    return newnode;
}
 
/*
 * _copyCoalesceExpr
 */
static CoalesceExpr *
_copyCoalesceExpr(const CoalesceExpr *from)
{
    CoalesceExpr *newnode = makeNode(CoalesceExpr);
 
    COPY_SCALAR_FIELD(coalescetype);
    COPY_SCALAR_FIELD(coalescecollid);
    COPY_NODE_FIELD(args);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyMinMaxExpr
 */
static MinMaxExpr *
_copyMinMaxExpr(const MinMaxExpr *from)
{
    MinMaxExpr *newnode = makeNode(MinMaxExpr);
 
    COPY_SCALAR_FIELD(minmaxtype);
    COPY_SCALAR_FIELD(minmaxcollid);
    COPY_SCALAR_FIELD(inputcollid);
    COPY_SCALAR_FIELD(op);
    COPY_NODE_FIELD(args);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copySQLValueFunction
 */
static SQLValueFunction *
_copySQLValueFunction(const SQLValueFunction *from)
{
    SQLValueFunction *newnode = makeNode(SQLValueFunction);
 
    COPY_SCALAR_FIELD(op);
    COPY_SCALAR_FIELD(type);
    COPY_SCALAR_FIELD(typmod);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyXmlExpr
 */
static XmlExpr *
_copyXmlExpr(const XmlExpr *from)
{
    XmlExpr    *newnode = makeNode(XmlExpr);
 
    COPY_SCALAR_FIELD(op);
    COPY_STRING_FIELD(name);
    COPY_NODE_FIELD(named_args);
    COPY_NODE_FIELD(arg_names);
    COPY_NODE_FIELD(args);
    COPY_SCALAR_FIELD(xmloption);
    COPY_SCALAR_FIELD(type);
    COPY_SCALAR_FIELD(typmod);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyNullTest
 */
static NullTest *
_copyNullTest(const NullTest *from)
{
    NullTest   *newnode = makeNode(NullTest);
 
    COPY_NODE_FIELD(arg);
    COPY_SCALAR_FIELD(nulltesttype);
    COPY_SCALAR_FIELD(argisrow);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyBooleanTest
 */
static BooleanTest *
_copyBooleanTest(const BooleanTest *from)
{
    BooleanTest *newnode = makeNode(BooleanTest);
 
    COPY_NODE_FIELD(arg);
    COPY_SCALAR_FIELD(booltesttype);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyCoerceToDomain
 */
static CoerceToDomain *
_copyCoerceToDomain(const CoerceToDomain *from)
{
    CoerceToDomain *newnode = makeNode(CoerceToDomain);
 
    COPY_NODE_FIELD(arg);
    COPY_SCALAR_FIELD(resulttype);
    COPY_SCALAR_FIELD(resulttypmod);
    COPY_SCALAR_FIELD(resultcollid);
    COPY_SCALAR_FIELD(coercionformat);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyCoerceToDomainValue
 */
static CoerceToDomainValue *
_copyCoerceToDomainValue(const CoerceToDomainValue *from)
{
    CoerceToDomainValue *newnode = makeNode(CoerceToDomainValue);
 
    COPY_SCALAR_FIELD(typeId);
    COPY_SCALAR_FIELD(typeMod);
    COPY_SCALAR_FIELD(collation);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copySetToDefault
 */
static SetToDefault *
_copySetToDefault(const SetToDefault *from)
{
    SetToDefault *newnode = makeNode(SetToDefault);
 
    COPY_SCALAR_FIELD(typeId);
    COPY_SCALAR_FIELD(typeMod);
    COPY_SCALAR_FIELD(collation);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyCurrentOfExpr
 */
static CurrentOfExpr *
_copyCurrentOfExpr(const CurrentOfExpr *from)
{
    CurrentOfExpr *newnode = makeNode(CurrentOfExpr);
 
    COPY_SCALAR_FIELD(cvarno);
    COPY_STRING_FIELD(cursor_name);
    COPY_SCALAR_FIELD(cursor_param);
 
    return newnode;
}
 
 /*
  * _copyNextValueExpr
  */
static NextValueExpr *
_copyNextValueExpr(const NextValueExpr *from)
{
    NextValueExpr *newnode = makeNode(NextValueExpr);
 
    COPY_SCALAR_FIELD(seqid);
    COPY_SCALAR_FIELD(typeId);
 
    return newnode;
}
 
/*
 * _copyInferenceElem
 */
static InferenceElem *
_copyInferenceElem(const InferenceElem *from)
{
    InferenceElem *newnode = makeNode(InferenceElem);
 
    COPY_NODE_FIELD(expr);
    COPY_SCALAR_FIELD(infercollid);
    COPY_SCALAR_FIELD(inferopclass);
 
    return newnode;
}
 
/*
 * _copyTargetEntry
 */
static TargetEntry *
_copyTargetEntry(const TargetEntry *from)
{
    TargetEntry *newnode = makeNode(TargetEntry);
 
    COPY_NODE_FIELD(expr);
    COPY_SCALAR_FIELD(resno);
    COPY_STRING_FIELD(resname);
    COPY_SCALAR_FIELD(ressortgroupref);
    COPY_SCALAR_FIELD(resorigtbl);
    COPY_SCALAR_FIELD(resorigcol);
    COPY_SCALAR_FIELD(resjunk);
 
    return newnode;
}
 
/*
 * _copyRangeTblRef
 */
static RangeTblRef *
_copyRangeTblRef(const RangeTblRef *from)
{
    RangeTblRef *newnode = makeNode(RangeTblRef);
 
    COPY_SCALAR_FIELD(rtindex);
 
    return newnode;
}
 
/*
 * _copyJoinExpr
 */
static JoinExpr *
_copyJoinExpr(const JoinExpr *from)
{
    JoinExpr   *newnode = makeNode(JoinExpr);
 
    COPY_SCALAR_FIELD(jointype);
    COPY_SCALAR_FIELD(isNatural);
    COPY_NODE_FIELD(larg);
    COPY_NODE_FIELD(rarg);
    COPY_NODE_FIELD(usingClause);
    COPY_NODE_FIELD(join_using_alias);
    COPY_NODE_FIELD(quals);
    COPY_NODE_FIELD(alias);
    COPY_SCALAR_FIELD(rtindex);
 
    return newnode;
}
 
/*
 * _copyFromExpr
 */
static FromExpr *
_copyFromExpr(const FromExpr *from)
{
    FromExpr   *newnode = makeNode(FromExpr);
 
    COPY_NODE_FIELD(fromlist);
    COPY_NODE_FIELD(quals);
 
    return newnode;
}
 
/*
 * _copyOnConflictExpr
 */
static OnConflictExpr *
_copyOnConflictExpr(const OnConflictExpr *from)
{
    OnConflictExpr *newnode = makeNode(OnConflictExpr);
 
    COPY_SCALAR_FIELD(action);
    COPY_NODE_FIELD(arbiterElems);
    COPY_NODE_FIELD(arbiterWhere);
    COPY_SCALAR_FIELD(constraint);
    COPY_NODE_FIELD(onConflictSet);
    COPY_NODE_FIELD(onConflictWhere);
    COPY_SCALAR_FIELD(exclRelIndex);
    COPY_NODE_FIELD(exclRelTlist);
 
    return newnode;
}
 
 
/*
 * _copyJsonFormat
 */
static JsonFormat *
_copyJsonFormat(const JsonFormat *from)
{
    JsonFormat *newnode = makeNode(JsonFormat);
 
    COPY_SCALAR_FIELD(format_type);
    COPY_SCALAR_FIELD(encoding);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonReturning
 */
static JsonReturning *
_copyJsonReturning(const JsonReturning *from)
{
    JsonReturning *newnode = makeNode(JsonReturning);
 
    COPY_NODE_FIELD(format);
    COPY_SCALAR_FIELD(typid);
    COPY_SCALAR_FIELD(typmod);
 
    return newnode;
}
 
/*
 * _copyJsonValueExpr
 */
static JsonValueExpr *
_copyJsonValueExpr(const JsonValueExpr *from)
{
    JsonValueExpr *newnode = makeNode(JsonValueExpr);
 
    COPY_NODE_FIELD(raw_expr);
    COPY_NODE_FIELD(formatted_expr);
    COPY_NODE_FIELD(format);
 
    return newnode;
}
 
/*
 * _copyJsonParseExpr
 */
static JsonParseExpr *
_copyJsonParseExpr(const JsonParseExpr *from)
{
    JsonParseExpr *newnode = makeNode(JsonParseExpr);
 
    COPY_NODE_FIELD(expr);
    COPY_NODE_FIELD(output);
    COPY_SCALAR_FIELD(unique_keys);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonScalarExpr
 */
static JsonScalarExpr *
_copyJsonScalarExpr(const JsonScalarExpr *from)
{
    JsonScalarExpr *newnode = makeNode(JsonScalarExpr);
 
    COPY_NODE_FIELD(expr);
    COPY_NODE_FIELD(output);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonSerializeExpr
 */
static JsonSerializeExpr *
_copyJsonSerializeExpr(const JsonSerializeExpr *from)
{
    JsonSerializeExpr *newnode = makeNode(JsonSerializeExpr);
 
    COPY_NODE_FIELD(expr);
    COPY_NODE_FIELD(output);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonConstructorExpr
 */
static JsonConstructorExpr *
_copyJsonConstructorExpr(const JsonConstructorExpr *from)
{
    JsonConstructorExpr *newnode = makeNode(JsonConstructorExpr);
 
    COPY_SCALAR_FIELD(type);
    COPY_NODE_FIELD(args);
    COPY_NODE_FIELD(func);
    COPY_NODE_FIELD(coercion);
    COPY_NODE_FIELD(returning);
    COPY_SCALAR_FIELD(absent_on_null);
    COPY_SCALAR_FIELD(unique);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonKeyValue
 */
static JsonKeyValue *
_copyJsonKeyValue(const JsonKeyValue *from)
{
    JsonKeyValue *newnode = makeNode(JsonKeyValue);
 
    COPY_NODE_FIELD(key);
    COPY_NODE_FIELD(value);
 
    return newnode;
}
 
/*
 * _copyJsonObjectConstructor
 */
static JsonObjectConstructor *
_copyJsonObjectConstructor(const JsonObjectConstructor *from)
{
    JsonObjectConstructor *newnode = makeNode(JsonObjectConstructor);
 
    COPY_NODE_FIELD(exprs);
    COPY_NODE_FIELD(output);
    COPY_SCALAR_FIELD(absent_on_null);
    COPY_SCALAR_FIELD(unique);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonAggConstructor
 */
static JsonAggConstructor *
_copyJsonAggConstructor(const JsonAggConstructor *from)
{
    JsonAggConstructor *newnode = makeNode(JsonAggConstructor);
 
    COPY_NODE_FIELD(output);
    COPY_NODE_FIELD(agg_filter);
    COPY_NODE_FIELD(agg_order);
    COPY_NODE_FIELD(over);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonObjectAgg
 */
static JsonObjectAgg *
_copyJsonObjectAgg(const JsonObjectAgg *from)
{
    JsonObjectAgg *newnode = makeNode(JsonObjectAgg);
 
    COPY_NODE_FIELD(constructor);
    COPY_NODE_FIELD(arg);
    COPY_SCALAR_FIELD(absent_on_null);
    COPY_SCALAR_FIELD(unique);
 
    return newnode;
}
 
/*
 * _copyJsonOutput
 */
static JsonOutput *
_copyJsonOutput(const JsonOutput *from)
{
    JsonOutput *newnode = makeNode(JsonOutput);
 
    COPY_NODE_FIELD(typeName);
    COPY_NODE_FIELD(returning);
 
    return newnode;
}
 
/*
 * _copyJsonArrayConstructor
 */
static JsonArrayConstructor *
_copyJsonArrayConstructor(const JsonArrayConstructor *from)
{
    JsonArrayConstructor *newnode = makeNode(JsonArrayConstructor);
 
    COPY_NODE_FIELD(exprs);
    COPY_NODE_FIELD(output);
    COPY_SCALAR_FIELD(absent_on_null);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonArrayAgg
 */
static JsonArrayAgg *
_copyJsonArrayAgg(const JsonArrayAgg *from)
{
    JsonArrayAgg *newnode = makeNode(JsonArrayAgg);
 
    COPY_NODE_FIELD(constructor);
    COPY_NODE_FIELD(arg);
    COPY_SCALAR_FIELD(absent_on_null);
 
    return newnode;
}
 
/*
 * _copyJsonArrayQueryConstructor
 */
static JsonArrayQueryConstructor *
_copyJsonArrayQueryConstructor(const JsonArrayQueryConstructor *from)
{
    JsonArrayQueryConstructor *newnode = makeNode(JsonArrayQueryConstructor);
 
    COPY_NODE_FIELD(query);
    COPY_NODE_FIELD(output);
    COPY_NODE_FIELD(format);
    COPY_SCALAR_FIELD(absent_on_null);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonExpr
 */
static JsonExpr *
_copyJsonExpr(const JsonExpr *from)
{
    JsonExpr   *newnode = makeNode(JsonExpr);
 
    COPY_SCALAR_FIELD(op);
    COPY_NODE_FIELD(formatted_expr);
    COPY_NODE_FIELD(result_coercion);
    COPY_NODE_FIELD(format);
    COPY_NODE_FIELD(path_spec);
    COPY_NODE_FIELD(passing_names);
    COPY_NODE_FIELD(passing_values);
    COPY_NODE_FIELD(returning);
    COPY_NODE_FIELD(on_empty);
    COPY_NODE_FIELD(on_error);
    COPY_NODE_FIELD(coercions);
    COPY_SCALAR_FIELD(wrapper);
    COPY_SCALAR_FIELD(omit_quotes);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonCoercion
 */
static JsonCoercion *
_copyJsonCoercion(const JsonCoercion *from)
{
    JsonCoercion *newnode = makeNode(JsonCoercion);
 
    COPY_NODE_FIELD(expr);
    COPY_SCALAR_FIELD(via_populate);
    COPY_SCALAR_FIELD(via_io);
    COPY_SCALAR_FIELD(collation);
 
    return newnode;
}
 
/*
 * _copyJsonItemCoercions
 */
static JsonItemCoercions *
_copyJsonItemCoercions(const JsonItemCoercions *from)
{
    JsonItemCoercions *newnode = makeNode(JsonItemCoercions);
 
    COPY_NODE_FIELD(null);
    COPY_NODE_FIELD(string);
    COPY_NODE_FIELD(numeric);
    COPY_NODE_FIELD(boolean);
    COPY_NODE_FIELD(date);
    COPY_NODE_FIELD(time);
    COPY_NODE_FIELD(timetz);
    COPY_NODE_FIELD(timestamp);
    COPY_NODE_FIELD(timestamptz);
    COPY_NODE_FIELD(composite);
 
    return newnode;
}
 
/*
 * _copyJsonFuncExpr
 */
static JsonFuncExpr *
_copyJsonFuncExpr(const JsonFuncExpr *from)
{
    JsonFuncExpr *newnode = makeNode(JsonFuncExpr);
 
    COPY_SCALAR_FIELD(op);
    COPY_NODE_FIELD(common);
    COPY_NODE_FIELD(output);
    COPY_NODE_FIELD(on_empty);
    COPY_NODE_FIELD(on_error);
    COPY_SCALAR_FIELD(wrapper);
    COPY_SCALAR_FIELD(omit_quotes);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonIsPredicate
 */
static JsonIsPredicate *
_copyJsonIsPredicate(const JsonIsPredicate *from)
{
    JsonIsPredicate *newnode = makeNode(JsonIsPredicate);
 
    COPY_NODE_FIELD(expr);
    COPY_NODE_FIELD(format);
    COPY_SCALAR_FIELD(item_type);
    COPY_SCALAR_FIELD(unique_keys);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonBehavior
 */
static JsonBehavior *
_copyJsonBehavior(const JsonBehavior *from)
{
    JsonBehavior *newnode = makeNode(JsonBehavior);
 
    COPY_SCALAR_FIELD(btype);
    COPY_NODE_FIELD(default_expr);
 
    return newnode;
}
 
/*
 * _copyJsonCommon
 */
static JsonCommon *
_copyJsonCommon(const JsonCommon *from)
{
    JsonCommon *newnode = makeNode(JsonCommon);
 
    COPY_NODE_FIELD(expr);
    COPY_NODE_FIELD(pathspec);
    COPY_STRING_FIELD(pathname);
    COPY_NODE_FIELD(passing);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonArgument
 */
static JsonArgument *
_copyJsonArgument(const JsonArgument *from)
{
    JsonArgument *newnode = makeNode(JsonArgument);
 
    COPY_NODE_FIELD(val);
    COPY_STRING_FIELD(name);
 
    return newnode;
}
 
/*
 * _copyJsonTable
 */
static JsonTable *
_copyJsonTable(const JsonTable *from)
{
    JsonTable  *newnode = makeNode(JsonTable);
 
    COPY_NODE_FIELD(common);
    COPY_NODE_FIELD(columns);
    COPY_NODE_FIELD(plan);
    COPY_NODE_FIELD(on_error);
    COPY_NODE_FIELD(alias);
    COPY_SCALAR_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonTableColumn
 */
static JsonTableColumn *
_copyJsonTableColumn(const JsonTableColumn *from)
{
    JsonTableColumn *newnode = makeNode(JsonTableColumn);
 
    COPY_SCALAR_FIELD(coltype);
    COPY_STRING_FIELD(name);
    COPY_NODE_FIELD(typeName);
    COPY_STRING_FIELD(pathspec);
    COPY_STRING_FIELD(pathname);
    COPY_SCALAR_FIELD(format);
    COPY_SCALAR_FIELD(wrapper);
    COPY_SCALAR_FIELD(omit_quotes);
    COPY_NODE_FIELD(columns);
    COPY_NODE_FIELD(on_empty);
    COPY_NODE_FIELD(on_error);
    COPY_SCALAR_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonTablePlan
 */
static JsonTablePlan *
_copyJsonTablePlan(const JsonTablePlan *from)
{
    JsonTablePlan *newnode = makeNode(JsonTablePlan);
 
    COPY_SCALAR_FIELD(plan_type);
    COPY_SCALAR_FIELD(join_type);
    COPY_STRING_FIELD(pathname);
    COPY_NODE_FIELD(plan1);
    COPY_NODE_FIELD(plan2);
    COPY_SCALAR_FIELD(location);
 
    return newnode;
}
 
/*
 * _copyJsonTableParent
 */
static JsonTableParent *
_copyJsonTableParent(const JsonTableParent *from)
{
    JsonTableParent *newnode = makeNode(JsonTableParent);
 
    COPY_NODE_FIELD(path);
    COPY_STRING_FIELD(name);
    COPY_NODE_FIELD(child);
    COPY_SCALAR_FIELD(outerJoin);
    COPY_SCALAR_FIELD(colMin);
    COPY_SCALAR_FIELD(colMax);
    COPY_SCALAR_FIELD(errorOnError);
 
    return newnode;
}
 
/*
 * _copyJsonTableSibling
 */
static JsonTableSibling *
_copyJsonTableSibling(const JsonTableSibling *from)
{
    JsonTableSibling *newnode = makeNode(JsonTableSibling);
 
    COPY_NODE_FIELD(larg);
    COPY_NODE_FIELD(rarg);
    COPY_SCALAR_FIELD(cross);
 
    return newnode;
}
 
/* ****************************************************************
 *                      pathnodes.h copy functions
 *
 * We don't support copying RelOptInfo, IndexOptInfo, or Path nodes.
 * There are some subsidiary structs that are useful to copy, though.
 * ****************************************************************
 */
 
/*
 * _copyPathKey
 */
static PathKey *
_copyPathKey(const PathKey *from)
{
    PathKey    *newnode = makeNode(PathKey);
 
    /* EquivalenceClasses are never moved, so just shallow-copy the pointer */
    COPY_SCALAR_FIELD(pk_eclass);
    COPY_SCALAR_FIELD(pk_opfamily);
    COPY_SCALAR_FIELD(pk_strategy);
    COPY_SCALAR_FIELD(pk_nulls_first);
 
    return newnode;
}
 
/*
 * _copyRestrictInfo
 */
static RestrictInfo *
_copyRestrictInfo(const RestrictInfo *from)
{
    RestrictInfo *newnode = makeNode(RestrictInfo);
 
    COPY_NODE_FIELD(clause);
    COPY_SCALAR_FIELD(is_pushed_down);
    COPY_SCALAR_FIELD(outerjoin_delayed);
    COPY_SCALAR_FIELD(can_join);
    COPY_SCALAR_FIELD(pseudoconstant);
    COPY_SCALAR_FIELD(leakproof);
    COPY_SCALAR_FIELD(has_volatile);
    COPY_SCALAR_FIELD(security_level);
    COPY_BITMAPSET_FIELD(clause_relids);
    COPY_BITMAPSET_FIELD(required_relids);
    COPY_BITMAPSET_FIELD(outer_relids);
    COPY_BITMAPSET_FIELD(nullable_relids);
    COPY_BITMAPSET_FIELD(left_relids);
    COPY_BITMAPSET_FIELD(right_relids);
    COPY_NODE_FIELD(orclause);
    /* EquivalenceClasses are never copied, so shallow-copy the pointers */
    COPY_SCALAR_FIELD(parent_ec);
    COPY_SCALAR_FIELD(eval_cost);
    COPY_SCALAR_FIELD(norm_selec);
    COPY_SCALAR_FIELD(outer_selec);
    COPY_NODE_FIELD(mergeopfamilies);
    /* EquivalenceClasses are never copied, so shallow-copy the pointers */
    COPY_SCALAR_FIELD(left_ec);
    COPY_SCALAR_FIELD(right_ec);
    COPY_SCALAR_FIELD(left_em);
    COPY_SCALAR_FIELD(right_em);
    /* MergeScanSelCache isn't a Node, so hard to copy; just reset cache */
    newnode->scansel_cache = NIL;
    COPY_SCALAR_FIELD(outer_is_left);
    COPY_SCALAR_FIELD(hashjoinoperator);
    COPY_SCALAR_FIELD(left_bucketsize);
    COPY_SCALAR_FIELD(right_bucketsize);
    COPY_SCALAR_FIELD(left_mcvfreq);
    COPY_SCALAR_FIELD(right_mcvfreq);
    COPY_SCALAR_FIELD(left_hasheqoperator);
    COPY_SCALAR_FIELD(right_hasheqoperator);
 
    return newnode;
}
 
/*
 * _copyPlaceHolderVar
 */
static PlaceHolderVar *
_copyPlaceHolderVar(const PlaceHolderVar *from)
{
    PlaceHolderVar *newnode = makeNode(PlaceHolderVar);
 
    COPY_NODE_FIELD(phexpr);
    COPY_BITMAPSET_FIELD(phrels);
    COPY_SCALAR_FIELD(phid);
    COPY_SCALAR_FIELD(phlevelsup);
 
    return newnode;
}
 
/*
 * _copySpecialJoinInfo
 */
static SpecialJoinInfo *
_copySpecialJoinInfo(const SpecialJoinInfo *from)
{
    SpecialJoinInfo *newnode = makeNode(SpecialJoinInfo);
 
    COPY_BITMAPSET_FIELD(min_lefthand);
    COPY_BITMAPSET_FIELD(min_righthand);
    COPY_BITMAPSET_FIELD(syn_lefthand);
    COPY_BITMAPSET_FIELD(syn_righthand);
    COPY_SCALAR_FIELD(jointype);
    COPY_SCALAR_FIELD(lhs_strict);
    COPY_SCALAR_FIELD(delay_upper_joins);
    COPY_SCALAR_FIELD(semi_can_btree);
    COPY_SCALAR_FIELD(semi_can_hash);
    COPY_NODE_FIELD(semi_operators);
    COPY_NODE_FIELD(semi_rhs_exprs);
 
    return newnode;
}
 
/*
 * _copyAppendRelInfo
 */
static AppendRelInfo *
_copyAppendRelInfo(const AppendRelInfo *from)
{
    AppendRelInfo *newnode = makeNode(AppendRelInfo);
 
    COPY_SCALAR_FIELD(parent_relid);
    COPY_SCALAR_FIELD(child_relid);
    COPY_SCALAR_FIELD(parent_reltype);
    COPY_SCALAR_FIELD(child_reltype);
    COPY_NODE_FIELD(translated_vars);
    COPY_SCALAR_FIELD(num_child_cols);
    COPY_POINTER_FIELD(parent_colnos, from->num_child_cols * sizeof(AttrNumber));
    COPY_SCALAR_FIELD(parent_reloid);
 
    return newnode;
}
 
/*
 * _copyPlaceHolderInfo
 */
static PlaceHolderInfo *
_copyPlaceHolderInfo(const PlaceHolderInfo *from)
{
    PlaceHolderInfo *newnode = makeNode(PlaceHolderInfo);
 
    COPY_SCALAR_FIELD(phid);
    COPY_NODE_FIELD(ph_var);
    COPY_BITMAPSET_FIELD(ph_eval_at);
    COPY_BITMAPSET_FIELD(ph_lateral);
    COPY_BITMAPSET_FIELD(ph_needed);
    COPY_SCALAR_FIELD(ph_width);
 
    return newnode;
}
 
/* ****************************************************************
 *                  parsenodes.h copy functions
 * ****************************************************************
 */
 
static RangeTblEntry *
_copyRangeTblEntry(const RangeTblEntry *from)
{
    RangeTblEntry *newnode = makeNode(RangeTblEntry);
 
    COPY_SCALAR_FIELD(rtekind);
    COPY_SCALAR_FIELD(relid);
    COPY_SCALAR_FIELD(relkind);
    COPY_SCALAR_FIELD(rellockmode);
    COPY_NODE_FIELD(tablesample);
    COPY_NODE_FIELD(subquery);
    COPY_SCALAR_FIELD(security_barrier);
    COPY_SCALAR_FIELD(jointype);
    COPY_SCALAR_FIELD(joinmergedcols);
    COPY_NODE_FIELD(joinaliasvars);
    COPY_NODE_FIELD(joinleftcols);
    COPY_NODE_FIELD(joinrightcols);
    COPY_NODE_FIELD(join_using_alias);
    COPY_NODE_FIELD(functions);
    COPY_SCALAR_FIELD(funcordinality);
    COPY_NODE_FIELD(tablefunc);
    COPY_NODE_FIELD(values_lists);
    COPY_STRING_FIELD(ctename);
    COPY_SCALAR_FIELD(ctelevelsup);
    COPY_SCALAR_FIELD(self_reference);
    COPY_NODE_FIELD(coltypes);
    COPY_NODE_FIELD(coltypmods);
    COPY_NODE_FIELD(colcollations);
    COPY_STRING_FIELD(enrname);
    COPY_SCALAR_FIELD(enrtuples);
    COPY_NODE_FIELD(alias);
    COPY_NODE_FIELD(eref);
    COPY_SCALAR_FIELD(lateral);
    COPY_SCALAR_FIELD(inh);
    COPY_SCALAR_FIELD(inFromCl);
    COPY_SCALAR_FIELD(requiredPerms);
    COPY_SCALAR_FIELD(checkAsUser);
    COPY_BITMAPSET_FIELD(selectedCols);
    COPY_BITMAPSET_FIELD(insertedCols);
    COPY_BITMAPSET_FIELD(updatedCols);
    COPY_BITMAPSET_FIELD(extraUpdatedCols);
    COPY_NODE_FIELD(securityQuals);
 
    return newnode;
}
 
static RangeTblFunction *
_copyRangeTblFunction(const RangeTblFunction *from)
{
    RangeTblFunction *newnode = makeNode(RangeTblFunction);
 
    COPY_NODE_FIELD(funcexpr);
    COPY_SCALAR_FIELD(funccolcount);
    COPY_NODE_FIELD(funccolnames);
    COPY_NODE_FIELD(funccoltypes);
    COPY_NODE_FIELD(funccoltypmods);
    COPY_NODE_FIELD(funccolcollations);
    COPY_BITMAPSET_FIELD(funcparams);
 
    return newnode;
}
 
static TableSampleClause *
_copyTableSampleClause(const TableSampleClause *from)
{
    TableSampleClause *newnode = makeNode(TableSampleClause);
 
    COPY_SCALAR_FIELD(tsmhandler);
    COPY_NODE_FIELD(args);
    COPY_NODE_FIELD(repeatable);
 
    return newnode;
}
 
static WithCheckOption *
_copyWithCheckOption(const WithCheckOption *from)
{
    WithCheckOption *newnode = makeNode(WithCheckOption);
 
    COPY_SCALAR_FIELD(kind);
    COPY_STRING_FIELD(relname);
    COPY_STRING_FIELD(polname);
    COPY_NODE_FIELD(qual);
    COPY_SCALAR_FIELD(cascaded);
 
    return newnode;
}
 
static SortGroupClause *
_copySortGroupClause(const SortGroupClause *from)
{
    SortGroupClause *newnode = makeNode(SortGroupClause);
 
    COPY_SCALAR_FIELD(tleSortGroupRef);
    COPY_SCALAR_FIELD(eqop);
    COPY_SCALAR_FIELD(sortop);
    COPY_SCALAR_FIELD(nulls_first);
    COPY_SCALAR_FIELD(hashable);
 
    return newnode;
}
 
static GroupingSet *
_copyGroupingSet(const GroupingSet *from)
{
    GroupingSet *newnode = makeNode(GroupingSet);
 
    COPY_SCALAR_FIELD(kind);
    COPY_NODE_FIELD(content);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static WindowClause *
_copyWindowClause(const WindowClause *from)
{
    WindowClause *newnode = makeNode(WindowClause);
 
    COPY_STRING_FIELD(name);
    COPY_STRING_FIELD(refname);
    COPY_NODE_FIELD(partitionClause);
    COPY_NODE_FIELD(orderClause);
    COPY_SCALAR_FIELD(frameOptions);
    COPY_NODE_FIELD(startOffset);
    COPY_NODE_FIELD(endOffset);
    COPY_NODE_FIELD(runCondition);
    COPY_SCALAR_FIELD(startInRangeFunc);
    COPY_SCALAR_FIELD(endInRangeFunc);
    COPY_SCALAR_FIELD(inRangeColl);
    COPY_SCALAR_FIELD(inRangeAsc);
    COPY_SCALAR_FIELD(inRangeNullsFirst);
    COPY_SCALAR_FIELD(winref);
    COPY_SCALAR_FIELD(copiedOrder);
 
    return newnode;
}
 
static RowMarkClause *
_copyRowMarkClause(const RowMarkClause *from)
{
    RowMarkClause *newnode = makeNode(RowMarkClause);
 
    COPY_SCALAR_FIELD(rti);
    COPY_SCALAR_FIELD(strength);
    COPY_SCALAR_FIELD(waitPolicy);
    COPY_SCALAR_FIELD(pushedDown);
 
    return newnode;
}
 
static WithClause *
_copyWithClause(const WithClause *from)
{
    WithClause *newnode = makeNode(WithClause);
 
    COPY_NODE_FIELD(ctes);
    COPY_SCALAR_FIELD(recursive);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static InferClause *
_copyInferClause(const InferClause *from)
{
    InferClause *newnode = makeNode(InferClause);
 
    COPY_NODE_FIELD(indexElems);
    COPY_NODE_FIELD(whereClause);
    COPY_STRING_FIELD(conname);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static OnConflictClause *
_copyOnConflictClause(const OnConflictClause *from)
{
    OnConflictClause *newnode = makeNode(OnConflictClause);
 
    COPY_SCALAR_FIELD(action);
    COPY_NODE_FIELD(infer);
    COPY_NODE_FIELD(targetList);
    COPY_NODE_FIELD(whereClause);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static CTESearchClause *
_copyCTESearchClause(const CTESearchClause *from)
{
    CTESearchClause *newnode = makeNode(CTESearchClause);
 
    COPY_NODE_FIELD(search_col_list);
    COPY_SCALAR_FIELD(search_breadth_first);
    COPY_STRING_FIELD(search_seq_column);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static CTECycleClause *
_copyCTECycleClause(const CTECycleClause *from)
{
    CTECycleClause *newnode = makeNode(CTECycleClause);
 
    COPY_NODE_FIELD(cycle_col_list);
    COPY_STRING_FIELD(cycle_mark_column);
    COPY_NODE_FIELD(cycle_mark_value);
    COPY_NODE_FIELD(cycle_mark_default);
    COPY_STRING_FIELD(cycle_path_column);
    COPY_LOCATION_FIELD(location);
    COPY_SCALAR_FIELD(cycle_mark_type);
    COPY_SCALAR_FIELD(cycle_mark_typmod);
    COPY_SCALAR_FIELD(cycle_mark_collation);
    COPY_SCALAR_FIELD(cycle_mark_neop);
 
    return newnode;
}
 
static CommonTableExpr *
_copyCommonTableExpr(const CommonTableExpr *from)
{
    CommonTableExpr *newnode = makeNode(CommonTableExpr);
 
    COPY_STRING_FIELD(ctename);
    COPY_NODE_FIELD(aliascolnames);
    COPY_SCALAR_FIELD(ctematerialized);
    COPY_NODE_FIELD(ctequery);
    COPY_NODE_FIELD(search_clause);
    COPY_NODE_FIELD(cycle_clause);
    COPY_LOCATION_FIELD(location);
    COPY_SCALAR_FIELD(cterecursive);
    COPY_SCALAR_FIELD(cterefcount);
    COPY_NODE_FIELD(ctecolnames);
    COPY_NODE_FIELD(ctecoltypes);
    COPY_NODE_FIELD(ctecoltypmods);
    COPY_NODE_FIELD(ctecolcollations);
 
    return newnode;
}
 
static MergeWhenClause *
_copyMergeWhenClause(const MergeWhenClause *from)
{
    MergeWhenClause *newnode = makeNode(MergeWhenClause);
 
    COPY_SCALAR_FIELD(matched);
    COPY_SCALAR_FIELD(commandType);
    COPY_SCALAR_FIELD(override);
    COPY_NODE_FIELD(condition);
    COPY_NODE_FIELD(targetList);
    COPY_NODE_FIELD(values);
    return newnode;
}
 
static MergeAction *
_copyMergeAction(const MergeAction *from)
{
    MergeAction *newnode = makeNode(MergeAction);
 
    COPY_SCALAR_FIELD(matched);
    COPY_SCALAR_FIELD(commandType);
    COPY_SCALAR_FIELD(override);
    COPY_NODE_FIELD(qual);
    COPY_NODE_FIELD(targetList);
    COPY_NODE_FIELD(updateColnos);
 
    return newnode;
}
 
static A_Expr *
_copyA_Expr(const A_Expr *from)
{
    A_Expr     *newnode = makeNode(A_Expr);
 
    COPY_SCALAR_FIELD(kind);
    COPY_NODE_FIELD(name);
    COPY_NODE_FIELD(lexpr);
    COPY_NODE_FIELD(rexpr);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static ColumnRef *
_copyColumnRef(const ColumnRef *from)
{
    ColumnRef  *newnode = makeNode(ColumnRef);
 
    COPY_NODE_FIELD(fields);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static ParamRef *
_copyParamRef(const ParamRef *from)
{
    ParamRef   *newnode = makeNode(ParamRef);
 
    COPY_SCALAR_FIELD(number);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static A_Const *
_copyA_Const(const A_Const *from)
{
    A_Const    *newnode = makeNode(A_Const);
 
    COPY_SCALAR_FIELD(isnull);
    if (!from->isnull)
    {
        /* This part must duplicate other _copy*() functions. */
        COPY_SCALAR_FIELD(val.node.type);
        switch (nodeTag(&from->val))
        {
            case T_Integer:
                COPY_SCALAR_FIELD(val.ival.ival);
                break;
            case T_Float:
                COPY_STRING_FIELD(val.fval.fval);
                break;
            case T_Boolean:
                COPY_SCALAR_FIELD(val.boolval.boolval);
                break;
            case T_String:
                COPY_STRING_FIELD(val.sval.sval);
                break;
            case T_BitString:
                COPY_STRING_FIELD(val.bsval.bsval);
                break;
            default:
                elog(ERROR, "unrecognized node type: %d",
                     (int) nodeTag(&from->val));
                break;
        }
    }
 
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static FuncCall *
_copyFuncCall(const FuncCall *from)
{
    FuncCall   *newnode = makeNode(FuncCall);
 
    COPY_NODE_FIELD(funcname);
    COPY_NODE_FIELD(args);
    COPY_NODE_FIELD(agg_order);
    COPY_NODE_FIELD(agg_filter);
    COPY_NODE_FIELD(over);
    COPY_SCALAR_FIELD(agg_within_group);
    COPY_SCALAR_FIELD(agg_star);
    COPY_SCALAR_FIELD(agg_distinct);
    COPY_SCALAR_FIELD(func_variadic);
    COPY_SCALAR_FIELD(funcformat);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static A_Star *
_copyA_Star(const A_Star *from)
{
    A_Star     *newnode = makeNode(A_Star);
 
    return newnode;
}
 
static A_Indices *
_copyA_Indices(const A_Indices *from)
{
    A_Indices  *newnode = makeNode(A_Indices);
 
    COPY_SCALAR_FIELD(is_slice);
    COPY_NODE_FIELD(lidx);
    COPY_NODE_FIELD(uidx);
 
    return newnode;
}
 
static A_Indirection *
_copyA_Indirection(const A_Indirection *from)
{
    A_Indirection *newnode = makeNode(A_Indirection);
 
    COPY_NODE_FIELD(arg);
    COPY_NODE_FIELD(indirection);
 
    return newnode;
}
 
static A_ArrayExpr *
_copyA_ArrayExpr(const A_ArrayExpr *from)
{
    A_ArrayExpr *newnode = makeNode(A_ArrayExpr);
 
    COPY_NODE_FIELD(elements);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static ResTarget *
_copyResTarget(const ResTarget *from)
{
    ResTarget  *newnode = makeNode(ResTarget);
 
    COPY_STRING_FIELD(name);
    COPY_NODE_FIELD(indirection);
    COPY_NODE_FIELD(val);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static MultiAssignRef *
_copyMultiAssignRef(const MultiAssignRef *from)
{
    MultiAssignRef *newnode = makeNode(MultiAssignRef);
 
    COPY_NODE_FIELD(source);
    COPY_SCALAR_FIELD(colno);
    COPY_SCALAR_FIELD(ncolumns);
 
    return newnode;
}
 
static TypeName *
_copyTypeName(const TypeName *from)
{
    TypeName   *newnode = makeNode(TypeName);
 
    COPY_NODE_FIELD(names);
    COPY_SCALAR_FIELD(typeOid);
    COPY_SCALAR_FIELD(setof);
    COPY_SCALAR_FIELD(pct_type);
    COPY_NODE_FIELD(typmods);
    COPY_SCALAR_FIELD(typemod);
    COPY_NODE_FIELD(arrayBounds);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static SortBy *
_copySortBy(const SortBy *from)
{
    SortBy     *newnode = makeNode(SortBy);
 
    COPY_NODE_FIELD(node);
    COPY_SCALAR_FIELD(sortby_dir);
    COPY_SCALAR_FIELD(sortby_nulls);
    COPY_NODE_FIELD(useOp);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static WindowDef *
_copyWindowDef(const WindowDef *from)
{
    WindowDef  *newnode = makeNode(WindowDef);
 
    COPY_STRING_FIELD(name);
    COPY_STRING_FIELD(refname);
    COPY_NODE_FIELD(partitionClause);
    COPY_NODE_FIELD(orderClause);
    COPY_SCALAR_FIELD(frameOptions);
    COPY_NODE_FIELD(startOffset);
    COPY_NODE_FIELD(endOffset);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static RangeSubselect *
_copyRangeSubselect(const RangeSubselect *from)
{
    RangeSubselect *newnode = makeNode(RangeSubselect);
 
    COPY_SCALAR_FIELD(lateral);
    COPY_NODE_FIELD(subquery);
    COPY_NODE_FIELD(alias);
 
    return newnode;
}
 
static RangeFunction *
_copyRangeFunction(const RangeFunction *from)
{
    RangeFunction *newnode = makeNode(RangeFunction);
 
    COPY_SCALAR_FIELD(lateral);
    COPY_SCALAR_FIELD(ordinality);
    COPY_SCALAR_FIELD(is_rowsfrom);
    COPY_NODE_FIELD(functions);
    COPY_NODE_FIELD(alias);
    COPY_NODE_FIELD(coldeflist);
 
    return newnode;
}
 
static RangeTableSample *
_copyRangeTableSample(const RangeTableSample *from)
{
    RangeTableSample *newnode = makeNode(RangeTableSample);
 
    COPY_NODE_FIELD(relation);
    COPY_NODE_FIELD(method);
    COPY_NODE_FIELD(args);
    COPY_NODE_FIELD(repeatable);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static RangeTableFunc *
_copyRangeTableFunc(const RangeTableFunc *from)
{
    RangeTableFunc *newnode = makeNode(RangeTableFunc);
 
    COPY_SCALAR_FIELD(lateral);
    COPY_NODE_FIELD(docexpr);
    COPY_NODE_FIELD(rowexpr);
    COPY_NODE_FIELD(namespaces);
    COPY_NODE_FIELD(columns);
    COPY_NODE_FIELD(alias);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static RangeTableFuncCol *
_copyRangeTableFuncCol(const RangeTableFuncCol *from)
{
    RangeTableFuncCol *newnode = makeNode(RangeTableFuncCol);
 
    COPY_STRING_FIELD(colname);
    COPY_NODE_FIELD(typeName);
    COPY_SCALAR_FIELD(for_ordinality);
    COPY_SCALAR_FIELD(is_not_null);
    COPY_NODE_FIELD(colexpr);
    COPY_NODE_FIELD(coldefexpr);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static TypeCast *
_copyTypeCast(const TypeCast *from)
{
    TypeCast   *newnode = makeNode(TypeCast);
 
    COPY_NODE_FIELD(arg);
    COPY_NODE_FIELD(typeName);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static CollateClause *
_copyCollateClause(const CollateClause *from)
{
    CollateClause *newnode = makeNode(CollateClause);
 
    COPY_NODE_FIELD(arg);
    COPY_NODE_FIELD(collname);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static IndexElem *
_copyIndexElem(const IndexElem *from)
{
    IndexElem  *newnode = makeNode(IndexElem);
 
    COPY_STRING_FIELD(name);
    COPY_NODE_FIELD(expr);
    COPY_STRING_FIELD(indexcolname);
    COPY_NODE_FIELD(collation);
    COPY_NODE_FIELD(opclass);
    COPY_NODE_FIELD(opclassopts);
    COPY_SCALAR_FIELD(ordering);
    COPY_SCALAR_FIELD(nulls_ordering);
 
    return newnode;
}
 
static StatsElem *
_copyStatsElem(const StatsElem *from)
{
    StatsElem  *newnode = makeNode(StatsElem);
 
    COPY_STRING_FIELD(name);
    COPY_NODE_FIELD(expr);
 
    return newnode;
}
 
static ColumnDef *
_copyColumnDef(const ColumnDef *from)
{
    ColumnDef  *newnode = makeNode(ColumnDef);
 
    COPY_STRING_FIELD(colname);
    COPY_NODE_FIELD(typeName);
    COPY_STRING_FIELD(compression);
    COPY_SCALAR_FIELD(inhcount);
    COPY_SCALAR_FIELD(is_local);
    COPY_SCALAR_FIELD(is_not_null);
    COPY_SCALAR_FIELD(is_from_type);
    COPY_SCALAR_FIELD(storage);
    COPY_NODE_FIELD(raw_default);
    COPY_NODE_FIELD(cooked_default);
    COPY_SCALAR_FIELD(identity);
    COPY_NODE_FIELD(identitySequence);
    COPY_SCALAR_FIELD(generated);
    COPY_NODE_FIELD(collClause);
    COPY_SCALAR_FIELD(collOid);
    COPY_NODE_FIELD(constraints);
    COPY_NODE_FIELD(fdwoptions);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static Constraint *
_copyConstraint(const Constraint *from)
{
    Constraint *newnode = makeNode(Constraint);
 
    COPY_SCALAR_FIELD(contype);
    COPY_STRING_FIELD(conname);
    COPY_SCALAR_FIELD(deferrable);
    COPY_SCALAR_FIELD(initdeferred);
    COPY_LOCATION_FIELD(location);
    COPY_SCALAR_FIELD(is_no_inherit);
    COPY_NODE_FIELD(raw_expr);
    COPY_STRING_FIELD(cooked_expr);
    COPY_SCALAR_FIELD(generated_when);
    COPY_SCALAR_FIELD(nulls_not_distinct);
    COPY_NODE_FIELD(keys);
    COPY_NODE_FIELD(including);
    COPY_NODE_FIELD(exclusions);
    COPY_NODE_FIELD(options);
    COPY_STRING_FIELD(indexname);
    COPY_STRING_FIELD(indexspace);
    COPY_SCALAR_FIELD(reset_default_tblspc);
    COPY_STRING_FIELD(access_method);
    COPY_NODE_FIELD(where_clause);
    COPY_NODE_FIELD(pktable);
    COPY_NODE_FIELD(fk_attrs);
    COPY_NODE_FIELD(pk_attrs);
    COPY_SCALAR_FIELD(fk_matchtype);
    COPY_SCALAR_FIELD(fk_upd_action);
    COPY_SCALAR_FIELD(fk_del_action);
    COPY_NODE_FIELD(fk_del_set_cols);
    COPY_NODE_FIELD(old_conpfeqop);
    COPY_SCALAR_FIELD(old_pktable_oid);
    COPY_SCALAR_FIELD(skip_validation);
    COPY_SCALAR_FIELD(initially_valid);
 
    return newnode;
}
 
static DefElem *
_copyDefElem(const DefElem *from)
{
    DefElem    *newnode = makeNode(DefElem);
 
    COPY_STRING_FIELD(defnamespace);
    COPY_STRING_FIELD(defname);
    COPY_NODE_FIELD(arg);
    COPY_SCALAR_FIELD(defaction);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static LockingClause *
_copyLockingClause(const LockingClause *from)
{
    LockingClause *newnode = makeNode(LockingClause);
 
    COPY_NODE_FIELD(lockedRels);
    COPY_SCALAR_FIELD(strength);
    COPY_SCALAR_FIELD(waitPolicy);
 
    return newnode;
}
 
static XmlSerialize *
_copyXmlSerialize(const XmlSerialize *from)
{
    XmlSerialize *newnode = makeNode(XmlSerialize);
 
    COPY_SCALAR_FIELD(xmloption);
    COPY_NODE_FIELD(expr);
    COPY_NODE_FIELD(typeName);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static RoleSpec *
_copyRoleSpec(const RoleSpec *from)
{
    RoleSpec   *newnode = makeNode(RoleSpec);
 
    COPY_SCALAR_FIELD(roletype);
    COPY_STRING_FIELD(rolename);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static TriggerTransition *
_copyTriggerTransition(const TriggerTransition *from)
{
    TriggerTransition *newnode = makeNode(TriggerTransition);
 
    COPY_STRING_FIELD(name);
    COPY_SCALAR_FIELD(isNew);
    COPY_SCALAR_FIELD(isTable);
 
    return newnode;
}
 
static Query *
_copyQuery(const Query *from)
{
    Query      *newnode = makeNode(Query);
 
    COPY_SCALAR_FIELD(commandType);
    COPY_SCALAR_FIELD(querySource);
    COPY_SCALAR_FIELD(queryId);
    COPY_SCALAR_FIELD(canSetTag);
    COPY_NODE_FIELD(utilityStmt);
    COPY_SCALAR_FIELD(resultRelation);
    COPY_SCALAR_FIELD(hasAggs);
    COPY_SCALAR_FIELD(hasWindowFuncs);
    COPY_SCALAR_FIELD(hasTargetSRFs);
    COPY_SCALAR_FIELD(hasSubLinks);
    COPY_SCALAR_FIELD(hasDistinctOn);
    COPY_SCALAR_FIELD(hasRecursive);
    COPY_SCALAR_FIELD(hasModifyingCTE);
    COPY_SCALAR_FIELD(hasForUpdate);
    COPY_SCALAR_FIELD(hasRowSecurity);
    COPY_SCALAR_FIELD(isReturn);
    COPY_NODE_FIELD(cteList);
    COPY_NODE_FIELD(rtable);
    COPY_NODE_FIELD(jointree);
    COPY_NODE_FIELD(targetList);
    COPY_SCALAR_FIELD(override);
    COPY_NODE_FIELD(onConflict);
    COPY_NODE_FIELD(returningList);
    COPY_NODE_FIELD(groupClause);
    COPY_SCALAR_FIELD(groupDistinct);
    COPY_NODE_FIELD(groupingSets);
    COPY_NODE_FIELD(havingQual);
    COPY_NODE_FIELD(windowClause);
    COPY_NODE_FIELD(distinctClause);
    COPY_NODE_FIELD(sortClause);
    COPY_NODE_FIELD(limitOffset);
    COPY_NODE_FIELD(limitCount);
    COPY_SCALAR_FIELD(limitOption);
    COPY_NODE_FIELD(rowMarks);
    COPY_NODE_FIELD(setOperations);
    COPY_NODE_FIELD(constraintDeps);
    COPY_NODE_FIELD(withCheckOptions);
    COPY_NODE_FIELD(mergeActionList);
    COPY_SCALAR_FIELD(mergeUseOuterJoin);
    COPY_LOCATION_FIELD(stmt_location);
    COPY_SCALAR_FIELD(stmt_len);
 
    return newnode;
}
 
static RawStmt *
_copyRawStmt(const RawStmt *from)
{
    RawStmt    *newnode = makeNode(RawStmt);
 
    COPY_NODE_FIELD(stmt);
    COPY_LOCATION_FIELD(stmt_location);
    COPY_SCALAR_FIELD(stmt_len);
 
    return newnode;
}
 
static InsertStmt *
_copyInsertStmt(const InsertStmt *from)
{
    InsertStmt *newnode = makeNode(InsertStmt);
 
    COPY_NODE_FIELD(relation);
    COPY_NODE_FIELD(cols);
    COPY_NODE_FIELD(selectStmt);
    COPY_NODE_FIELD(onConflictClause);
    COPY_NODE_FIELD(returningList);
    COPY_NODE_FIELD(withClause);
    COPY_SCALAR_FIELD(override);
 
    return newnode;
}
 
static DeleteStmt *
_copyDeleteStmt(const DeleteStmt *from)
{
    DeleteStmt *newnode = makeNode(DeleteStmt);
 
    COPY_NODE_FIELD(relation);
    COPY_NODE_FIELD(usingClause);
    COPY_NODE_FIELD(whereClause);
    COPY_NODE_FIELD(returningList);
    COPY_NODE_FIELD(withClause);
 
    return newnode;
}
 
static UpdateStmt *
_copyUpdateStmt(const UpdateStmt *from)
{
    UpdateStmt *newnode = makeNode(UpdateStmt);
 
    COPY_NODE_FIELD(relation);
    COPY_NODE_FIELD(targetList);
    COPY_NODE_FIELD(whereClause);
    COPY_NODE_FIELD(fromClause);
    COPY_NODE_FIELD(returningList);
    COPY_NODE_FIELD(withClause);
 
    return newnode;
}
 
static MergeStmt *
_copyMergeStmt(const MergeStmt *from)
{
    MergeStmt  *newnode = makeNode(MergeStmt);
 
    COPY_NODE_FIELD(relation);
    COPY_NODE_FIELD(sourceRelation);
    COPY_NODE_FIELD(joinCondition);
    COPY_NODE_FIELD(mergeWhenClauses);
    COPY_NODE_FIELD(withClause);
 
    return newnode;
}
 
static SelectStmt *
_copySelectStmt(const SelectStmt *from)
{
    SelectStmt *newnode = makeNode(SelectStmt);
 
    COPY_NODE_FIELD(distinctClause);
    COPY_NODE_FIELD(intoClause);
    COPY_NODE_FIELD(targetList);
    COPY_NODE_FIELD(fromClause);
    COPY_NODE_FIELD(whereClause);
    COPY_NODE_FIELD(groupClause);
    COPY_SCALAR_FIELD(groupDistinct);
    COPY_NODE_FIELD(havingClause);
    COPY_NODE_FIELD(windowClause);
    COPY_NODE_FIELD(valuesLists);
    COPY_NODE_FIELD(sortClause);
    COPY_NODE_FIELD(limitOffset);
    COPY_NODE_FIELD(limitCount);
    COPY_SCALAR_FIELD(limitOption);
    COPY_NODE_FIELD(lockingClause);
    COPY_NODE_FIELD(withClause);
    COPY_SCALAR_FIELD(op);
    COPY_SCALAR_FIELD(all);
    COPY_NODE_FIELD(larg);
    COPY_NODE_FIELD(rarg);
 
    return newnode;
}
 
static SetOperationStmt *
_copySetOperationStmt(const SetOperationStmt *from)
{
    SetOperationStmt *newnode = makeNode(SetOperationStmt);
 
    COPY_SCALAR_FIELD(op);
    COPY_SCALAR_FIELD(all);
    COPY_NODE_FIELD(larg);
    COPY_NODE_FIELD(rarg);
    COPY_NODE_FIELD(colTypes);
    COPY_NODE_FIELD(colTypmods);
    COPY_NODE_FIELD(colCollations);
    COPY_NODE_FIELD(groupClauses);
 
    return newnode;
}
 
static ReturnStmt *
_copyReturnStmt(const ReturnStmt *from)
{
    ReturnStmt *newnode = makeNode(ReturnStmt);
 
    COPY_NODE_FIELD(returnval);
 
    return newnode;
}
 
static PLAssignStmt *
_copyPLAssignStmt(const PLAssignStmt *from)
{
    PLAssignStmt *newnode = makeNode(PLAssignStmt);
 
    COPY_STRING_FIELD(name);
    COPY_NODE_FIELD(indirection);
    COPY_SCALAR_FIELD(nnames);
    COPY_NODE_FIELD(val);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static AlterTableStmt *
_copyAlterTableStmt(const AlterTableStmt *from)
{
    AlterTableStmt *newnode = makeNode(AlterTableStmt);
 
    COPY_NODE_FIELD(relation);
    COPY_NODE_FIELD(cmds);
    COPY_SCALAR_FIELD(objtype);
    COPY_SCALAR_FIELD(missing_ok);
 
    return newnode;
}
 
static AlterTableCmd *
_copyAlterTableCmd(const AlterTableCmd *from)
{
    AlterTableCmd *newnode = makeNode(AlterTableCmd);
 
    COPY_SCALAR_FIELD(subtype);
    COPY_STRING_FIELD(name);
    COPY_SCALAR_FIELD(num);
    COPY_NODE_FIELD(newowner);
    COPY_NODE_FIELD(def);
    COPY_SCALAR_FIELD(behavior);
    COPY_SCALAR_FIELD(missing_ok);
 
    return newnode;
}
 
static AlterCollationStmt *
_copyAlterCollationStmt(const AlterCollationStmt *from)
{
    AlterCollationStmt *newnode = makeNode(AlterCollationStmt);
 
    COPY_NODE_FIELD(collname);
 
    return newnode;
}
 
static AlterDomainStmt *
_copyAlterDomainStmt(const AlterDomainStmt *from)
{
    AlterDomainStmt *newnode = makeNode(AlterDomainStmt);
 
    COPY_SCALAR_FIELD(subtype);
    COPY_NODE_FIELD(typeName);
    COPY_STRING_FIELD(name);
    COPY_NODE_FIELD(def);
    COPY_SCALAR_FIELD(behavior);
    COPY_SCALAR_FIELD(missing_ok);
 
    return newnode;
}
 
static GrantStmt *
_copyGrantStmt(const GrantStmt *from)
{
    GrantStmt  *newnode = makeNode(GrantStmt);
 
    COPY_SCALAR_FIELD(is_grant);
    COPY_SCALAR_FIELD(targtype);
    COPY_SCALAR_FIELD(objtype);
    COPY_NODE_FIELD(objects);
    COPY_NODE_FIELD(privileges);
    COPY_NODE_FIELD(grantees);
    COPY_SCALAR_FIELD(grant_option);
    COPY_NODE_FIELD(grantor);
    COPY_SCALAR_FIELD(behavior);
 
    return newnode;
}
 
static ObjectWithArgs *
_copyObjectWithArgs(const ObjectWithArgs *from)
{
    ObjectWithArgs *newnode = makeNode(ObjectWithArgs);
 
    COPY_NODE_FIELD(objname);
    COPY_NODE_FIELD(objargs);
    COPY_NODE_FIELD(objfuncargs);
    COPY_SCALAR_FIELD(args_unspecified);
 
    return newnode;
}
 
static AccessPriv *
_copyAccessPriv(const AccessPriv *from)
{
    AccessPriv *newnode = makeNode(AccessPriv);
 
    COPY_STRING_FIELD(priv_name);
    COPY_NODE_FIELD(cols);
 
    return newnode;
}
 
static GrantRoleStmt *
_copyGrantRoleStmt(const GrantRoleStmt *from)
{
    GrantRoleStmt *newnode = makeNode(GrantRoleStmt);
 
    COPY_NODE_FIELD(granted_roles);
    COPY_NODE_FIELD(grantee_roles);
    COPY_SCALAR_FIELD(is_grant);
    COPY_SCALAR_FIELD(admin_opt);
    COPY_NODE_FIELD(grantor);
    COPY_SCALAR_FIELD(behavior);
 
    return newnode;
}
 
static AlterDefaultPrivilegesStmt *
_copyAlterDefaultPrivilegesStmt(const AlterDefaultPrivilegesStmt *from)
{
    AlterDefaultPrivilegesStmt *newnode = makeNode(AlterDefaultPrivilegesStmt);
 
    COPY_NODE_FIELD(options);
    COPY_NODE_FIELD(action);
 
    return newnode;
}
 
static DeclareCursorStmt *
_copyDeclareCursorStmt(const DeclareCursorStmt *from)
{
    DeclareCursorStmt *newnode = makeNode(DeclareCursorStmt);
 
    COPY_STRING_FIELD(portalname);
    COPY_SCALAR_FIELD(options);
    COPY_NODE_FIELD(query);
 
    return newnode;
}
 
static ClosePortalStmt *
_copyClosePortalStmt(const ClosePortalStmt *from)
{
    ClosePortalStmt *newnode = makeNode(ClosePortalStmt);
 
    COPY_STRING_FIELD(portalname);
 
    return newnode;
}
 
static CallStmt *
_copyCallStmt(const CallStmt *from)
{
    CallStmt   *newnode = makeNode(CallStmt);
 
    COPY_NODE_FIELD(funccall);
    COPY_NODE_FIELD(funcexpr);
    COPY_NODE_FIELD(outargs);
 
    return newnode;
}
 
static ClusterStmt *
_copyClusterStmt(const ClusterStmt *from)
{
    ClusterStmt *newnode = makeNode(ClusterStmt);
 
    COPY_NODE_FIELD(relation);
    COPY_STRING_FIELD(indexname);
    COPY_NODE_FIELD(params);
 
    return newnode;
}
 
static CopyStmt *
_copyCopyStmt(const CopyStmt *from)
{
    CopyStmt   *newnode = makeNode(CopyStmt);
 
    COPY_NODE_FIELD(relation);
    COPY_NODE_FIELD(query);
    COPY_NODE_FIELD(attlist);
    COPY_SCALAR_FIELD(is_from);
    COPY_SCALAR_FIELD(is_program);
    COPY_STRING_FIELD(filename);
    COPY_NODE_FIELD(options);
    COPY_NODE_FIELD(whereClause);
 
    return newnode;
}
 
/*
 * CopyCreateStmtFields
 *
 *      This function copies the fields of the CreateStmt node.  It is used by
 *      copy functions for classes which inherit from CreateStmt.
 */
static void
CopyCreateStmtFields(const CreateStmt *from, CreateStmt *newnode)
{
    COPY_NODE_FIELD(relation);
    COPY_NODE_FIELD(tableElts);
    COPY_NODE_FIELD(inhRelations);
    COPY_NODE_FIELD(partspec);
    COPY_NODE_FIELD(partbound);
    COPY_NODE_FIELD(ofTypename);
    COPY_NODE_FIELD(constraints);
    COPY_NODE_FIELD(options);
    COPY_SCALAR_FIELD(oncommit);
    COPY_STRING_FIELD(tablespacename);
    COPY_STRING_FIELD(accessMethod);
    COPY_SCALAR_FIELD(if_not_exists);
}
 
static CreateStmt *
_copyCreateStmt(const CreateStmt *from)
{
    CreateStmt *newnode = makeNode(CreateStmt);
 
    CopyCreateStmtFields(from, newnode);
 
    return newnode;
}
 
static TableLikeClause *
_copyTableLikeClause(const TableLikeClause *from)
{
    TableLikeClause *newnode = makeNode(TableLikeClause);
 
    COPY_NODE_FIELD(relation);
    COPY_SCALAR_FIELD(options);
    COPY_SCALAR_FIELD(relationOid);
 
    return newnode;
}
 
static DefineStmt *
_copyDefineStmt(const DefineStmt *from)
{
    DefineStmt *newnode = makeNode(DefineStmt);
 
    COPY_SCALAR_FIELD(kind);
    COPY_SCALAR_FIELD(oldstyle);
    COPY_NODE_FIELD(defnames);
    COPY_NODE_FIELD(args);
    COPY_NODE_FIELD(definition);
    COPY_SCALAR_FIELD(if_not_exists);
    COPY_SCALAR_FIELD(replace);
 
    return newnode;
}
 
static DropStmt *
_copyDropStmt(const DropStmt *from)
{
    DropStmt   *newnode = makeNode(DropStmt);
 
    COPY_NODE_FIELD(objects);
    COPY_SCALAR_FIELD(removeType);
    COPY_SCALAR_FIELD(behavior);
    COPY_SCALAR_FIELD(missing_ok);
    COPY_SCALAR_FIELD(concurrent);
 
    return newnode;
}
 
static TruncateStmt *
_copyTruncateStmt(const TruncateStmt *from)
{
    TruncateStmt *newnode = makeNode(TruncateStmt);
 
    COPY_NODE_FIELD(relations);
    COPY_SCALAR_FIELD(restart_seqs);
    COPY_SCALAR_FIELD(behavior);
 
    return newnode;
}
 
static CommentStmt *
_copyCommentStmt(const CommentStmt *from)
{
    CommentStmt *newnode = makeNode(CommentStmt);
 
    COPY_SCALAR_FIELD(objtype);
    COPY_NODE_FIELD(object);
    COPY_STRING_FIELD(comment);
 
    return newnode;
}
 
static SecLabelStmt *
_copySecLabelStmt(const SecLabelStmt *from)
{
    SecLabelStmt *newnode = makeNode(SecLabelStmt);
 
    COPY_SCALAR_FIELD(objtype);
    COPY_NODE_FIELD(object);
    COPY_STRING_FIELD(provider);
    COPY_STRING_FIELD(label);
 
    return newnode;
}
 
static FetchStmt *
_copyFetchStmt(const FetchStmt *from)
{
    FetchStmt  *newnode = makeNode(FetchStmt);
 
    COPY_SCALAR_FIELD(direction);
    COPY_SCALAR_FIELD(howMany);
    COPY_STRING_FIELD(portalname);
    COPY_SCALAR_FIELD(ismove);
 
    return newnode;
}
 
static IndexStmt *
_copyIndexStmt(const IndexStmt *from)
{
    IndexStmt  *newnode = makeNode(IndexStmt);
 
    COPY_STRING_FIELD(idxname);
    COPY_NODE_FIELD(relation);
    COPY_STRING_FIELD(accessMethod);
    COPY_STRING_FIELD(tableSpace);
    COPY_NODE_FIELD(indexParams);
    COPY_NODE_FIELD(indexIncludingParams);
    COPY_NODE_FIELD(options);
    COPY_NODE_FIELD(whereClause);
    COPY_NODE_FIELD(excludeOpNames);
    COPY_STRING_FIELD(idxcomment);
    COPY_SCALAR_FIELD(indexOid);
    COPY_SCALAR_FIELD(oldNode);
    COPY_SCALAR_FIELD(oldCreateSubid);
    COPY_SCALAR_FIELD(oldFirstRelfilenodeSubid);
    COPY_SCALAR_FIELD(unique);
    COPY_SCALAR_FIELD(nulls_not_distinct);
    COPY_SCALAR_FIELD(primary);
    COPY_SCALAR_FIELD(isconstraint);
    COPY_SCALAR_FIELD(deferrable);
    COPY_SCALAR_FIELD(initdeferred);
    COPY_SCALAR_FIELD(transformed);
    COPY_SCALAR_FIELD(concurrent);
    COPY_SCALAR_FIELD(if_not_exists);
    COPY_SCALAR_FIELD(reset_default_tblspc);
 
    return newnode;
}
 
static CreateStatsStmt *
_copyCreateStatsStmt(const CreateStatsStmt *from)
{
    CreateStatsStmt *newnode = makeNode(CreateStatsStmt);
 
    COPY_NODE_FIELD(defnames);
    COPY_NODE_FIELD(stat_types);
    COPY_NODE_FIELD(exprs);
    COPY_NODE_FIELD(relations);
    COPY_STRING_FIELD(stxcomment);
    COPY_SCALAR_FIELD(transformed);
    COPY_SCALAR_FIELD(if_not_exists);
 
    return newnode;
}
 
static AlterStatsStmt *
_copyAlterStatsStmt(const AlterStatsStmt *from)
{
    AlterStatsStmt *newnode = makeNode(AlterStatsStmt);
 
    COPY_NODE_FIELD(defnames);
    COPY_SCALAR_FIELD(stxstattarget);
    COPY_SCALAR_FIELD(missing_ok);
 
    return newnode;
}
 
static CreateFunctionStmt *
_copyCreateFunctionStmt(const CreateFunctionStmt *from)
{
    CreateFunctionStmt *newnode = makeNode(CreateFunctionStmt);
 
    COPY_SCALAR_FIELD(is_procedure);
    COPY_SCALAR_FIELD(replace);
    COPY_NODE_FIELD(funcname);
    COPY_NODE_FIELD(parameters);
    COPY_NODE_FIELD(returnType);
    COPY_NODE_FIELD(options);
    COPY_NODE_FIELD(sql_body);
 
    return newnode;
}
 
static FunctionParameter *
_copyFunctionParameter(const FunctionParameter *from)
{
    FunctionParameter *newnode = makeNode(FunctionParameter);
 
    COPY_STRING_FIELD(name);
    COPY_NODE_FIELD(argType);
    COPY_SCALAR_FIELD(mode);
    COPY_NODE_FIELD(defexpr);
 
    return newnode;
}
 
static AlterFunctionStmt *
_copyAlterFunctionStmt(const AlterFunctionStmt *from)
{
    AlterFunctionStmt *newnode = makeNode(AlterFunctionStmt);
 
    COPY_SCALAR_FIELD(objtype);
    COPY_NODE_FIELD(func);
    COPY_NODE_FIELD(actions);
 
    return newnode;
}
 
static DoStmt *
_copyDoStmt(const DoStmt *from)
{
    DoStmt     *newnode = makeNode(DoStmt);
 
    COPY_NODE_FIELD(args);
 
    return newnode;
}
 
static RenameStmt *
_copyRenameStmt(const RenameStmt *from)
{
    RenameStmt *newnode = makeNode(RenameStmt);
 
    COPY_SCALAR_FIELD(renameType);
    COPY_SCALAR_FIELD(relationType);
    COPY_NODE_FIELD(relation);
    COPY_NODE_FIELD(object);
    COPY_STRING_FIELD(subname);
    COPY_STRING_FIELD(newname);
    COPY_SCALAR_FIELD(behavior);
    COPY_SCALAR_FIELD(missing_ok);
 
    return newnode;
}
 
static AlterObjectDependsStmt *
_copyAlterObjectDependsStmt(const AlterObjectDependsStmt *from)
{
    AlterObjectDependsStmt *newnode = makeNode(AlterObjectDependsStmt);
 
    COPY_SCALAR_FIELD(objectType);
    COPY_NODE_FIELD(relation);
    COPY_NODE_FIELD(object);
    COPY_NODE_FIELD(extname);
    COPY_SCALAR_FIELD(remove);
 
    return newnode;
}
 
static AlterObjectSchemaStmt *
_copyAlterObjectSchemaStmt(const AlterObjectSchemaStmt *from)
{
    AlterObjectSchemaStmt *newnode = makeNode(AlterObjectSchemaStmt);
 
    COPY_SCALAR_FIELD(objectType);
    COPY_NODE_FIELD(relation);
    COPY_NODE_FIELD(object);
    COPY_STRING_FIELD(newschema);
    COPY_SCALAR_FIELD(missing_ok);
 
    return newnode;
}
 
static AlterOwnerStmt *
_copyAlterOwnerStmt(const AlterOwnerStmt *from)
{
    AlterOwnerStmt *newnode = makeNode(AlterOwnerStmt);
 
    COPY_SCALAR_FIELD(objectType);
    COPY_NODE_FIELD(relation);
    COPY_NODE_FIELD(object);
    COPY_NODE_FIELD(newowner);
 
    return newnode;
}
 
static AlterOperatorStmt *
_copyAlterOperatorStmt(const AlterOperatorStmt *from)
{
    AlterOperatorStmt *newnode = makeNode(AlterOperatorStmt);
 
    COPY_NODE_FIELD(opername);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static AlterTypeStmt *
_copyAlterTypeStmt(const AlterTypeStmt *from)
{
    AlterTypeStmt *newnode = makeNode(AlterTypeStmt);
 
    COPY_NODE_FIELD(typeName);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static RuleStmt *
_copyRuleStmt(const RuleStmt *from)
{
    RuleStmt   *newnode = makeNode(RuleStmt);
 
    COPY_NODE_FIELD(relation);
    COPY_STRING_FIELD(rulename);
    COPY_NODE_FIELD(whereClause);
    COPY_SCALAR_FIELD(event);
    COPY_SCALAR_FIELD(instead);
    COPY_NODE_FIELD(actions);
    COPY_SCALAR_FIELD(replace);
 
    return newnode;
}
 
static NotifyStmt *
_copyNotifyStmt(const NotifyStmt *from)
{
    NotifyStmt *newnode = makeNode(NotifyStmt);
 
    COPY_STRING_FIELD(conditionname);
    COPY_STRING_FIELD(payload);
 
    return newnode;
}
 
static ListenStmt *
_copyListenStmt(const ListenStmt *from)
{
    ListenStmt *newnode = makeNode(ListenStmt);
 
    COPY_STRING_FIELD(conditionname);
 
    return newnode;
}
 
static UnlistenStmt *
_copyUnlistenStmt(const UnlistenStmt *from)
{
    UnlistenStmt *newnode = makeNode(UnlistenStmt);
 
    COPY_STRING_FIELD(conditionname);
 
    return newnode;
}
 
static TransactionStmt *
_copyTransactionStmt(const TransactionStmt *from)
{
    TransactionStmt *newnode = makeNode(TransactionStmt);
 
    COPY_SCALAR_FIELD(kind);
    COPY_NODE_FIELD(options);
    COPY_STRING_FIELD(savepoint_name);
    COPY_STRING_FIELD(gid);
    COPY_SCALAR_FIELD(chain);
 
    return newnode;
}
 
static CompositeTypeStmt *
_copyCompositeTypeStmt(const CompositeTypeStmt *from)
{
    CompositeTypeStmt *newnode = makeNode(CompositeTypeStmt);
 
    COPY_NODE_FIELD(typevar);
    COPY_NODE_FIELD(coldeflist);
 
    return newnode;
}
 
static CreateEnumStmt *
_copyCreateEnumStmt(const CreateEnumStmt *from)
{
    CreateEnumStmt *newnode = makeNode(CreateEnumStmt);
 
    COPY_NODE_FIELD(typeName);
    COPY_NODE_FIELD(vals);
 
    return newnode;
}
 
static CreateRangeStmt *
_copyCreateRangeStmt(const CreateRangeStmt *from)
{
    CreateRangeStmt *newnode = makeNode(CreateRangeStmt);
 
    COPY_NODE_FIELD(typeName);
    COPY_NODE_FIELD(params);
 
    return newnode;
}
 
static AlterEnumStmt *
_copyAlterEnumStmt(const AlterEnumStmt *from)
{
    AlterEnumStmt *newnode = makeNode(AlterEnumStmt);
 
    COPY_NODE_FIELD(typeName);
    COPY_STRING_FIELD(oldVal);
    COPY_STRING_FIELD(newVal);
    COPY_STRING_FIELD(newValNeighbor);
    COPY_SCALAR_FIELD(newValIsAfter);
    COPY_SCALAR_FIELD(skipIfNewValExists);
 
    return newnode;
}
 
static ViewStmt *
_copyViewStmt(const ViewStmt *from)
{
    ViewStmt   *newnode = makeNode(ViewStmt);
 
    COPY_NODE_FIELD(view);
    COPY_NODE_FIELD(aliases);
    COPY_NODE_FIELD(query);
    COPY_SCALAR_FIELD(replace);
    COPY_NODE_FIELD(options);
    COPY_SCALAR_FIELD(withCheckOption);
 
    return newnode;
}
 
static LoadStmt *
_copyLoadStmt(const LoadStmt *from)
{
    LoadStmt   *newnode = makeNode(LoadStmt);
 
    COPY_STRING_FIELD(filename);
 
    return newnode;
}
 
static CreateDomainStmt *
_copyCreateDomainStmt(const CreateDomainStmt *from)
{
    CreateDomainStmt *newnode = makeNode(CreateDomainStmt);
 
    COPY_NODE_FIELD(domainname);
    COPY_NODE_FIELD(typeName);
    COPY_NODE_FIELD(collClause);
    COPY_NODE_FIELD(constraints);
 
    return newnode;
}
 
static CreateOpClassStmt *
_copyCreateOpClassStmt(const CreateOpClassStmt *from)
{
    CreateOpClassStmt *newnode = makeNode(CreateOpClassStmt);
 
    COPY_NODE_FIELD(opclassname);
    COPY_NODE_FIELD(opfamilyname);
    COPY_STRING_FIELD(amname);
    COPY_NODE_FIELD(datatype);
    COPY_NODE_FIELD(items);
    COPY_SCALAR_FIELD(isDefault);
 
    return newnode;
}
 
static CreateOpClassItem *
_copyCreateOpClassItem(const CreateOpClassItem *from)
{
    CreateOpClassItem *newnode = makeNode(CreateOpClassItem);
 
    COPY_SCALAR_FIELD(itemtype);
    COPY_NODE_FIELD(name);
    COPY_SCALAR_FIELD(number);
    COPY_NODE_FIELD(order_family);
    COPY_NODE_FIELD(class_args);
    COPY_NODE_FIELD(storedtype);
 
    return newnode;
}
 
static CreateOpFamilyStmt *
_copyCreateOpFamilyStmt(const CreateOpFamilyStmt *from)
{
    CreateOpFamilyStmt *newnode = makeNode(CreateOpFamilyStmt);
 
    COPY_NODE_FIELD(opfamilyname);
    COPY_STRING_FIELD(amname);
 
    return newnode;
}
 
static AlterOpFamilyStmt *
_copyAlterOpFamilyStmt(const AlterOpFamilyStmt *from)
{
    AlterOpFamilyStmt *newnode = makeNode(AlterOpFamilyStmt);
 
    COPY_NODE_FIELD(opfamilyname);
    COPY_STRING_FIELD(amname);
    COPY_SCALAR_FIELD(isDrop);
    COPY_NODE_FIELD(items);
 
    return newnode;
}
 
static CreatedbStmt *
_copyCreatedbStmt(const CreatedbStmt *from)
{
    CreatedbStmt *newnode = makeNode(CreatedbStmt);
 
    COPY_STRING_FIELD(dbname);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static AlterDatabaseStmt *
_copyAlterDatabaseStmt(const AlterDatabaseStmt *from)
{
    AlterDatabaseStmt *newnode = makeNode(AlterDatabaseStmt);
 
    COPY_STRING_FIELD(dbname);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static AlterDatabaseRefreshCollStmt *
_copyAlterDatabaseRefreshCollStmt(const AlterDatabaseRefreshCollStmt *from)
{
    AlterDatabaseRefreshCollStmt *newnode = makeNode(AlterDatabaseRefreshCollStmt);
 
    COPY_STRING_FIELD(dbname);
 
    return newnode;
}
 
static AlterDatabaseSetStmt *
_copyAlterDatabaseSetStmt(const AlterDatabaseSetStmt *from)
{
    AlterDatabaseSetStmt *newnode = makeNode(AlterDatabaseSetStmt);
 
    COPY_STRING_FIELD(dbname);
    COPY_NODE_FIELD(setstmt);
 
    return newnode;
}
 
static DropdbStmt *
_copyDropdbStmt(const DropdbStmt *from)
{
    DropdbStmt *newnode = makeNode(DropdbStmt);
 
    COPY_STRING_FIELD(dbname);
    COPY_SCALAR_FIELD(missing_ok);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static VacuumStmt *
_copyVacuumStmt(const VacuumStmt *from)
{
    VacuumStmt *newnode = makeNode(VacuumStmt);
 
    COPY_NODE_FIELD(options);
    COPY_NODE_FIELD(rels);
    COPY_SCALAR_FIELD(is_vacuumcmd);
 
    return newnode;
}
 
static VacuumRelation *
_copyVacuumRelation(const VacuumRelation *from)
{
    VacuumRelation *newnode = makeNode(VacuumRelation);
 
    COPY_NODE_FIELD(relation);
    COPY_SCALAR_FIELD(oid);
    COPY_NODE_FIELD(va_cols);
 
    return newnode;
}
 
static ExplainStmt *
_copyExplainStmt(const ExplainStmt *from)
{
    ExplainStmt *newnode = makeNode(ExplainStmt);
 
    COPY_NODE_FIELD(query);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static CreateTableAsStmt *
_copyCreateTableAsStmt(const CreateTableAsStmt *from)
{
    CreateTableAsStmt *newnode = makeNode(CreateTableAsStmt);
 
    COPY_NODE_FIELD(query);
    COPY_NODE_FIELD(into);
    COPY_SCALAR_FIELD(objtype);
    COPY_SCALAR_FIELD(is_select_into);
    COPY_SCALAR_FIELD(if_not_exists);
 
    return newnode;
}
 
static RefreshMatViewStmt *
_copyRefreshMatViewStmt(const RefreshMatViewStmt *from)
{
    RefreshMatViewStmt *newnode = makeNode(RefreshMatViewStmt);
 
    COPY_SCALAR_FIELD(concurrent);
    COPY_SCALAR_FIELD(skipData);
    COPY_NODE_FIELD(relation);
 
    return newnode;
}
 
static ReplicaIdentityStmt *
_copyReplicaIdentityStmt(const ReplicaIdentityStmt *from)
{
    ReplicaIdentityStmt *newnode = makeNode(ReplicaIdentityStmt);
 
    COPY_SCALAR_FIELD(identity_type);
    COPY_STRING_FIELD(name);
 
    return newnode;
}
 
static AlterSystemStmt *
_copyAlterSystemStmt(const AlterSystemStmt *from)
{
    AlterSystemStmt *newnode = makeNode(AlterSystemStmt);
 
    COPY_NODE_FIELD(setstmt);
 
    return newnode;
}
 
static CreateSeqStmt *
_copyCreateSeqStmt(const CreateSeqStmt *from)
{
    CreateSeqStmt *newnode = makeNode(CreateSeqStmt);
 
    COPY_NODE_FIELD(sequence);
    COPY_NODE_FIELD(options);
    COPY_SCALAR_FIELD(ownerId);
    COPY_SCALAR_FIELD(for_identity);
    COPY_SCALAR_FIELD(if_not_exists);
 
    return newnode;
}
 
static AlterSeqStmt *
_copyAlterSeqStmt(const AlterSeqStmt *from)
{
    AlterSeqStmt *newnode = makeNode(AlterSeqStmt);
 
    COPY_NODE_FIELD(sequence);
    COPY_NODE_FIELD(options);
    COPY_SCALAR_FIELD(for_identity);
    COPY_SCALAR_FIELD(missing_ok);
 
    return newnode;
}
 
static VariableSetStmt *
_copyVariableSetStmt(const VariableSetStmt *from)
{
    VariableSetStmt *newnode = makeNode(VariableSetStmt);
 
    COPY_SCALAR_FIELD(kind);
    COPY_STRING_FIELD(name);
    COPY_NODE_FIELD(args);
    COPY_SCALAR_FIELD(is_local);
 
    return newnode;
}
 
static VariableShowStmt *
_copyVariableShowStmt(const VariableShowStmt *from)
{
    VariableShowStmt *newnode = makeNode(VariableShowStmt);
 
    COPY_STRING_FIELD(name);
 
    return newnode;
}
 
static DiscardStmt *
_copyDiscardStmt(const DiscardStmt *from)
{
    DiscardStmt *newnode = makeNode(DiscardStmt);
 
    COPY_SCALAR_FIELD(target);
 
    return newnode;
}
 
static CreateTableSpaceStmt *
_copyCreateTableSpaceStmt(const CreateTableSpaceStmt *from)
{
    CreateTableSpaceStmt *newnode = makeNode(CreateTableSpaceStmt);
 
    COPY_STRING_FIELD(tablespacename);
    COPY_NODE_FIELD(owner);
    COPY_STRING_FIELD(location);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static DropTableSpaceStmt *
_copyDropTableSpaceStmt(const DropTableSpaceStmt *from)
{
    DropTableSpaceStmt *newnode = makeNode(DropTableSpaceStmt);
 
    COPY_STRING_FIELD(tablespacename);
    COPY_SCALAR_FIELD(missing_ok);
 
    return newnode;
}
 
static AlterTableSpaceOptionsStmt *
_copyAlterTableSpaceOptionsStmt(const AlterTableSpaceOptionsStmt *from)
{
    AlterTableSpaceOptionsStmt *newnode = makeNode(AlterTableSpaceOptionsStmt);
 
    COPY_STRING_FIELD(tablespacename);
    COPY_NODE_FIELD(options);
    COPY_SCALAR_FIELD(isReset);
 
    return newnode;
}
 
static AlterTableMoveAllStmt *
_copyAlterTableMoveAllStmt(const AlterTableMoveAllStmt *from)
{
    AlterTableMoveAllStmt *newnode = makeNode(AlterTableMoveAllStmt);
 
    COPY_STRING_FIELD(orig_tablespacename);
    COPY_SCALAR_FIELD(objtype);
    COPY_NODE_FIELD(roles);
    COPY_STRING_FIELD(new_tablespacename);
    COPY_SCALAR_FIELD(nowait);
 
    return newnode;
}
 
static CreateExtensionStmt *
_copyCreateExtensionStmt(const CreateExtensionStmt *from)
{
    CreateExtensionStmt *newnode = makeNode(CreateExtensionStmt);
 
    COPY_STRING_FIELD(extname);
    COPY_SCALAR_FIELD(if_not_exists);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static AlterExtensionStmt *
_copyAlterExtensionStmt(const AlterExtensionStmt *from)
{
    AlterExtensionStmt *newnode = makeNode(AlterExtensionStmt);
 
    COPY_STRING_FIELD(extname);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static AlterExtensionContentsStmt *
_copyAlterExtensionContentsStmt(const AlterExtensionContentsStmt *from)
{
    AlterExtensionContentsStmt *newnode = makeNode(AlterExtensionContentsStmt);
 
    COPY_STRING_FIELD(extname);
    COPY_SCALAR_FIELD(action);
    COPY_SCALAR_FIELD(objtype);
    COPY_NODE_FIELD(object);
 
    return newnode;
}
 
static CreateFdwStmt *
_copyCreateFdwStmt(const CreateFdwStmt *from)
{
    CreateFdwStmt *newnode = makeNode(CreateFdwStmt);
 
    COPY_STRING_FIELD(fdwname);
    COPY_NODE_FIELD(func_options);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static AlterFdwStmt *
_copyAlterFdwStmt(const AlterFdwStmt *from)
{
    AlterFdwStmt *newnode = makeNode(AlterFdwStmt);
 
    COPY_STRING_FIELD(fdwname);
    COPY_NODE_FIELD(func_options);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static CreateForeignServerStmt *
_copyCreateForeignServerStmt(const CreateForeignServerStmt *from)
{
    CreateForeignServerStmt *newnode = makeNode(CreateForeignServerStmt);
 
    COPY_STRING_FIELD(servername);
    COPY_STRING_FIELD(servertype);
    COPY_STRING_FIELD(version);
    COPY_STRING_FIELD(fdwname);
    COPY_SCALAR_FIELD(if_not_exists);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static AlterForeignServerStmt *
_copyAlterForeignServerStmt(const AlterForeignServerStmt *from)
{
    AlterForeignServerStmt *newnode = makeNode(AlterForeignServerStmt);
 
    COPY_STRING_FIELD(servername);
    COPY_STRING_FIELD(version);
    COPY_NODE_FIELD(options);
    COPY_SCALAR_FIELD(has_version);
 
    return newnode;
}
 
static CreateUserMappingStmt *
_copyCreateUserMappingStmt(const CreateUserMappingStmt *from)
{
    CreateUserMappingStmt *newnode = makeNode(CreateUserMappingStmt);
 
    COPY_NODE_FIELD(user);
    COPY_STRING_FIELD(servername);
    COPY_SCALAR_FIELD(if_not_exists);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static AlterUserMappingStmt *
_copyAlterUserMappingStmt(const AlterUserMappingStmt *from)
{
    AlterUserMappingStmt *newnode = makeNode(AlterUserMappingStmt);
 
    COPY_NODE_FIELD(user);
    COPY_STRING_FIELD(servername);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static DropUserMappingStmt *
_copyDropUserMappingStmt(const DropUserMappingStmt *from)
{
    DropUserMappingStmt *newnode = makeNode(DropUserMappingStmt);
 
    COPY_NODE_FIELD(user);
    COPY_STRING_FIELD(servername);
    COPY_SCALAR_FIELD(missing_ok);
 
    return newnode;
}
 
static CreateForeignTableStmt *
_copyCreateForeignTableStmt(const CreateForeignTableStmt *from)
{
    CreateForeignTableStmt *newnode = makeNode(CreateForeignTableStmt);
 
    CopyCreateStmtFields((const CreateStmt *) from, (CreateStmt *) newnode);
 
    COPY_STRING_FIELD(servername);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static ImportForeignSchemaStmt *
_copyImportForeignSchemaStmt(const ImportForeignSchemaStmt *from)
{
    ImportForeignSchemaStmt *newnode = makeNode(ImportForeignSchemaStmt);
 
    COPY_STRING_FIELD(server_name);
    COPY_STRING_FIELD(remote_schema);
    COPY_STRING_FIELD(local_schema);
    COPY_SCALAR_FIELD(list_type);
    COPY_NODE_FIELD(table_list);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static CreateTransformStmt *
_copyCreateTransformStmt(const CreateTransformStmt *from)
{
    CreateTransformStmt *newnode = makeNode(CreateTransformStmt);
 
    COPY_SCALAR_FIELD(replace);
    COPY_NODE_FIELD(type_name);
    COPY_STRING_FIELD(lang);
    COPY_NODE_FIELD(fromsql);
    COPY_NODE_FIELD(tosql);
 
    return newnode;
}
 
static CreateAmStmt *
_copyCreateAmStmt(const CreateAmStmt *from)
{
    CreateAmStmt *newnode = makeNode(CreateAmStmt);
 
    COPY_STRING_FIELD(amname);
    COPY_NODE_FIELD(handler_name);
    COPY_SCALAR_FIELD(amtype);
 
    return newnode;
}
 
static CreateTrigStmt *
_copyCreateTrigStmt(const CreateTrigStmt *from)
{
    CreateTrigStmt *newnode = makeNode(CreateTrigStmt);
 
    COPY_SCALAR_FIELD(replace);
    COPY_SCALAR_FIELD(isconstraint);
    COPY_STRING_FIELD(trigname);
    COPY_NODE_FIELD(relation);
    COPY_NODE_FIELD(funcname);
    COPY_NODE_FIELD(args);
    COPY_SCALAR_FIELD(row);
    COPY_SCALAR_FIELD(timing);
    COPY_SCALAR_FIELD(events);
    COPY_NODE_FIELD(columns);
    COPY_NODE_FIELD(whenClause);
    COPY_NODE_FIELD(transitionRels);
    COPY_SCALAR_FIELD(deferrable);
    COPY_SCALAR_FIELD(initdeferred);
    COPY_NODE_FIELD(constrrel);
 
    return newnode;
}
 
static CreateEventTrigStmt *
_copyCreateEventTrigStmt(const CreateEventTrigStmt *from)
{
    CreateEventTrigStmt *newnode = makeNode(CreateEventTrigStmt);
 
    COPY_STRING_FIELD(trigname);
    COPY_STRING_FIELD(eventname);
    COPY_NODE_FIELD(whenclause);
    COPY_NODE_FIELD(funcname);
 
    return newnode;
}
 
static AlterEventTrigStmt *
_copyAlterEventTrigStmt(const AlterEventTrigStmt *from)
{
    AlterEventTrigStmt *newnode = makeNode(AlterEventTrigStmt);
 
    COPY_STRING_FIELD(trigname);
    COPY_SCALAR_FIELD(tgenabled);
 
    return newnode;
}
 
static CreatePLangStmt *
_copyCreatePLangStmt(const CreatePLangStmt *from)
{
    CreatePLangStmt *newnode = makeNode(CreatePLangStmt);
 
    COPY_SCALAR_FIELD(replace);
    COPY_STRING_FIELD(plname);
    COPY_NODE_FIELD(plhandler);
    COPY_NODE_FIELD(plinline);
    COPY_NODE_FIELD(plvalidator);
    COPY_SCALAR_FIELD(pltrusted);
 
    return newnode;
}
 
static CreateRoleStmt *
_copyCreateRoleStmt(const CreateRoleStmt *from)
{
    CreateRoleStmt *newnode = makeNode(CreateRoleStmt);
 
    COPY_SCALAR_FIELD(stmt_type);
    COPY_STRING_FIELD(role);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static AlterRoleStmt *
_copyAlterRoleStmt(const AlterRoleStmt *from)
{
    AlterRoleStmt *newnode = makeNode(AlterRoleStmt);
 
    COPY_NODE_FIELD(role);
    COPY_NODE_FIELD(options);
    COPY_SCALAR_FIELD(action);
 
    return newnode;
}
 
static AlterRoleSetStmt *
_copyAlterRoleSetStmt(const AlterRoleSetStmt *from)
{
    AlterRoleSetStmt *newnode = makeNode(AlterRoleSetStmt);
 
    COPY_NODE_FIELD(role);
    COPY_STRING_FIELD(database);
    COPY_NODE_FIELD(setstmt);
 
    return newnode;
}
 
static DropRoleStmt *
_copyDropRoleStmt(const DropRoleStmt *from)
{
    DropRoleStmt *newnode = makeNode(DropRoleStmt);
 
    COPY_NODE_FIELD(roles);
    COPY_SCALAR_FIELD(missing_ok);
 
    return newnode;
}
 
static LockStmt *
_copyLockStmt(const LockStmt *from)
{
    LockStmt   *newnode = makeNode(LockStmt);
 
    COPY_NODE_FIELD(relations);
    COPY_SCALAR_FIELD(mode);
    COPY_SCALAR_FIELD(nowait);
 
    return newnode;
}
 
static ConstraintsSetStmt *
_copyConstraintsSetStmt(const ConstraintsSetStmt *from)
{
    ConstraintsSetStmt *newnode = makeNode(ConstraintsSetStmt);
 
    COPY_NODE_FIELD(constraints);
    COPY_SCALAR_FIELD(deferred);
 
    return newnode;
}
 
static ReindexStmt *
_copyReindexStmt(const ReindexStmt *from)
{
    ReindexStmt *newnode = makeNode(ReindexStmt);
 
    COPY_SCALAR_FIELD(kind);
    COPY_NODE_FIELD(relation);
    COPY_STRING_FIELD(name);
    COPY_NODE_FIELD(params);
 
    return newnode;
}
 
static CreateSchemaStmt *
_copyCreateSchemaStmt(const CreateSchemaStmt *from)
{
    CreateSchemaStmt *newnode = makeNode(CreateSchemaStmt);
 
    COPY_STRING_FIELD(schemaname);
    COPY_NODE_FIELD(authrole);
    COPY_NODE_FIELD(schemaElts);
    COPY_SCALAR_FIELD(if_not_exists);
 
    return newnode;
}
 
static CreateConversionStmt *
_copyCreateConversionStmt(const CreateConversionStmt *from)
{
    CreateConversionStmt *newnode = makeNode(CreateConversionStmt);
 
    COPY_NODE_FIELD(conversion_name);
    COPY_STRING_FIELD(for_encoding_name);
    COPY_STRING_FIELD(to_encoding_name);
    COPY_NODE_FIELD(func_name);
    COPY_SCALAR_FIELD(def);
 
    return newnode;
}
 
static CreateCastStmt *
_copyCreateCastStmt(const CreateCastStmt *from)
{
    CreateCastStmt *newnode = makeNode(CreateCastStmt);
 
    COPY_NODE_FIELD(sourcetype);
    COPY_NODE_FIELD(targettype);
    COPY_NODE_FIELD(func);
    COPY_SCALAR_FIELD(context);
    COPY_SCALAR_FIELD(inout);
 
    return newnode;
}
 
static PrepareStmt *
_copyPrepareStmt(const PrepareStmt *from)
{
    PrepareStmt *newnode = makeNode(PrepareStmt);
 
    COPY_STRING_FIELD(name);
    COPY_NODE_FIELD(argtypes);
    COPY_NODE_FIELD(query);
 
    return newnode;
}
 
static ExecuteStmt *
_copyExecuteStmt(const ExecuteStmt *from)
{
    ExecuteStmt *newnode = makeNode(ExecuteStmt);
 
    COPY_STRING_FIELD(name);
    COPY_NODE_FIELD(params);
 
    return newnode;
}
 
static DeallocateStmt *
_copyDeallocateStmt(const DeallocateStmt *from)
{
    DeallocateStmt *newnode = makeNode(DeallocateStmt);
 
    COPY_STRING_FIELD(name);
 
    return newnode;
}
 
static DropOwnedStmt *
_copyDropOwnedStmt(const DropOwnedStmt *from)
{
    DropOwnedStmt *newnode = makeNode(DropOwnedStmt);
 
    COPY_NODE_FIELD(roles);
    COPY_SCALAR_FIELD(behavior);
 
    return newnode;
}
 
static ReassignOwnedStmt *
_copyReassignOwnedStmt(const ReassignOwnedStmt *from)
{
    ReassignOwnedStmt *newnode = makeNode(ReassignOwnedStmt);
 
    COPY_NODE_FIELD(roles);
    COPY_NODE_FIELD(newrole);
 
    return newnode;
}
 
static AlterTSDictionaryStmt *
_copyAlterTSDictionaryStmt(const AlterTSDictionaryStmt *from)
{
    AlterTSDictionaryStmt *newnode = makeNode(AlterTSDictionaryStmt);
 
    COPY_NODE_FIELD(dictname);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static AlterTSConfigurationStmt *
_copyAlterTSConfigurationStmt(const AlterTSConfigurationStmt *from)
{
    AlterTSConfigurationStmt *newnode = makeNode(AlterTSConfigurationStmt);
 
    COPY_SCALAR_FIELD(kind);
    COPY_NODE_FIELD(cfgname);
    COPY_NODE_FIELD(tokentype);
    COPY_NODE_FIELD(dicts);
    COPY_SCALAR_FIELD(override);
    COPY_SCALAR_FIELD(replace);
    COPY_SCALAR_FIELD(missing_ok);
 
    return newnode;
}
 
static CreatePolicyStmt *
_copyCreatePolicyStmt(const CreatePolicyStmt *from)
{
    CreatePolicyStmt *newnode = makeNode(CreatePolicyStmt);
 
    COPY_STRING_FIELD(policy_name);
    COPY_NODE_FIELD(table);
    COPY_STRING_FIELD(cmd_name);
    COPY_SCALAR_FIELD(permissive);
    COPY_NODE_FIELD(roles);
    COPY_NODE_FIELD(qual);
    COPY_NODE_FIELD(with_check);
 
    return newnode;
}
 
static AlterPolicyStmt *
_copyAlterPolicyStmt(const AlterPolicyStmt *from)
{
    AlterPolicyStmt *newnode = makeNode(AlterPolicyStmt);
 
    COPY_STRING_FIELD(policy_name);
    COPY_NODE_FIELD(table);
    COPY_NODE_FIELD(roles);
    COPY_NODE_FIELD(qual);
    COPY_NODE_FIELD(with_check);
 
    return newnode;
}
 
static PartitionElem *
_copyPartitionElem(const PartitionElem *from)
{
    PartitionElem *newnode = makeNode(PartitionElem);
 
    COPY_STRING_FIELD(name);
    COPY_NODE_FIELD(expr);
    COPY_NODE_FIELD(collation);
    COPY_NODE_FIELD(opclass);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static PartitionSpec *
_copyPartitionSpec(const PartitionSpec *from)
{
    PartitionSpec *newnode = makeNode(PartitionSpec);
 
    COPY_STRING_FIELD(strategy);
    COPY_NODE_FIELD(partParams);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static PartitionBoundSpec *
_copyPartitionBoundSpec(const PartitionBoundSpec *from)
{
    PartitionBoundSpec *newnode = makeNode(PartitionBoundSpec);
 
    COPY_SCALAR_FIELD(strategy);
    COPY_SCALAR_FIELD(is_default);
    COPY_SCALAR_FIELD(modulus);
    COPY_SCALAR_FIELD(remainder);
    COPY_NODE_FIELD(listdatums);
    COPY_NODE_FIELD(lowerdatums);
    COPY_NODE_FIELD(upperdatums);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static PartitionRangeDatum *
_copyPartitionRangeDatum(const PartitionRangeDatum *from)
{
    PartitionRangeDatum *newnode = makeNode(PartitionRangeDatum);
 
    COPY_SCALAR_FIELD(kind);
    COPY_NODE_FIELD(value);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static PartitionCmd *
_copyPartitionCmd(const PartitionCmd *from)
{
    PartitionCmd *newnode = makeNode(PartitionCmd);
 
    COPY_NODE_FIELD(name);
    COPY_NODE_FIELD(bound);
    COPY_SCALAR_FIELD(concurrent);
 
    return newnode;
}
 
static PublicationObjSpec *
_copyPublicationObject(const PublicationObjSpec *from)
{
    PublicationObjSpec *newnode = makeNode(PublicationObjSpec);
 
    COPY_SCALAR_FIELD(pubobjtype);
    COPY_STRING_FIELD(name);
    COPY_NODE_FIELD(pubtable);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}
 
static PublicationTable *
_copyPublicationTable(const PublicationTable *from)
{
    PublicationTable *newnode = makeNode(PublicationTable);
 
    COPY_NODE_FIELD(relation);
    COPY_NODE_FIELD(whereClause);
    COPY_NODE_FIELD(columns);
 
    return newnode;
}
 
static CreatePublicationStmt *
_copyCreatePublicationStmt(const CreatePublicationStmt *from)
{
    CreatePublicationStmt *newnode = makeNode(CreatePublicationStmt);
 
    COPY_STRING_FIELD(pubname);
    COPY_NODE_FIELD(options);
    COPY_NODE_FIELD(pubobjects);
    COPY_SCALAR_FIELD(for_all_tables);
 
    return newnode;
}
 
static AlterPublicationStmt *
_copyAlterPublicationStmt(const AlterPublicationStmt *from)
{
    AlterPublicationStmt *newnode = makeNode(AlterPublicationStmt);
 
    COPY_STRING_FIELD(pubname);
    COPY_NODE_FIELD(options);
    COPY_NODE_FIELD(pubobjects);
    COPY_SCALAR_FIELD(for_all_tables);
    COPY_SCALAR_FIELD(action);
 
    return newnode;
}
 
static CreateSubscriptionStmt *
_copyCreateSubscriptionStmt(const CreateSubscriptionStmt *from)
{
    CreateSubscriptionStmt *newnode = makeNode(CreateSubscriptionStmt);
 
    COPY_STRING_FIELD(subname);
    COPY_STRING_FIELD(conninfo);
    COPY_NODE_FIELD(publication);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static AlterSubscriptionStmt *
_copyAlterSubscriptionStmt(const AlterSubscriptionStmt *from)
{
    AlterSubscriptionStmt *newnode = makeNode(AlterSubscriptionStmt);
 
    COPY_SCALAR_FIELD(kind);
    COPY_STRING_FIELD(subname);
    COPY_STRING_FIELD(conninfo);
    COPY_NODE_FIELD(publication);
    COPY_NODE_FIELD(options);
 
    return newnode;
}
 
static DropSubscriptionStmt *
_copyDropSubscriptionStmt(const DropSubscriptionStmt *from)
{
    DropSubscriptionStmt *newnode = makeNode(DropSubscriptionStmt);
 
    COPY_STRING_FIELD(subname);
    COPY_SCALAR_FIELD(missing_ok);
    COPY_SCALAR_FIELD(behavior);
 
    return newnode;
}
 
/* ****************************************************************
 *                  extensible.h copy functions
 * ****************************************************************
 */
static ExtensibleNode *
_copyExtensibleNode(const ExtensibleNode *from)
{
    ExtensibleNode *newnode;
    const ExtensibleNodeMethods *methods;
 
    methods = GetExtensibleNodeMethods(from->extnodename, false);
    newnode = (ExtensibleNode *) newNode(methods->node_size,
                                         T_ExtensibleNode);
    COPY_STRING_FIELD(extnodename);
 
    /* copy the private fields */
    methods->nodeCopy(newnode, from);
 
    return newnode;
}
 
/* ****************************************************************
 *                  value.h copy functions
 * ****************************************************************
 */
static Integer *
_copyInteger(const Integer *from)
{
    Integer    *newnode = makeNode(Integer);
 
    COPY_SCALAR_FIELD(ival);
 
    return newnode;
}
 
static Float *
_copyFloat(const Float *from)
{
    Float      *newnode = makeNode(Float);
 
    COPY_STRING_FIELD(fval);
 
    return newnode;
}
 
static Boolean *
_copyBoolean(const Boolean *from)
{
    Boolean    *newnode = makeNode(Boolean);
 
    COPY_SCALAR_FIELD(boolval);
 
    return newnode;
}
 
static String *
_copyString(const String *from)
{
    String     *newnode = makeNode(String);
 
    COPY_STRING_FIELD(sval);
 
    return newnode;
}
 
static BitString *
_copyBitString(const BitString *from)
{
    BitString  *newnode = makeNode(BitString);
 
    COPY_STRING_FIELD(bsval);
 
    return newnode;
}
 
 
static ForeignKeyCacheInfo *
_copyForeignKeyCacheInfo(const ForeignKeyCacheInfo *from)
{
    ForeignKeyCacheInfo *newnode = makeNode(ForeignKeyCacheInfo);
 
    COPY_SCALAR_FIELD(conoid);
    COPY_SCALAR_FIELD(conrelid);
    COPY_SCALAR_FIELD(confrelid);
    COPY_SCALAR_FIELD(nkeys);
    COPY_ARRAY_FIELD(conkey);
    COPY_ARRAY_FIELD(confkey);
    COPY_ARRAY_FIELD(conpfeqop);
 
    return newnode;
}
 
/*
 * copyObjectImpl -- implementation of copyObject(); see nodes/nodes.h
 *
 * Create a copy of a Node tree or list.  This is a "deep" copy: all
 * substructure is copied too, recursively.
 */
void *
copyObjectImpl(const void *from)
{
    void       *retval;
 
    if (from == NULL)
        return NULL;
 
    /* Guard against stack overflow due to overly complex expressions */
    check_stack_depth();
 
    switch (nodeTag(from))
    {
            /*
             * PLAN NODES
             */
        case T_PlannedStmt:
            retval = _copyPlannedStmt(from);
            break;
        case T_Plan:
            retval = _copyPlan(from);
            break;
        case T_Result:
            retval = _copyResult(from);
            break;
        case T_ProjectSet:
            retval = _copyProjectSet(from);
            break;
        case T_ModifyTable:
            retval = _copyModifyTable(from);
            break;
        case T_Append:
            retval = _copyAppend(from);
            break;
        case T_MergeAppend:
            retval = _copyMergeAppend(from);
            break;
        case T_RecursiveUnion:
            retval = _copyRecursiveUnion(from);
            break;
        case T_BitmapAnd:
            retval = _copyBitmapAnd(from);
            break;
        case T_BitmapOr:
            retval = _copyBitmapOr(from);
            break;
        case T_Scan:
            retval = _copyScan(from);
            break;
        case T_Gather:
            retval = _copyGather(from);
            break;
        case T_GatherMerge:
            retval = _copyGatherMerge(from);
            break;
        case T_SeqScan:
            retval = _copySeqScan(from);
            break;
        case T_SampleScan:
            retval = _copySampleScan(from);
            break;
        case T_IndexScan:
            retval = _copyIndexScan(from);
            break;
        case T_IndexOnlyScan:
            retval = _copyIndexOnlyScan(from);
            break;
        case T_BitmapIndexScan:
            retval = _copyBitmapIndexScan(from);
            break;
        case T_BitmapHeapScan:
            retval = _copyBitmapHeapScan(from);
            break;
        case T_TidScan:
            retval = _copyTidScan(from);
            break;
        case T_TidRangeScan:
            retval = _copyTidRangeScan(from);
            break;
        case T_SubqueryScan:
            retval = _copySubqueryScan(from);
            break;
        case T_FunctionScan:
            retval = _copyFunctionScan(from);
            break;
        case T_TableFuncScan:
            retval = _copyTableFuncScan(from);
            break;
        case T_ValuesScan:
            retval = _copyValuesScan(from);
            break;
        case T_CteScan:
            retval = _copyCteScan(from);
            break;
        case T_NamedTuplestoreScan:
            retval = _copyNamedTuplestoreScan(from);
            break;
        case T_WorkTableScan:
            retval = _copyWorkTableScan(from);
            break;
        case T_ForeignScan:
            retval = _copyForeignScan(from);
            break;
        case T_CustomScan:
            retval = _copyCustomScan(from);
            break;
        case T_Join:
            retval = _copyJoin(from);
            break;
        case T_NestLoop:
            retval = _copyNestLoop(from);
            break;
        case T_MergeJoin:
            retval = _copyMergeJoin(from);
            break;
        case T_HashJoin:
            retval = _copyHashJoin(from);
            break;
        case T_Material:
            retval = _copyMaterial(from);
            break;
        case T_Memoize:
            retval = _copyMemoize(from);
            break;
        case T_Sort:
            retval = _copySort(from);
            break;
        case T_IncrementalSort:
            retval = _copyIncrementalSort(from);
            break;
        case T_Group:
            retval = _copyGroup(from);
            break;
        case T_Agg:
            retval = _copyAgg(from);
            break;
        case T_WindowAgg:
            retval = _copyWindowAgg(from);
            break;
        case T_Unique:
            retval = _copyUnique(from);
            break;
        case T_Hash:
            retval = _copyHash(from);
            break;
        case T_SetOp:
            retval = _copySetOp(from);
            break;
        case T_LockRows:
            retval = _copyLockRows(from);
            break;
        case T_Limit:
            retval = _copyLimit(from);
            break;
        case T_NestLoopParam:
            retval = _copyNestLoopParam(from);
            break;
        case T_PlanRowMark:
            retval = _copyPlanRowMark(from);
            break;
        case T_PartitionPruneInfo:
            retval = _copyPartitionPruneInfo(from);
            break;
        case T_PartitionedRelPruneInfo:
            retval = _copyPartitionedRelPruneInfo(from);
            break;
        case T_PartitionPruneStepOp:
            retval = _copyPartitionPruneStepOp(from);
            break;
        case T_PartitionPruneStepCombine:
            retval = _copyPartitionPruneStepCombine(from);
            break;
        case T_PlanInvalItem:
            retval = _copyPlanInvalItem(from);
            break;
 
            /*
             * PRIMITIVE NODES
             */
        case T_Alias:
            retval = _copyAlias(from);
            break;
        case T_RangeVar:
            retval = _copyRangeVar(from);
            break;
        case T_TableFunc:
            retval = _copyTableFunc(from);
            break;
        case T_IntoClause:
            retval = _copyIntoClause(from);
            break;
        case T_Var:
            retval = _copyVar(from);
            break;
        case T_Const:
            retval = _copyConst(from);
            break;
        case T_Param:
            retval = _copyParam(from);
            break;
        case T_Aggref:
            retval = _copyAggref(from);
            break;
        case T_GroupingFunc:
            retval = _copyGroupingFunc(from);
            break;
        case T_WindowFunc:
            retval = _copyWindowFunc(from);
            break;
        case T_SubscriptingRef:
            retval = _copySubscriptingRef(from);
            break;
        case T_FuncExpr:
            retval = _copyFuncExpr(from);
            break;
        case T_NamedArgExpr:
            retval = _copyNamedArgExpr(from);
            break;
        case T_OpExpr:
            retval = _copyOpExpr(from);
            break;
        case T_DistinctExpr:
            retval = _copyDistinctExpr(from);
            break;
        case T_NullIfExpr:
            retval = _copyNullIfExpr(from);
            break;
        case T_ScalarArrayOpExpr:
            retval = _copyScalarArrayOpExpr(from);
            break;
        case T_BoolExpr:
            retval = _copyBoolExpr(from);
            break;
        case T_SubLink:
            retval = _copySubLink(from);
            break;
        case T_SubPlan:
            retval = _copySubPlan(from);
            break;
        case T_AlternativeSubPlan:
            retval = _copyAlternativeSubPlan(from);
            break;
        case T_FieldSelect:
            retval = _copyFieldSelect(from);
            break;
        case T_FieldStore:
            retval = _copyFieldStore(from);
            break;
        case T_RelabelType:
            retval = _copyRelabelType(from);
            break;
        case T_CoerceViaIO:
            retval = _copyCoerceViaIO(from);
            break;
        case T_ArrayCoerceExpr:
            retval = _copyArrayCoerceExpr(from);
            break;
        case T_ConvertRowtypeExpr:
            retval = _copyConvertRowtypeExpr(from);
            break;
        case T_CollateExpr:
            retval = _copyCollateExpr(from);
            break;
        case T_CaseExpr:
            retval = _copyCaseExpr(from);
            break;
        case T_CaseWhen:
            retval = _copyCaseWhen(from);
            break;
        case T_CaseTestExpr:
            retval = _copyCaseTestExpr(from);
            break;
        case T_ArrayExpr:
            retval = _copyArrayExpr(from);
            break;
        case T_RowExpr:
            retval = _copyRowExpr(from);
            break;
        case T_RowCompareExpr:
            retval = _copyRowCompareExpr(from);
            break;
        case T_CoalesceExpr:
            retval = _copyCoalesceExpr(from);
            break;
        case T_MinMaxExpr:
            retval = _copyMinMaxExpr(from);
            break;
        case T_SQLValueFunction:
            retval = _copySQLValueFunction(from);
            break;
        case T_XmlExpr:
            retval = _copyXmlExpr(from);
            break;
        case T_NullTest:
            retval = _copyNullTest(from);
            break;
        case T_BooleanTest:
            retval = _copyBooleanTest(from);
            break;
        case T_CoerceToDomain:
            retval = _copyCoerceToDomain(from);
            break;
        case T_CoerceToDomainValue:
            retval = _copyCoerceToDomainValue(from);
            break;
        case T_SetToDefault:
            retval = _copySetToDefault(from);
            break;
        case T_CurrentOfExpr:
            retval = _copyCurrentOfExpr(from);
            break;
        case T_NextValueExpr:
            retval = _copyNextValueExpr(from);
            break;
        case T_InferenceElem:
            retval = _copyInferenceElem(from);
            break;
        case T_TargetEntry:
            retval = _copyTargetEntry(from);
            break;
        case T_RangeTblRef:
            retval = _copyRangeTblRef(from);
            break;
        case T_JoinExpr:
            retval = _copyJoinExpr(from);
            break;
        case T_FromExpr:
            retval = _copyFromExpr(from);
            break;
        case T_OnConflictExpr:
            retval = _copyOnConflictExpr(from);
            break;
        case T_JsonFormat:
            retval = _copyJsonFormat(from);
            break;
        case T_JsonReturning:
            retval = _copyJsonReturning(from);
            break;
        case T_JsonValueExpr:
            retval = _copyJsonValueExpr(from);
            break;
        case T_JsonParseExpr:
            retval = _copyJsonParseExpr(from);
            break;
        case T_JsonScalarExpr:
            retval = _copyJsonScalarExpr(from);
            break;
        case T_JsonSerializeExpr:
            retval = _copyJsonSerializeExpr(from);
            break;
        case T_JsonKeyValue:
            retval = _copyJsonKeyValue(from);
            break;
        case T_JsonConstructorExpr:
            retval = _copyJsonConstructorExpr(from);
            break;
        case T_JsonObjectConstructor:
            retval = _copyJsonObjectConstructor(from);
            break;
        case T_JsonAggConstructor:
            retval = _copyJsonAggConstructor(from);
            break;
        case T_JsonObjectAgg:
            retval = _copyJsonObjectAgg(from);
            break;
        case T_JsonOutput:
            retval = _copyJsonOutput(from);
            break;
        case T_JsonArrayConstructor:
            retval = _copyJsonArrayConstructor(from);
            break;
        case T_JsonArrayQueryConstructor:
            retval = _copyJsonArrayQueryConstructor(from);
            break;
        case T_JsonArrayAgg:
            retval = _copyJsonArrayAgg(from);
            break;
        case T_JsonIsPredicate:
            retval = _copyJsonIsPredicate(from);
            break;
        case T_JsonFuncExpr:
            retval = _copyJsonFuncExpr(from);
            break;
        case T_JsonExpr:
            retval = _copyJsonExpr(from);
            break;
        case T_JsonCommon:
            retval = _copyJsonCommon(from);
            break;
        case T_JsonBehavior:
            retval = _copyJsonBehavior(from);
            break;
        case T_JsonArgument:
            retval = _copyJsonArgument(from);
            break;
        case T_JsonCoercion:
            retval = _copyJsonCoercion(from);
            break;
        case T_JsonItemCoercions:
            retval = _copyJsonItemCoercions(from);
            break;
        case T_JsonTable:
            retval = _copyJsonTable(from);
            break;
        case T_JsonTableColumn:
            retval = _copyJsonTableColumn(from);
            break;
        case T_JsonTablePlan:
            retval = _copyJsonTablePlan(from);
            break;
        case T_JsonTableParent:
            retval = _copyJsonTableParent(from);
            break;
        case T_JsonTableSibling:
            retval = _copyJsonTableSibling(from);
            break;
 
            /*
             * RELATION NODES
             */
        case T_PathKey:
            retval = _copyPathKey(from);
            break;
        case T_RestrictInfo:
            retval = _copyRestrictInfo(from);
            break;
        case T_PlaceHolderVar:
            retval = _copyPlaceHolderVar(from);
            break;
        case T_SpecialJoinInfo:
            retval = _copySpecialJoinInfo(from);
            break;
        case T_AppendRelInfo:
            retval = _copyAppendRelInfo(from);
            break;
        case T_PlaceHolderInfo:
            retval = _copyPlaceHolderInfo(from);
            break;
 
            /*
             * VALUE NODES
             */
        case T_Integer:
            retval = _copyInteger(from);
            break;
        case T_Float:
            retval = _copyFloat(from);
            break;
        case T_Boolean:
            retval = _copyBoolean(from);
            break;
        case T_String:
            retval = _copyString(from);
            break;
        case T_BitString:
            retval = _copyBitString(from);
            break;
 
            /*
             * LIST NODES
             */
        case