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-2021, 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 a pointer to a simple palloc'd object of size sz */
#define COPY_POINTER_FIELD(fldname, sz) \
    do { \
        Size    _size = (sz); \
        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);

    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);
    if (from->numCols > 0)
    {
        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(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);

    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(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);
    COPY_SCALAR_FIELD(resultRelation);

    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);
    if (numCols > 0)
    {
        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;
}


/*
 * _copyResultCache
 */
static ResultCache *
_copyResultCache(const ResultCache *from)
{
    ResultCache *newnode = makeNode(ResultCache);

    /*
     * 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(est_entries);

    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);
    if (from->numCols > 0)
    {
        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);
    if (from->partNumCols > 0)
    {
        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);
    if (from->ordNumCols > 0)
    {
        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_SCALAR_FIELD(startInRangeFunc);
    COPY_SCALAR_FIELD(endInRangeFunc);
    COPY_SCALAR_FIELD(inRangeColl);
    COPY_SCALAR_FIELD(inRangeAsc);
    COPY_SCALAR_FIELD(inRangeNullsFirst);

    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_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_BITMAPSET_FIELD(notnulls);
    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(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;
}

/* ****************************************************************
 *                      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(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_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 A_Expr *
_copyAExpr(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 *
_copyAConst(const A_Const *from)
{
    A_Const    *newnode = makeNode(A_Const);

    /* This part must duplicate _copyValue */
    COPY_SCALAR_FIELD(val.type);
    switch (from->val.type)
    {
        case T_Integer:
            COPY_SCALAR_FIELD(val.val.ival);
            break;
        case T_Float:
        case T_String:
        case T_BitString:
            COPY_STRING_FIELD(val.val.str);
            break;
        case T_Null:
            /* nothing to do */
            break;
        default:
            elog(ERROR, "unrecognized node type: %d",
                 (int) from->val.type);
            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 *
_copyAStar(const A_Star *from)
{
    A_Star     *newnode = makeNode(A_Star);

    return newnode;
}

static A_Indices *
_copyAIndices(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_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(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_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 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_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);

    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(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(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 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 CreatePublicationStmt *
_copyCreatePublicationStmt(const CreatePublicationStmt *from)
{
    CreatePublicationStmt *newnode = makeNode(CreatePublicationStmt);

    COPY_STRING_FIELD(pubname);
    COPY_NODE_FIELD(options);
    COPY_NODE_FIELD(tables);
    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(tables);
    COPY_SCALAR_FIELD(for_all_tables);
    COPY_SCALAR_FIELD(tableAction);

    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 Value *
_copyValue(const Value *from)
{
    Value      *newnode = makeNode(Value);

    /* See also _copyAConst when changing this code! */

    COPY_SCALAR_FIELD(type);
    switch (from->type)
    {
        case T_Integer:
            COPY_SCALAR_FIELD(val.ival);
            break;
        case T_Float:
        case T_String:
        case T_BitString:
            COPY_STRING_FIELD(val.str);
            break;
        case T_Null:
            /* nothing to do */
            break;
        default:
            elog(ERROR, "unrecognized node type: %d",
                 (int) from->type);
            break;
    }
    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_SCALAR_FIELD might work for these, but let's not assume that */
    memcpy(newnode->conkey, from->conkey, sizeof(newnode->conkey));
    memcpy(newnode->confkey, from->confkey, sizeof(newnode->confkey));
    memcpy(newnode->conpfeqop, from->conpfeqop, sizeof(newnode->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_ResultCache:
            retval = _copyResultCache(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;

            /*
             * 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:
        case T_Float:
        case T_String:
        case T_BitString:
        case T_Null:
            retval = _copyValue(from);
            break;

            /*
             * LIST NODES
             */
        case T_List:
            retval = list_copy_deep(from);
            break;

            /*
             * Lists of integers and OIDs don't need to be deep-copied, so we
             * perform a shallow copy via list_copy()
             */
        case T_IntList:
        case T_OidList:
            retval = list_copy(from);
            break;

            /*
             * EXTENSIBLE NODES
             */
        case T_ExtensibleNode:
            retval = _copyExtensibleNode(from);
            break;

            /*
             * PARSE NODES
             */
        case T_Query:
            retval = _copyQuery(from);
            break;
        case T_RawStmt:
            retval = _copyRawStmt(from);
            break;
        case T_InsertStmt:
            retval = _copyInsertStmt(from);
            break;
        case T_DeleteStmt:
            retval = _copyDeleteStmt(from);
            break;
        case T_UpdateStmt:
            retval = _copyUpdateStmt(from);
            break;
        case T_SelectStmt:
            retval = _copySelectStmt(from);
            break;
        case T_SetOperationStmt:
            retval = _copySetOperationStmt(from);
            break;
        case T_ReturnStmt:
            retval = _copyReturnStmt(from);
            break;
        case T_PLAssignStmt:
            retval = _copyPLAssignStmt(from);
            break;
        case T_AlterTableStmt:
            retval = _copyAlterTableStmt(from);
            break;
        case T_AlterTableCmd:
            retval = _copyAlterTableCmd(from);
            break;
        case T_AlterCollationStmt:
            retval = _copyAlterCollationStmt(from);
            break;
        case T_AlterDomainStmt:
            retval = _copyAlterDomainStmt(from);
            break;
        case T_GrantStmt:
            retval = _copyGrantStmt(from);
            break;
        case T_GrantRoleStmt:
            retval = _copyGrantRoleStmt(from);
            break;
        case T_AlterDefaultPrivilegesStmt:
            retval = _copyAlterDefaultPrivilegesStmt(from);
            break;
        case T_DeclareCursorStmt:
            retval = _copyDeclareCursorStmt(from);
            break;
        case T_ClosePortalStmt:
            retval = _copyClosePortalStmt(from);
            break;
        case T_CallStmt:
            retval = _copyCallStmt(from);
            break;
        case T_ClusterStmt:
            retval = _copyClusterStmt(from);
            break;
        case T_CopyStmt:
            retval = _copyCopyStmt(from);
            break;
        case T_CreateStmt:
            retval = _copyCreateStmt(from);
            break;
        case T_TableLikeClause:
            retval = _copyTableLikeClause(from);
            break;
        case T_DefineStmt:
            retval = _copyDefineStmt(from);
            break;
        case T_DropStmt:
            retval = _copyDropStmt(from);
            break;
        case T_TruncateStmt:
            retval = _copyTruncateStmt(from);
            break;
        case T_CommentStmt:
            retval = _copyCommentStmt(from);
            break;
        case T_SecLabelStmt:
            retval = _copySecLabelStmt(from);
            break;
        case T_FetchStmt:
            retval = _copyFetchStmt(from);
            break;
        case T_IndexStmt:
            retval = _copyIndexStmt(from);
            break;
        case T_CreateStatsStmt:
            retval = _copyCreateStatsStmt(from);
            break;
        case T_AlterStatsStmt:
            retval = _copyAlterStatsStmt(from);
            break;
        case T_CreateFunctionStmt:
            retval = _copyCreateFunctionStmt(from);
            break;
        case T_FunctionParameter:
            retval = _copyFunctionParameter(from);
            break;
        case T_AlterFunctionStmt:
            retval = _copyAlterFunctionStmt(from);
            break;
        case T_DoStmt:
            retval = _copyDoStmt(from);
            break;
        case T_RenameStmt:
            retval = _copyRenameStmt(from);
            break;
        case T_AlterObjectDependsStmt:
            retval = _copyAlterObjectDependsStmt(from);
            break;
        case T_AlterObjectSchemaStmt:
            retval = _copyAlterObjectSchemaStmt(from);
            break;
        case T_AlterOwnerStmt:
            retval = _copyAlterOwnerStmt(from);
            break;
        case T_AlterOperatorStmt:
            retval = _copyAlterOperatorStmt(from);
            break;
        case T_AlterTypeStmt:
            retval = _copyAlterTypeStmt(from);
            break;
        case T_RuleStmt:
            retval = _copyRuleStmt(from);
            break;
        case T_NotifyStmt:
            retval = _copyNotifyStmt(from);
            break;
        case T_ListenStmt:
            retval = _copyListenStmt(from);
            break;
        case T_UnlistenStmt:
            retval = _copyUnlistenStmt(from);
            break;
        case T_TransactionStmt:
            retval = _copyTransactionStmt(from);
            break;
        case T_CompositeTypeStmt:
            retval = _copyCompositeTypeStmt(from);
            break;
        case T_CreateEnumStmt:
            retval = _copyCreateEnumStmt(from);
            break;
        case T_CreateRangeStmt:
            retval = _copyCreateRangeStmt(from);
            break;
        case T_AlterEnumStmt:
            retval = _copyAlterEnumStmt(from);
            break;
        case T_ViewStmt:
            retval = _copyViewStmt(from);
            break;
        case T_LoadStmt:
            retval = _copyLoadStmt(from);
            break;
        case T_CreateDomainStmt:
            retval = _copyCreateDomainStmt(from);
            break;
        case T_CreateOpClassStmt:
            retval = _copyCreateOpClassStmt(from);
            break;
        case T_CreateOpClassItem:
            retval = _copyCreateOpClassItem(from);
            break;
        case T_CreateOpFamilyStmt:
            retval = _copyCreateOpFamilyStmt(from);
            break;
        case T_AlterOpFamilyStmt:
            retval = _copyAlterOpFamilyStmt(from);
            break;
        case T_CreatedbStmt:
            retval = _copyCreatedbStmt(from);
            break;
        case T_AlterDatabaseStmt:
            retval = _copyAlterDatabaseStmt(from);
            break;
        case T_AlterDatabaseSetStmt:
            retval = _copyAlterDatabaseSetStmt(from);
            break;
        case T_DropdbStmt:
            retval = _copyDropdbStmt(from);
            break;
        case T_VacuumStmt:
            retval = _copyVacuumStmt(from);
            break;
        case T_VacuumRelation:
            retval = _copyVacuumRelation(from);
            break;
        case T_ExplainStmt:
            retval = _copyExplainStmt(from);
            break;
        case T_CreateTableAsStmt:
            retval = _copyCreateTableAsStmt(from);
            break;
        case T_RefreshMatViewStmt:
            retval = _copyRefreshMatViewStmt(from);
            break;
        case T_ReplicaIdentityStmt:
            retval = _copyReplicaIdentityStmt(from);
            break;
        case T_AlterSystemStmt:
            retval = _copyAlterSystemStmt(from);
            break;
        case T_CreateSeqStmt:
            retval = _copyCreateSeqStmt(from);
            break;
        case T_AlterSeqStmt:
            retval = _copyAlterSeqStmt(from);
            break;
        case T_VariableSetStmt:
            retval = _copyVariableSetStmt(from);
            break;
        case T_VariableShowStmt:
            retval = _copyVariableShowStmt(from);
            break;
        case T_DiscardStmt:
            retval = _copyDiscardStmt(from);
            break;
        case T_CreateTableSpaceStmt:
            retval = _copyCreateTableSpaceStmt(from);
            break;
        case T_DropTableSpaceStmt:
            retval = _copyDropTableSpaceStmt(from);
            break;
        case T_AlterTableSpaceOptionsStmt:
            retval = _copyAlterTableSpaceOptionsStmt(from);
            break;
        case T_AlterTableMoveAllStmt:
            retval = _copyAlterTableMoveAllStmt(from);
            break;
        case T_CreateExtensionStmt:
            retval = _copyCreateExtensionStmt(from);
            break;
        case T_AlterExtensionStmt:
            retval = _copyAlterExtensionStmt(from);
            break;
        case T_AlterExtensionContentsStmt:
            retval = _copyAlterExtensionContentsStmt(from);
            break;
        case T_CreateFdwStmt:
            retval = _copyCreateFdwStmt(from);
            break;
        case T_AlterFdwStmt:
            retval = _copyAlterFdwStmt(from);
            break;
        case T_CreateForeignServerStmt:
            retval = _copyCreateForeignServerStmt(from);
            break;
        case T_AlterForeignServerStmt:
            retval = _copyAlterForeignServerStmt(from);
            break;
        case T_CreateUserMappingStmt:
            retval = _copyCreateUserMappingStmt(from);
            break;
        case T_AlterUserMappingStmt:
            retval = _copyAlterUserMappingStmt(from);
            break;
        case T_DropUserMappingStmt:
            retval = _copyDropUserMappingStmt(from);
            break;
        case T_CreateForeignTableStmt:
            retval = _copyCreateForeignTableStmt(from);
            break;
        case T_ImportForeignSchemaStmt:
            retval = _copyImportForeignSchemaStmt(from);
            break;
        case T_CreateTransformStmt:
            retval = _copyCreateTransformStmt(from);
            break;
        case T_CreateAmStmt:
            retval = _copyCreateAmStmt(from);
            break;
        case T_CreateTrigStmt:
            retval = _copyCreateTrigStmt(from);
            break;
        case T_CreateEventTrigStmt:
            retval = _copyCreateEventTrigStmt(from);
            break;
        case T_AlterEventTrigStmt:
            retval = _copyAlterEventTrigStmt(from);
            break;
        case T_CreatePLangStmt:
            retval = _copyCreatePLangStmt(from);
            break;
        case T_CreateRoleStmt:
            retval = _copyCreateRoleStmt(from);
            break;
        case T_AlterRoleStmt:
            retval = _copyAlterRoleStmt(from);
            break;
        case T_AlterRoleSetStmt:
            retval = _copyAlterRoleSetStmt(from);
            break;
        case T_DropRoleStmt:
            retval = _copyDropRoleStmt(from);
            break;
        case T_LockStmt:
            retval = _copyLockStmt(from);
            break;
        case T_ConstraintsSetStmt:
            retval = _copyConstraintsSetStmt(from);
            break;
        case T_ReindexStmt:
            retval = _copyReindexStmt(from);
            break;
        case T_CheckPointStmt:
            retval = (void *) makeNode(CheckPointStmt);
            break;
        case T_CreateSchemaStmt:
            retval = _copyCreateSchemaStmt(from);
            break;
        case T_CreateConversionStmt:
            retval = _copyCreateConversionStmt(from);
            break;
        case T_CreateCastStmt:
            retval = _copyCreateCastStmt(from);
            break;
        case T_PrepareStmt:
            retval = _copyPrepareStmt(from);
            break;
        case T_ExecuteStmt:
            retval = _copyExecuteStmt(from);
            break;
        case T_DeallocateStmt:
            retval = _copyDeallocateStmt(from);
            break;
        case T_DropOwnedStmt:
            retval = _copyDropOwnedStmt(from);
            break;
        case T_ReassignOwnedStmt:
            retval = _copyReassignOwnedStmt(from);
            break;
        case T_AlterTSDictionaryStmt:
            retval = _copyAlterTSDictionaryStmt(from);
            break;
        case T_AlterTSConfigurationStmt:
            retval = _copyAlterTSConfigurationStmt(from);
            break;
        case T_CreatePolicyStmt:
            retval = _copyCreatePolicyStmt(from);
            break;
        case T_AlterPolicyStmt:
            retval = _copyAlterPolicyStmt(from);
            break;
        case T_CreatePublicationStmt:
            retval = _copyCreatePublicationStmt(from);
            break;
        case T_AlterPublicationStmt:
            retval = _copyAlterPublicationStmt(from);
            break;
        case T_CreateSubscriptionStmt:
            retval = _copyCreateSubscriptionStmt(from);
            break;
        case T_AlterSubscriptionStmt:
            retval = _copyAlterSubscriptionStmt(from);
            break;
        case T_DropSubscriptionStmt:
            retval = _copyDropSubscriptionStmt(from);
            break;
        case T_A_Expr:
            retval = _copyAExpr(from);
            break;
        case T_ColumnRef:
            retval = _copyColumnRef(from);
            break;
        case T_ParamRef:
            retval = _copyParamRef(from);
            break;
        case T_A_Const:
            retval = _copyAConst(from);
            break;
        case T_FuncCall:
            retval = _copyFuncCall(from);
            break;
        case T_A_Star:
            retval = _copyAStar(from);
            break;
        case T_A_Indices:
            retval = _copyAIndices(from);
            break;
        case T_A_Indirection:
            retval = _copyA_Indirection(from);
            break;
        case T_A_ArrayExpr:
            retval = _copyA_ArrayExpr(from);
            break;
        case T_ResTarget:
            retval = _copyResTarget(from);
            break;
        case T_MultiAssignRef:
            retval = _copyMultiAssignRef(from);
            break;
        case T_TypeCast:
            retval = _copyTypeCast(from);
            break;
        case T_CollateClause:
            retval = _copyCollateClause(from);
            break;
        case T_SortBy:
            retval = _copySortBy(from);
            break;
        case T_WindowDef:
            retval = _copyWindowDef(from);
            break;
        case T_RangeSubselect:
            retval = _copyRangeSubselect(from);
            break;
        case T_RangeFunction:
            retval = _copyRangeFunction(from);
            break;
        case T_RangeTableSample:
            retval = _copyRangeTableSample(from);
            break;
        case T_RangeTableFunc:
            retval = _copyRangeTableFunc(from);
            break;
        case T_RangeTableFuncCol:
            retval = _copyRangeTableFuncCol(from);
            break;
        case T_TypeName:
            retval = _copyTypeName(from);
            break;
        case T_IndexElem:
            retval = _copyIndexElem(from);
            break;
        case T_StatsElem:
            retval = _copyStatsElem(from);
            break;
        case T_ColumnDef:
            retval = _copyColumnDef(from);
            break;
        case T_Constraint:
            retval = _copyConstraint(from);
            break;
        case T_DefElem:
            retval = _copyDefElem(from);
            break;
        case T_LockingClause:
            retval = _copyLockingClause(from);
            break;
        case T_RangeTblEntry:
            retval = _copyRangeTblEntry(from);
            break;
        case T_RangeTblFunction:
            retval = _copyRangeTblFunction(from);
            break;
        case T_TableSampleClause:
            retval = _copyTableSampleClause(from);
            break;
        case T_WithCheckOption:
            retval = _copyWithCheckOption(from);
            break;
        case T_SortGroupClause:
            retval = _copySortGroupClause(from);
            break;
        case T_GroupingSet:
            retval = _copyGroupingSet(from);
            break;
        case T_WindowClause:
            retval = _copyWindowClause(from);
            break;
        case T_RowMarkClause:
            retval = _copyRowMarkClause(from);
            break;
        case T_WithClause:
            retval = _copyWithClause(from);
            break;
        case T_InferClause:
            retval = _copyInferClause(from);
            break;
        case T_OnConflictClause:
            retval = _copyOnConflictClause(from);
            break;
        case T_CTESearchClause:
            retval = _copyCTESearchClause(from);
            break;
        case T_CTECycleClause:
            retval = _copyCTECycleClause(from);
            break;
        case T_CommonTableExpr:
            retval = _copyCommonTableExpr(from);
            break;
        case T_ObjectWithArgs:
            retval = _copyObjectWithArgs(from);
            break;
        case T_AccessPriv:
            retval = _copyAccessPriv(from);
            break;
        case T_XmlSerialize:
            retval = _copyXmlSerialize(from);
            break;
        case T_RoleSpec:
            retval = _copyRoleSpec(from);
            break;
        case T_TriggerTransition:
            retval = _copyTriggerTransition(from);
            break;
        case T_PartitionElem:
            retval = _copyPartitionElem(from);
            break;
        case T_PartitionSpec:
            retval = _copyPartitionSpec(from);
            break;
        case T_PartitionBoundSpec:
            retval = _copyPartitionBoundSpec(from);
            break;
        case T_PartitionRangeDatum:
            retval = _copyPartitionRangeDatum(from);
            break;
        case T_PartitionCmd:
            retval = _copyPartitionCmd(from);
            break;

            /*
             * MISCELLANEOUS NODES
             */
        case T_ForeignKeyCacheInfo:
            retval = _copyForeignKeyCacheInfo(from);
            break;

        default:
            elog(ERROR, "unrecognized node type: %d", (int) nodeTag(from));
            retval = 0;         /* keep compiler quiet */
            break;
    }

    return retval;
}