PostgreSQL Source Code  git master
copyfuncs.c File Reference
#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"
Include dependency graph for copyfuncs.c:

Go to the source code of this file.

Macros

#define COPY_SCALAR_FIELD(fldname)    (newnode->fldname = from->fldname)
 
#define COPY_NODE_FIELD(fldname)    (newnode->fldname = copyObjectImpl(from->fldname))
 
#define COPY_BITMAPSET_FIELD(fldname)    (newnode->fldname = bms_copy(from->fldname))
 
#define COPY_STRING_FIELD(fldname)    (newnode->fldname = from->fldname ? pstrdup(from->fldname) : (char *) NULL)
 
#define COPY_ARRAY_FIELD(fldname)    memcpy(newnode->fldname, from->fldname, sizeof(newnode->fldname))
 
#define COPY_POINTER_FIELD(fldname, sz)
 
#define COPY_LOCATION_FIELD(fldname)    (newnode->fldname = from->fldname)
 

Functions

static PlannedStmt_copyPlannedStmt (const PlannedStmt *from)
 
static void CopyPlanFields (const Plan *from, Plan *newnode)
 
static Plan_copyPlan (const Plan *from)
 
static Result_copyResult (const Result *from)
 
static ProjectSet_copyProjectSet (const ProjectSet *from)
 
static ModifyTable_copyModifyTable (const ModifyTable *from)
 
static Append_copyAppend (const Append *from)
 
static MergeAppend_copyMergeAppend (const MergeAppend *from)
 
static RecursiveUnion_copyRecursiveUnion (const RecursiveUnion *from)
 
static BitmapAnd_copyBitmapAnd (const BitmapAnd *from)
 
static BitmapOr_copyBitmapOr (const BitmapOr *from)
 
static Gather_copyGather (const Gather *from)
 
static GatherMerge_copyGatherMerge (const GatherMerge *from)
 
static void CopyScanFields (const Scan *from, Scan *newnode)
 
static Scan_copyScan (const Scan *from)
 
static SeqScan_copySeqScan (const SeqScan *from)
 
static SampleScan_copySampleScan (const SampleScan *from)
 
static IndexScan_copyIndexScan (const IndexScan *from)
 
static IndexOnlyScan_copyIndexOnlyScan (const IndexOnlyScan *from)
 
static BitmapIndexScan_copyBitmapIndexScan (const BitmapIndexScan *from)
 
static BitmapHeapScan_copyBitmapHeapScan (const BitmapHeapScan *from)
 
static TidScan_copyTidScan (const TidScan *from)
 
static TidRangeScan_copyTidRangeScan (const TidRangeScan *from)
 
static SubqueryScan_copySubqueryScan (const SubqueryScan *from)
 
static FunctionScan_copyFunctionScan (const FunctionScan *from)
 
static TableFuncScan_copyTableFuncScan (const TableFuncScan *from)
 
static ValuesScan_copyValuesScan (const ValuesScan *from)
 
static CteScan_copyCteScan (const CteScan *from)
 
static NamedTuplestoreScan_copyNamedTuplestoreScan (const NamedTuplestoreScan *from)
 
static WorkTableScan_copyWorkTableScan (const WorkTableScan *from)
 
static ForeignScan_copyForeignScan (const ForeignScan *from)
 
static CustomScan_copyCustomScan (const CustomScan *from)
 
static void CopyJoinFields (const Join *from, Join *newnode)
 
static Join_copyJoin (const Join *from)
 
static NestLoop_copyNestLoop (const NestLoop *from)
 
static MergeJoin_copyMergeJoin (const MergeJoin *from)
 
static HashJoin_copyHashJoin (const HashJoin *from)
 
static Material_copyMaterial (const Material *from)
 
static Memoize_copyMemoize (const Memoize *from)
 
static void CopySortFields (const Sort *from, Sort *newnode)
 
static Sort_copySort (const Sort *from)
 
static IncrementalSort_copyIncrementalSort (const IncrementalSort *from)
 
static Group_copyGroup (const Group *from)
 
static Agg_copyAgg (const Agg *from)
 
static WindowAgg_copyWindowAgg (const WindowAgg *from)
 
static Unique_copyUnique (const Unique *from)
 
static Hash_copyHash (const Hash *from)
 
static SetOp_copySetOp (const SetOp *from)
 
static LockRows_copyLockRows (const LockRows *from)
 
static Limit_copyLimit (const Limit *from)
 
static NestLoopParam_copyNestLoopParam (const NestLoopParam *from)
 
static PlanRowMark_copyPlanRowMark (const PlanRowMark *from)
 
static PartitionPruneInfo_copyPartitionPruneInfo (const PartitionPruneInfo *from)
 
static PartitionedRelPruneInfo_copyPartitionedRelPruneInfo (const PartitionedRelPruneInfo *from)
 
static PartitionPruneStepOp_copyPartitionPruneStepOp (const PartitionPruneStepOp *from)
 
static PartitionPruneStepCombine_copyPartitionPruneStepCombine (const PartitionPruneStepCombine *from)
 
static PlanInvalItem_copyPlanInvalItem (const PlanInvalItem *from)
 
static Alias_copyAlias (const Alias *from)
 
static RangeVar_copyRangeVar (const RangeVar *from)
 
static TableFunc_copyTableFunc (const TableFunc *from)
 
static IntoClause_copyIntoClause (const IntoClause *from)
 
static Var_copyVar (const Var *from)
 
static Const_copyConst (const Const *from)
 
static Param_copyParam (const Param *from)
 
static Aggref_copyAggref (const Aggref *from)
 
static GroupingFunc_copyGroupingFunc (const GroupingFunc *from)
 
static WindowFunc_copyWindowFunc (const WindowFunc *from)
 
static SubscriptingRef_copySubscriptingRef (const SubscriptingRef *from)
 
static FuncExpr_copyFuncExpr (const FuncExpr *from)
 
static NamedArgExpr_copyNamedArgExpr (const NamedArgExpr *from)
 
static OpExpr_copyOpExpr (const OpExpr *from)
 
static DistinctExpr_copyDistinctExpr (const DistinctExpr *from)
 
static NullIfExpr_copyNullIfExpr (const NullIfExpr *from)
 
static ScalarArrayOpExpr_copyScalarArrayOpExpr (const ScalarArrayOpExpr *from)
 
static BoolExpr_copyBoolExpr (const BoolExpr *from)
 
static SubLink_copySubLink (const SubLink *from)
 
static SubPlan_copySubPlan (const SubPlan *from)
 
static AlternativeSubPlan_copyAlternativeSubPlan (const AlternativeSubPlan *from)
 
static FieldSelect_copyFieldSelect (const FieldSelect *from)
 
static FieldStore_copyFieldStore (const FieldStore *from)
 
static RelabelType_copyRelabelType (const RelabelType *from)
 
static CoerceViaIO_copyCoerceViaIO (const CoerceViaIO *from)
 
static ArrayCoerceExpr_copyArrayCoerceExpr (const ArrayCoerceExpr *from)
 
static ConvertRowtypeExpr_copyConvertRowtypeExpr (const ConvertRowtypeExpr *from)
 
static CollateExpr_copyCollateExpr (const CollateExpr *from)
 
static CaseExpr_copyCaseExpr (const CaseExpr *from)
 
static CaseWhen_copyCaseWhen (const CaseWhen *from)
 
static CaseTestExpr_copyCaseTestExpr (const CaseTestExpr *from)
 
static ArrayExpr_copyArrayExpr (const ArrayExpr *from)
 
static RowExpr_copyRowExpr (const RowExpr *from)
 
static RowCompareExpr_copyRowCompareExpr (const RowCompareExpr *from)
 
static CoalesceExpr_copyCoalesceExpr (const CoalesceExpr *from)
 
static MinMaxExpr_copyMinMaxExpr (const MinMaxExpr *from)
 
static SQLValueFunction_copySQLValueFunction (const SQLValueFunction *from)
 
static XmlExpr_copyXmlExpr (const XmlExpr *from)
 
static NullTest_copyNullTest (const NullTest *from)
 
static BooleanTest_copyBooleanTest (const BooleanTest *from)
 
static CoerceToDomain_copyCoerceToDomain (const CoerceToDomain *from)
 
static CoerceToDomainValue_copyCoerceToDomainValue (const CoerceToDomainValue *from)
 
static SetToDefault_copySetToDefault (const SetToDefault *from)
 
static CurrentOfExpr_copyCurrentOfExpr (const CurrentOfExpr *from)
 
static NextValueExpr_copyNextValueExpr (const NextValueExpr *from)
 
static InferenceElem_copyInferenceElem (const InferenceElem *from)
 
static TargetEntry_copyTargetEntry (const TargetEntry *from)
 
static RangeTblRef_copyRangeTblRef (const RangeTblRef *from)
 
static JoinExpr_copyJoinExpr (const JoinExpr *from)
 
static FromExpr_copyFromExpr (const FromExpr *from)
 
static OnConflictExpr_copyOnConflictExpr (const OnConflictExpr *from)
 
static JsonFormat_copyJsonFormat (const JsonFormat *from)
 
static JsonReturning_copyJsonReturning (const JsonReturning *from)
 
static JsonValueExpr_copyJsonValueExpr (const JsonValueExpr *from)
 
static JsonParseExpr_copyJsonParseExpr (const JsonParseExpr *from)
 
static JsonScalarExpr_copyJsonScalarExpr (const JsonScalarExpr *from)
 
static JsonSerializeExpr_copyJsonSerializeExpr (const JsonSerializeExpr *from)
 
static JsonConstructorExpr_copyJsonConstructorExpr (const JsonConstructorExpr *from)
 
static JsonKeyValue_copyJsonKeyValue (const JsonKeyValue *from)
 
static JsonObjectConstructor_copyJsonObjectConstructor (const JsonObjectConstructor *from)
 
static JsonAggConstructor_copyJsonAggConstructor (const JsonAggConstructor *from)
 
static JsonObjectAgg_copyJsonObjectAgg (const JsonObjectAgg *from)
 
static JsonOutput_copyJsonOutput (const JsonOutput *from)
 
static JsonArrayConstructor_copyJsonArrayConstructor (const JsonArrayConstructor *from)
 
static JsonArrayAgg_copyJsonArrayAgg (const JsonArrayAgg *from)
 
static JsonArrayQueryConstructor_copyJsonArrayQueryConstructor (const JsonArrayQueryConstructor *from)
 
static JsonExpr_copyJsonExpr (const JsonExpr *from)
 
static JsonCoercion_copyJsonCoercion (const JsonCoercion *from)
 
static JsonItemCoercions_copyJsonItemCoercions (const JsonItemCoercions *from)
 
static JsonFuncExpr_copyJsonFuncExpr (const JsonFuncExpr *from)
 
static JsonIsPredicate_copyJsonIsPredicate (const JsonIsPredicate *from)
 
static JsonBehavior_copyJsonBehavior (const JsonBehavior *from)
 
static JsonCommon_copyJsonCommon (const JsonCommon *from)
 
static JsonArgument_copyJsonArgument (const JsonArgument *from)
 
static JsonTable_copyJsonTable (const JsonTable *from)
 
static JsonTableColumn_copyJsonTableColumn (const JsonTableColumn *from)
 
static JsonTablePlan_copyJsonTablePlan (const JsonTablePlan *from)
 
static JsonTableParent_copyJsonTableParent (const JsonTableParent *from)
 
static JsonTableSibling_copyJsonTableSibling (const JsonTableSibling *from)
 
static PathKey_copyPathKey (const PathKey *from)
 
static RestrictInfo_copyRestrictInfo (const RestrictInfo *from)
 
static PlaceHolderVar_copyPlaceHolderVar (const PlaceHolderVar *from)
 
static SpecialJoinInfo_copySpecialJoinInfo (const SpecialJoinInfo *from)
 
static AppendRelInfo_copyAppendRelInfo (const AppendRelInfo *from)
 
static PlaceHolderInfo_copyPlaceHolderInfo (const PlaceHolderInfo *from)
 
static RangeTblEntry_copyRangeTblEntry (const RangeTblEntry *from)
 
static RangeTblFunction_copyRangeTblFunction (const RangeTblFunction *from)
 
static TableSampleClause_copyTableSampleClause (const TableSampleClause *from)
 
static WithCheckOption_copyWithCheckOption (const WithCheckOption *from)
 
static SortGroupClause_copySortGroupClause (const SortGroupClause *from)
 
static GroupingSet_copyGroupingSet (const GroupingSet *from)
 
static WindowClause_copyWindowClause (const WindowClause *from)
 
static RowMarkClause_copyRowMarkClause (const RowMarkClause *from)
 
static WithClause_copyWithClause (const WithClause *from)
 
static InferClause_copyInferClause (const InferClause *from)
 
static OnConflictClause_copyOnConflictClause (const OnConflictClause *from)
 
static CTESearchClause_copyCTESearchClause (const CTESearchClause *from)
 
static CTECycleClause_copyCTECycleClause (const CTECycleClause *from)
 
static CommonTableExpr_copyCommonTableExpr (const CommonTableExpr *from)
 
static MergeWhenClause_copyMergeWhenClause (const MergeWhenClause *from)
 
static MergeAction_copyMergeAction (const MergeAction *from)
 
static A_Expr_copyA_Expr (const A_Expr *from)
 
static ColumnRef_copyColumnRef (const ColumnRef *from)
 
static ParamRef_copyParamRef (const ParamRef *from)
 
static A_Const_copyA_Const (const A_Const *from)
 
static FuncCall_copyFuncCall (const FuncCall *from)
 
static A_Star_copyA_Star (const A_Star *from)
 
static A_Indices_copyA_Indices (const A_Indices *from)
 
static A_Indirection_copyA_Indirection (const A_Indirection *from)
 
static A_ArrayExpr_copyA_ArrayExpr (const A_ArrayExpr *from)
 
static ResTarget_copyResTarget (const ResTarget *from)
 
static MultiAssignRef_copyMultiAssignRef (const MultiAssignRef *from)
 
static TypeName_copyTypeName (const TypeName *from)
 
static SortBy_copySortBy (const SortBy *from)
 
static WindowDef_copyWindowDef (const WindowDef *from)
 
static RangeSubselect_copyRangeSubselect (const RangeSubselect *from)
 
static RangeFunction_copyRangeFunction (const RangeFunction *from)
 
static RangeTableSample_copyRangeTableSample (const RangeTableSample *from)
 
static RangeTableFunc_copyRangeTableFunc (const RangeTableFunc *from)
 
static RangeTableFuncCol_copyRangeTableFuncCol (const RangeTableFuncCol *from)
 
static TypeCast_copyTypeCast (const TypeCast *from)
 
static CollateClause_copyCollateClause (const CollateClause *from)
 
static IndexElem_copyIndexElem (const IndexElem *from)
 
static StatsElem_copyStatsElem (const StatsElem *from)
 
static ColumnDef_copyColumnDef (const ColumnDef *from)
 
static Constraint_copyConstraint (const Constraint *from)
 
static DefElem_copyDefElem (const DefElem *from)
 
static LockingClause_copyLockingClause (const LockingClause *from)
 
static XmlSerialize_copyXmlSerialize (const XmlSerialize *from)
 
static RoleSpec_copyRoleSpec (const RoleSpec *from)
 
static TriggerTransition_copyTriggerTransition (const TriggerTransition *from)
 
static Query_copyQuery (const Query *from)
 
static RawStmt_copyRawStmt (const RawStmt *from)
 
static InsertStmt_copyInsertStmt (const InsertStmt *from)
 
static DeleteStmt_copyDeleteStmt (const DeleteStmt *from)
 
static UpdateStmt_copyUpdateStmt (const UpdateStmt *from)
 
static MergeStmt_copyMergeStmt (const MergeStmt *from)
 
static SelectStmt_copySelectStmt (const SelectStmt *from)
 
static SetOperationStmt_copySetOperationStmt (const SetOperationStmt *from)
 
static ReturnStmt_copyReturnStmt (const ReturnStmt *from)
 
static PLAssignStmt_copyPLAssignStmt (const PLAssignStmt *from)
 
static AlterTableStmt_copyAlterTableStmt (const AlterTableStmt *from)
 
static AlterTableCmd_copyAlterTableCmd (const AlterTableCmd *from)
 
static AlterCollationStmt_copyAlterCollationStmt (const AlterCollationStmt *from)
 
static AlterDomainStmt_copyAlterDomainStmt (const AlterDomainStmt *from)
 
static GrantStmt_copyGrantStmt (const GrantStmt *from)
 
static ObjectWithArgs_copyObjectWithArgs (const ObjectWithArgs *from)
 
static AccessPriv_copyAccessPriv (const AccessPriv *from)
 
static GrantRoleStmt_copyGrantRoleStmt (const GrantRoleStmt *from)
 
static AlterDefaultPrivilegesStmt_copyAlterDefaultPrivilegesStmt (const AlterDefaultPrivilegesStmt *from)
 
static DeclareCursorStmt_copyDeclareCursorStmt (const DeclareCursorStmt *from)
 
static ClosePortalStmt_copyClosePortalStmt (const ClosePortalStmt *from)
 
static CallStmt_copyCallStmt (const CallStmt *from)
 
static ClusterStmt_copyClusterStmt (const ClusterStmt *from)
 
static CopyStmt_copyCopyStmt (const CopyStmt *from)
 
static void CopyCreateStmtFields (const CreateStmt *from, CreateStmt *newnode)
 
static CreateStmt_copyCreateStmt (const CreateStmt *from)
 
static TableLikeClause_copyTableLikeClause (const TableLikeClause *from)
 
static DefineStmt_copyDefineStmt (const DefineStmt *from)
 
static DropStmt_copyDropStmt (const DropStmt *from)
 
static TruncateStmt_copyTruncateStmt (const TruncateStmt *from)
 
static CommentStmt_copyCommentStmt (const CommentStmt *from)
 
static SecLabelStmt_copySecLabelStmt (const SecLabelStmt *from)
 
static FetchStmt_copyFetchStmt (const FetchStmt *from)
 
static IndexStmt_copyIndexStmt (const IndexStmt *from)
 
static CreateStatsStmt_copyCreateStatsStmt (const CreateStatsStmt *from)
 
static AlterStatsStmt_copyAlterStatsStmt (const AlterStatsStmt *from)
 
static CreateFunctionStmt_copyCreateFunctionStmt (const CreateFunctionStmt *from)
 
static FunctionParameter_copyFunctionParameter (const FunctionParameter *from)
 
static AlterFunctionStmt_copyAlterFunctionStmt (const AlterFunctionStmt *from)
 
static DoStmt_copyDoStmt (const DoStmt *from)
 
static RenameStmt_copyRenameStmt (const RenameStmt *from)
 
static AlterObjectDependsStmt_copyAlterObjectDependsStmt (const AlterObjectDependsStmt *from)
 
static AlterObjectSchemaStmt_copyAlterObjectSchemaStmt (const AlterObjectSchemaStmt *from)
 
static AlterOwnerStmt_copyAlterOwnerStmt (const AlterOwnerStmt *from)
 
static AlterOperatorStmt_copyAlterOperatorStmt (const AlterOperatorStmt *from)
 
static AlterTypeStmt_copyAlterTypeStmt (const AlterTypeStmt *from)
 
static RuleStmt_copyRuleStmt (const RuleStmt *from)
 
static NotifyStmt_copyNotifyStmt (const NotifyStmt *from)
 
static ListenStmt_copyListenStmt (const ListenStmt *from)
 
static UnlistenStmt_copyUnlistenStmt (const UnlistenStmt *from)
 
static TransactionStmt_copyTransactionStmt (const TransactionStmt *from)
 
static CompositeTypeStmt_copyCompositeTypeStmt (const CompositeTypeStmt *from)
 
static CreateEnumStmt_copyCreateEnumStmt (const CreateEnumStmt *from)
 
static CreateRangeStmt_copyCreateRangeStmt (const CreateRangeStmt *from)
 
static AlterEnumStmt_copyAlterEnumStmt (const AlterEnumStmt *from)
 
static ViewStmt_copyViewStmt (const ViewStmt *from)
 
static LoadStmt_copyLoadStmt (const LoadStmt *from)
 
static CreateDomainStmt_copyCreateDomainStmt (const CreateDomainStmt *from)
 
static CreateOpClassStmt_copyCreateOpClassStmt (const CreateOpClassStmt *from)
 
static CreateOpClassItem_copyCreateOpClassItem (const CreateOpClassItem *from)
 
static CreateOpFamilyStmt_copyCreateOpFamilyStmt (const CreateOpFamilyStmt *from)
 
static AlterOpFamilyStmt_copyAlterOpFamilyStmt (const AlterOpFamilyStmt *from)
 
static CreatedbStmt_copyCreatedbStmt (const CreatedbStmt *from)
 
static AlterDatabaseStmt_copyAlterDatabaseStmt (const AlterDatabaseStmt *from)
 
static AlterDatabaseRefreshCollStmt_copyAlterDatabaseRefreshCollStmt (const AlterDatabaseRefreshCollStmt *from)
 
static AlterDatabaseSetStmt_copyAlterDatabaseSetStmt (const AlterDatabaseSetStmt *from)
 
static DropdbStmt_copyDropdbStmt (const DropdbStmt *from)
 
static VacuumStmt_copyVacuumStmt (const VacuumStmt *from)
 
static VacuumRelation_copyVacuumRelation (const VacuumRelation *from)
 
static ExplainStmt_copyExplainStmt (const ExplainStmt *from)
 
static CreateTableAsStmt_copyCreateTableAsStmt (const CreateTableAsStmt *from)
 
static RefreshMatViewStmt_copyRefreshMatViewStmt (const RefreshMatViewStmt *from)
 
static ReplicaIdentityStmt_copyReplicaIdentityStmt (const ReplicaIdentityStmt *from)
 
static AlterSystemStmt_copyAlterSystemStmt (const AlterSystemStmt *from)
 
static CreateSeqStmt_copyCreateSeqStmt (const CreateSeqStmt *from)
 
static AlterSeqStmt_copyAlterSeqStmt (const AlterSeqStmt *from)
 
static VariableSetStmt_copyVariableSetStmt (const VariableSetStmt *from)
 
static VariableShowStmt_copyVariableShowStmt (const VariableShowStmt *from)
 
static DiscardStmt_copyDiscardStmt (const DiscardStmt *from)
 
static CreateTableSpaceStmt_copyCreateTableSpaceStmt (const CreateTableSpaceStmt *from)
 
static DropTableSpaceStmt_copyDropTableSpaceStmt (const DropTableSpaceStmt *from)
 
static AlterTableSpaceOptionsStmt_copyAlterTableSpaceOptionsStmt (const AlterTableSpaceOptionsStmt *from)
 
static AlterTableMoveAllStmt_copyAlterTableMoveAllStmt (const AlterTableMoveAllStmt *from)
 
static CreateExtensionStmt_copyCreateExtensionStmt (const CreateExtensionStmt *from)
 
static AlterExtensionStmt_copyAlterExtensionStmt (const AlterExtensionStmt *from)
 
static AlterExtensionContentsStmt_copyAlterExtensionContentsStmt (const AlterExtensionContentsStmt *from)
 
static CreateFdwStmt_copyCreateFdwStmt (const CreateFdwStmt *from)
 
static AlterFdwStmt_copyAlterFdwStmt (const AlterFdwStmt *from)
 
static CreateForeignServerStmt_copyCreateForeignServerStmt (const CreateForeignServerStmt *from)
 
static AlterForeignServerStmt_copyAlterForeignServerStmt (const AlterForeignServerStmt *from)
 
static CreateUserMappingStmt_copyCreateUserMappingStmt (const CreateUserMappingStmt *from)
 
static AlterUserMappingStmt_copyAlterUserMappingStmt (const AlterUserMappingStmt *from)
 
static DropUserMappingStmt_copyDropUserMappingStmt (const DropUserMappingStmt *from)
 
static CreateForeignTableStmt_copyCreateForeignTableStmt (const CreateForeignTableStmt *from)
 
static ImportForeignSchemaStmt_copyImportForeignSchemaStmt (const ImportForeignSchemaStmt *from)
 
static CreateTransformStmt_copyCreateTransformStmt (const CreateTransformStmt *from)
 
static CreateAmStmt_copyCreateAmStmt (const CreateAmStmt *from)
 
static CreateTrigStmt_copyCreateTrigStmt (const CreateTrigStmt *from)
 
static CreateEventTrigStmt_copyCreateEventTrigStmt (const CreateEventTrigStmt *from)
 
static AlterEventTrigStmt_copyAlterEventTrigStmt (const AlterEventTrigStmt *from)
 
static CreatePLangStmt_copyCreatePLangStmt (const CreatePLangStmt *from)
 
static CreateRoleStmt_copyCreateRoleStmt (const CreateRoleStmt *from)
 
static AlterRoleStmt_copyAlterRoleStmt (const AlterRoleStmt *from)
 
static AlterRoleSetStmt_copyAlterRoleSetStmt (const AlterRoleSetStmt *from)
 
static DropRoleStmt_copyDropRoleStmt (const DropRoleStmt *from)
 
static LockStmt_copyLockStmt (const LockStmt *from)
 
static ConstraintsSetStmt_copyConstraintsSetStmt (const ConstraintsSetStmt *from)
 
static ReindexStmt_copyReindexStmt (const ReindexStmt *from)
 
static CreateSchemaStmt_copyCreateSchemaStmt (const CreateSchemaStmt *from)
 
static CreateConversionStmt_copyCreateConversionStmt (const CreateConversionStmt *from)
 
static CreateCastStmt_copyCreateCastStmt (const CreateCastStmt *from)
 
static PrepareStmt_copyPrepareStmt (const PrepareStmt *from)
 
static ExecuteStmt_copyExecuteStmt (const ExecuteStmt *from)
 
static DeallocateStmt_copyDeallocateStmt (const DeallocateStmt *from)
 
static DropOwnedStmt_copyDropOwnedStmt (const DropOwnedStmt *from)
 
static ReassignOwnedStmt_copyReassignOwnedStmt (const ReassignOwnedStmt *from)
 
static AlterTSDictionaryStmt_copyAlterTSDictionaryStmt (const AlterTSDictionaryStmt *from)
 
static AlterTSConfigurationStmt_copyAlterTSConfigurationStmt (const AlterTSConfigurationStmt *from)
 
static CreatePolicyStmt_copyCreatePolicyStmt (const CreatePolicyStmt *from)
 
static AlterPolicyStmt_copyAlterPolicyStmt (const AlterPolicyStmt *from)
 
static PartitionElem_copyPartitionElem (const PartitionElem *from)
 
static PartitionSpec_copyPartitionSpec (const PartitionSpec *from)
 
static PartitionBoundSpec_copyPartitionBoundSpec (const PartitionBoundSpec *from)
 
static PartitionRangeDatum_copyPartitionRangeDatum (const PartitionRangeDatum *from)
 
static PartitionCmd_copyPartitionCmd (const PartitionCmd *from)
 
static PublicationObjSpec_copyPublicationObject (const PublicationObjSpec *from)
 
static PublicationTable_copyPublicationTable (const PublicationTable *from)
 
static CreatePublicationStmt_copyCreatePublicationStmt (const CreatePublicationStmt *from)
 
static AlterPublicationStmt_copyAlterPublicationStmt (const AlterPublicationStmt *from)
 
static CreateSubscriptionStmt_copyCreateSubscriptionStmt (const CreateSubscriptionStmt *from)
 
static AlterSubscriptionStmt_copyAlterSubscriptionStmt (const AlterSubscriptionStmt *from)
 
static DropSubscriptionStmt_copyDropSubscriptionStmt (const DropSubscriptionStmt *from)
 
static ExtensibleNode_copyExtensibleNode (const ExtensibleNode *from)
 
static Integer_copyInteger (const Integer *from)
 
static Float_copyFloat (const Float *from)
 
static Boolean_copyBoolean (const Boolean *from)
 
static String_copyString (const String *from)
 
static BitString_copyBitString (const BitString *from)
 
static ForeignKeyCacheInfo_copyForeignKeyCacheInfo (const ForeignKeyCacheInfo *from)
 
void * copyObjectImpl (const void *from)
 

Macro Definition Documentation

◆ COPY_ARRAY_FIELD

#define COPY_ARRAY_FIELD (   fldname)     memcpy(newnode->fldname, from->fldname, sizeof(newnode->fldname))

Definition at line 57 of file copyfuncs.c.

◆ COPY_BITMAPSET_FIELD

#define COPY_BITMAPSET_FIELD (   fldname)     (newnode->fldname = bms_copy(from->fldname))

Definition at line 49 of file copyfuncs.c.

◆ COPY_LOCATION_FIELD

#define COPY_LOCATION_FIELD (   fldname)     (newnode->fldname = from->fldname)

Definition at line 72 of file copyfuncs.c.

◆ COPY_NODE_FIELD

#define COPY_NODE_FIELD (   fldname)     (newnode->fldname = copyObjectImpl(from->fldname))

Definition at line 45 of file copyfuncs.c.

◆ COPY_POINTER_FIELD

#define COPY_POINTER_FIELD (   fldname,
  sz 
)
Value:
do { \
Size _size = (sz); \
if (_size > 0) \
{ \
newnode->fldname = palloc(_size); \
memcpy(newnode->fldname, from->fldname, _size); \
} \
} while (0)
void * palloc(Size size)
Definition: mcxt.c:1068

Definition at line 61 of file copyfuncs.c.

◆ COPY_SCALAR_FIELD

#define COPY_SCALAR_FIELD (   fldname)     (newnode->fldname = from->fldname)

Definition at line 41 of file copyfuncs.c.

◆ COPY_STRING_FIELD

#define COPY_STRING_FIELD (   fldname)     (newnode->fldname = from->fldname ? pstrdup(from->fldname) : (char *) NULL)

Definition at line 53 of file copyfuncs.c.

Function Documentation

◆ _copyA_ArrayExpr()

static A_ArrayExpr* _copyA_ArrayExpr ( const A_ArrayExpr from)
static

Definition at line 3342 of file copyfuncs.c.

3343 {
3344  A_ArrayExpr *newnode = makeNode(A_ArrayExpr);
3345 
3346  COPY_NODE_FIELD(elements);
3347  COPY_LOCATION_FIELD(location);
3348 
3349  return newnode;
3350 }
#define COPY_LOCATION_FIELD(fldname)
Definition: copyfuncs.c:72
#define COPY_NODE_FIELD(fldname)
Definition: copyfuncs.c:45
#define makeNode(_type_)
Definition: nodes.h:621

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyA_Const()

static A_Const* _copyA_Const ( const A_Const from)
static

Definition at line 3252 of file copyfuncs.c.

3253 {
3254  A_Const *newnode = makeNode(A_Const);
3255 
3256  COPY_SCALAR_FIELD(isnull);
3257  if (!from->isnull)
3258  {
3259  /* This part must duplicate other _copy*() functions. */
3260  COPY_SCALAR_FIELD(val.node.type);
3261  switch (nodeTag(&from->val))
3262  {
3263  case T_Integer:
3264  COPY_SCALAR_FIELD(val.ival.ival);
3265  break;
3266  case T_Float:
3267  COPY_STRING_FIELD(val.fval.fval);
3268  break;
3269  case T_Boolean:
3270  COPY_SCALAR_FIELD(val.boolval.boolval);
3271  break;
3272  case T_String:
3273  COPY_STRING_FIELD(val.sval.sval);
3274  break;
3275  case T_BitString:
3276  COPY_STRING_FIELD(val.bsval.bsval);
3277  break;
3278  default:
3279  elog(ERROR, "unrecognized node type: %d",
3280  (int) nodeTag(&from->val));
3281  break;
3282  }
3283  }
3284 
3285  COPY_LOCATION_FIELD(location);
3286 
3287  return newnode;
3288 }
#define COPY_STRING_FIELD(fldname)
Definition: copyfuncs.c:53
#define COPY_SCALAR_FIELD(fldname)
Definition: copyfuncs.c:41
#define ERROR
Definition: elog.h:33
#define elog(elevel,...)
Definition: elog.h:218
long val
Definition: informix.c:664
#define nodeTag(nodeptr)
Definition: nodes.h:578
@ T_BitString
Definition: nodes.h:312
@ T_Float
Definition: nodes.h:309
@ T_String
Definition: nodes.h:311
@ T_Integer
Definition: nodes.h:308
@ T_Boolean
Definition: nodes.h:310
bool isnull
Definition: parsenodes.h:318
union A_Const::ValUnion val

References COPY_LOCATION_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, elog, ERROR, A_Const::isnull, makeNode, nodeTag, T_BitString, T_Boolean, T_Float, T_Integer, T_String, A_Const::val, and val.

Referenced by copyObjectImpl().

◆ _copyA_Expr()

static A_Expr* _copyA_Expr ( const A_Expr from)
static

Definition at line 3216 of file copyfuncs.c.

3217 {
3218  A_Expr *newnode = makeNode(A_Expr);
3219 
3220  COPY_SCALAR_FIELD(kind);
3222  COPY_NODE_FIELD(lexpr);
3223  COPY_NODE_FIELD(rexpr);
3224  COPY_LOCATION_FIELD(location);
3225 
3226  return newnode;
3227 }
const char * name
Definition: encode.c:561

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, makeNode, and name.

Referenced by copyObjectImpl().

◆ _copyA_Indices()

static A_Indices* _copyA_Indices ( const A_Indices from)
static

Definition at line 3319 of file copyfuncs.c.

3320 {
3321  A_Indices *newnode = makeNode(A_Indices);
3322 
3323  COPY_SCALAR_FIELD(is_slice);
3324  COPY_NODE_FIELD(lidx);
3325  COPY_NODE_FIELD(uidx);
3326 
3327  return newnode;
3328 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyA_Indirection()

static A_Indirection* _copyA_Indirection ( const A_Indirection from)
static

Definition at line 3331 of file copyfuncs.c.

3332 {
3333  A_Indirection *newnode = makeNode(A_Indirection);
3334 
3336  COPY_NODE_FIELD(indirection);
3337 
3338  return newnode;
3339 }
void * arg

References arg, COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyA_Star()

static A_Star* _copyA_Star ( const A_Star from)
static

Definition at line 3311 of file copyfuncs.c.

3312 {
3313  A_Star *newnode = makeNode(A_Star);
3314 
3315  return newnode;
3316 }

References makeNode.

Referenced by copyObjectImpl().

◆ _copyAccessPriv()

static AccessPriv* _copyAccessPriv ( const AccessPriv from)
static

Definition at line 3956 of file copyfuncs.c.

3957 {
3958  AccessPriv *newnode = makeNode(AccessPriv);
3959 
3960  COPY_STRING_FIELD(priv_name);
3961  COPY_NODE_FIELD(cols);
3962 
3963  return newnode;
3964 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAgg()

static Agg* _copyAgg ( const Agg from)
static

Definition at line 1064 of file copyfuncs.c.

1065 {
1066  Agg *newnode = makeNode(Agg);
1067 
1068  CopyPlanFields((const Plan *) from, (Plan *) newnode);
1069 
1070  COPY_SCALAR_FIELD(aggstrategy);
1071  COPY_SCALAR_FIELD(aggsplit);
1072  COPY_SCALAR_FIELD(numCols);
1073  COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
1074  COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid));
1075  COPY_POINTER_FIELD(grpCollations, from->numCols * sizeof(Oid));
1076  COPY_SCALAR_FIELD(numGroups);
1077  COPY_SCALAR_FIELD(transitionSpace);
1078  COPY_BITMAPSET_FIELD(aggParams);
1079  COPY_NODE_FIELD(groupingSets);
1080  COPY_NODE_FIELD(chain);
1081 
1082  return newnode;
1083 }
int16 AttrNumber
Definition: attnum.h:21
#define COPY_BITMAPSET_FIELD(fldname)
Definition: copyfuncs.c:49
#define COPY_POINTER_FIELD(fldname, sz)
Definition: copyfuncs.c:61
static void CopyPlanFields(const Plan *from, Plan *newnode)
Definition: copyfuncs.c:122
unsigned int Oid
Definition: postgres_ext.h:31
Definition: plannodes.h:966

References COPY_BITMAPSET_FIELD, COPY_NODE_FIELD, COPY_POINTER_FIELD, COPY_SCALAR_FIELD, CopyPlanFields(), makeNode, and Agg::numCols.

Referenced by copyObjectImpl().

◆ _copyAggref()

static Aggref* _copyAggref ( const Aggref from)
static

Definition at line 1529 of file copyfuncs.c.

1530 {
1531  Aggref *newnode = makeNode(Aggref);
1532 
1533  COPY_SCALAR_FIELD(aggfnoid);
1534  COPY_SCALAR_FIELD(aggtype);
1535  COPY_SCALAR_FIELD(aggcollid);
1536  COPY_SCALAR_FIELD(inputcollid);
1537  COPY_SCALAR_FIELD(aggtranstype);
1538  COPY_NODE_FIELD(aggargtypes);
1539  COPY_NODE_FIELD(aggdirectargs);
1541  COPY_NODE_FIELD(aggorder);
1542  COPY_NODE_FIELD(aggdistinct);
1543  COPY_NODE_FIELD(aggfilter);
1544  COPY_SCALAR_FIELD(aggstar);
1545  COPY_SCALAR_FIELD(aggvariadic);
1546  COPY_SCALAR_FIELD(aggkind);
1547  COPY_SCALAR_FIELD(agglevelsup);
1548  COPY_SCALAR_FIELD(aggsplit);
1549  COPY_SCALAR_FIELD(aggno);
1550  COPY_SCALAR_FIELD(aggtransno);
1551  COPY_LOCATION_FIELD(location);
1552 
1553  return newnode;
1554 }

References generate_unaccent_rules::args, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlias()

static Alias* _copyAlias ( const Alias from)
static

Definition at line 1364 of file copyfuncs.c.

1365 {
1366  Alias *newnode = makeNode(Alias);
1367 
1368  COPY_STRING_FIELD(aliasname);
1369  COPY_NODE_FIELD(colnames);
1370 
1371  return newnode;
1372 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterCollationStmt()

static AlterCollationStmt* _copyAlterCollationStmt ( const AlterCollationStmt from)
static

Definition at line 3900 of file copyfuncs.c.

3901 {
3903 
3904  COPY_NODE_FIELD(collname);
3905 
3906  return newnode;
3907 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterDatabaseRefreshCollStmt()

static AlterDatabaseRefreshCollStmt* _copyAlterDatabaseRefreshCollStmt ( const AlterDatabaseRefreshCollStmt from)
static

Definition at line 4596 of file copyfuncs.c.

4597 {
4599 
4601 
4602  return newnode;
4603 }
char * dbname
Definition: streamutil.c:51

References COPY_STRING_FIELD, dbname, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterDatabaseSetStmt()

static AlterDatabaseSetStmt* _copyAlterDatabaseSetStmt ( const AlterDatabaseSetStmt from)
static

Definition at line 4606 of file copyfuncs.c.

4607 {
4609 
4611  COPY_NODE_FIELD(setstmt);
4612 
4613  return newnode;
4614 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, dbname, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterDatabaseStmt()

static AlterDatabaseStmt* _copyAlterDatabaseStmt ( const AlterDatabaseStmt from)
static

Definition at line 4585 of file copyfuncs.c.

4586 {
4588 
4591 
4592  return newnode;
4593 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, dbname, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterDefaultPrivilegesStmt()

static AlterDefaultPrivilegesStmt* _copyAlterDefaultPrivilegesStmt ( const AlterDefaultPrivilegesStmt from)
static

Definition at line 3982 of file copyfuncs.c.

References generate_unaccent_rules::action, COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterDomainStmt()

static AlterDomainStmt* _copyAlterDomainStmt ( const AlterDomainStmt from)
static

Definition at line 3910 of file copyfuncs.c.

3911 {
3913 
3914  COPY_SCALAR_FIELD(subtype);
3915  COPY_NODE_FIELD(typeName);
3917  COPY_NODE_FIELD(def);
3918  COPY_SCALAR_FIELD(behavior);
3919  COPY_SCALAR_FIELD(missing_ok);
3920 
3921  return newnode;
3922 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, makeNode, and name.

Referenced by copyObjectImpl().

◆ _copyAlterEnumStmt()

static AlterEnumStmt* _copyAlterEnumStmt ( const AlterEnumStmt from)
static

Definition at line 4467 of file copyfuncs.c.

4468 {
4469  AlterEnumStmt *newnode = makeNode(AlterEnumStmt);
4470 
4471  COPY_NODE_FIELD(typeName);
4472  COPY_STRING_FIELD(oldVal);
4473  COPY_STRING_FIELD(newVal);
4474  COPY_STRING_FIELD(newValNeighbor);
4475  COPY_SCALAR_FIELD(newValIsAfter);
4476  COPY_SCALAR_FIELD(skipIfNewValExists);
4477 
4478  return newnode;
4479 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterEventTrigStmt()

static AlterEventTrigStmt* _copyAlterEventTrigStmt ( const AlterEventTrigStmt from)
static

Definition at line 5037 of file copyfuncs.c.

5038 {
5040 
5041  COPY_STRING_FIELD(trigname);
5042  COPY_SCALAR_FIELD(tgenabled);
5043 
5044  return newnode;
5045 }

References COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterExtensionContentsStmt()

static AlterExtensionContentsStmt* _copyAlterExtensionContentsStmt ( const AlterExtensionContentsStmt from)
static

Definition at line 4844 of file copyfuncs.c.

4845 {
4847 
4848  COPY_STRING_FIELD(extname);
4850  COPY_SCALAR_FIELD(objtype);
4851  COPY_NODE_FIELD(object);
4852 
4853  return newnode;
4854 }

References generate_unaccent_rules::action, COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterExtensionStmt()

static AlterExtensionStmt* _copyAlterExtensionStmt ( const AlterExtensionStmt from)
static

Definition at line 4833 of file copyfuncs.c.

4834 {
4836 
4837  COPY_STRING_FIELD(extname);
4839 
4840  return newnode;
4841 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterFdwStmt()

static AlterFdwStmt* _copyAlterFdwStmt ( const AlterFdwStmt from)
static

Definition at line 4869 of file copyfuncs.c.

4870 {
4871  AlterFdwStmt *newnode = makeNode(AlterFdwStmt);
4872 
4873  COPY_STRING_FIELD(fdwname);
4874  COPY_NODE_FIELD(func_options);
4876 
4877  return newnode;
4878 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterForeignServerStmt()

static AlterForeignServerStmt* _copyAlterForeignServerStmt ( const AlterForeignServerStmt from)
static

Definition at line 4896 of file copyfuncs.c.

4897 {
4899 
4900  COPY_STRING_FIELD(servername);
4901  COPY_STRING_FIELD(version);
4903  COPY_SCALAR_FIELD(has_version);
4904 
4905  return newnode;
4906 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterFunctionStmt()

static AlterFunctionStmt* _copyAlterFunctionStmt ( const AlterFunctionStmt from)
static

Definition at line 4271 of file copyfuncs.c.

4272 {
4274 
4275  COPY_SCALAR_FIELD(objtype);
4276  COPY_NODE_FIELD(func);
4277  COPY_NODE_FIELD(actions);
4278 
4279  return newnode;
4280 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlternativeSubPlan()

static AlternativeSubPlan* _copyAlternativeSubPlan ( const AlternativeSubPlan from)
static

Definition at line 1798 of file copyfuncs.c.

1799 {
1801 
1802  COPY_NODE_FIELD(subplans);
1803 
1804  return newnode;
1805 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterObjectDependsStmt()

static AlterObjectDependsStmt* _copyAlterObjectDependsStmt ( const AlterObjectDependsStmt from)
static

Definition at line 4310 of file copyfuncs.c.

4311 {
4313 
4314  COPY_SCALAR_FIELD(objectType);
4315  COPY_NODE_FIELD(relation);
4316  COPY_NODE_FIELD(object);
4317  COPY_NODE_FIELD(extname);
4318  COPY_SCALAR_FIELD(remove);
4319 
4320  return newnode;
4321 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterObjectSchemaStmt()

static AlterObjectSchemaStmt* _copyAlterObjectSchemaStmt ( const AlterObjectSchemaStmt from)
static

Definition at line 4324 of file copyfuncs.c.

4325 {
4327 
4328  COPY_SCALAR_FIELD(objectType);
4329  COPY_NODE_FIELD(relation);
4330  COPY_NODE_FIELD(object);
4331  COPY_STRING_FIELD(newschema);
4332  COPY_SCALAR_FIELD(missing_ok);
4333 
4334  return newnode;
4335 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterOperatorStmt()

static AlterOperatorStmt* _copyAlterOperatorStmt ( const AlterOperatorStmt from)
static

Definition at line 4351 of file copyfuncs.c.

4352 {
4354 
4355  COPY_NODE_FIELD(opername);
4357 
4358  return newnode;
4359 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterOpFamilyStmt()

static AlterOpFamilyStmt* _copyAlterOpFamilyStmt ( const AlterOpFamilyStmt from)
static

Definition at line 4561 of file copyfuncs.c.

4562 {
4564 
4565  COPY_NODE_FIELD(opfamilyname);
4566  COPY_STRING_FIELD(amname);
4567  COPY_SCALAR_FIELD(isDrop);
4568  COPY_NODE_FIELD(items);
4569 
4570  return newnode;
4571 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterOwnerStmt()

static AlterOwnerStmt* _copyAlterOwnerStmt ( const AlterOwnerStmt from)
static

Definition at line 4338 of file copyfuncs.c.

4339 {
4341 
4342  COPY_SCALAR_FIELD(objectType);
4343  COPY_NODE_FIELD(relation);
4344  COPY_NODE_FIELD(object);
4345  COPY_NODE_FIELD(newowner);
4346 
4347  return newnode;
4348 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterPolicyStmt()

static AlterPolicyStmt* _copyAlterPolicyStmt ( const AlterPolicyStmt from)
static

Definition at line 5285 of file copyfuncs.c.

5286 {
5288 
5289  COPY_STRING_FIELD(policy_name);
5290  COPY_NODE_FIELD(table);
5291  COPY_NODE_FIELD(roles);
5292  COPY_NODE_FIELD(qual);
5293  COPY_NODE_FIELD(with_check);
5294 
5295  return newnode;
5296 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterPublicationStmt()

static AlterPublicationStmt* _copyAlterPublicationStmt ( const AlterPublicationStmt from)
static

Definition at line 5404 of file copyfuncs.c.

5405 {
5407 
5408  COPY_STRING_FIELD(pubname);
5410  COPY_NODE_FIELD(pubobjects);
5411  COPY_SCALAR_FIELD(for_all_tables);
5413 
5414  return newnode;
5415 }

References generate_unaccent_rules::action, COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterRoleSetStmt()

static AlterRoleSetStmt* _copyAlterRoleSetStmt ( const AlterRoleSetStmt from)
static

Definition at line 5087 of file copyfuncs.c.

5088 {
5090 
5091  COPY_NODE_FIELD(role);
5092  COPY_STRING_FIELD(database);
5093  COPY_NODE_FIELD(setstmt);
5094 
5095  return newnode;
5096 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterRoleStmt()

static AlterRoleStmt* _copyAlterRoleStmt ( const AlterRoleStmt from)
static

Definition at line 5075 of file copyfuncs.c.

5076 {
5077  AlterRoleStmt *newnode = makeNode(AlterRoleStmt);
5078 
5079  COPY_NODE_FIELD(role);
5082 
5083  return newnode;
5084 }

References generate_unaccent_rules::action, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterSeqStmt()

static AlterSeqStmt* _copyAlterSeqStmt ( const AlterSeqStmt from)
static

Definition at line 4725 of file copyfuncs.c.

4726 {
4727  AlterSeqStmt *newnode = makeNode(AlterSeqStmt);
4728 
4729  COPY_NODE_FIELD(sequence);
4731  COPY_SCALAR_FIELD(for_identity);
4732  COPY_SCALAR_FIELD(missing_ok);
4733 
4734  return newnode;
4735 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterStatsStmt()

static AlterStatsStmt* _copyAlterStatsStmt ( const AlterStatsStmt from)
static

Definition at line 4230 of file copyfuncs.c.

4231 {
4233 
4234  COPY_NODE_FIELD(defnames);
4235  COPY_SCALAR_FIELD(stxstattarget);
4236  COPY_SCALAR_FIELD(missing_ok);
4237 
4238  return newnode;
4239 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterSubscriptionStmt()

static AlterSubscriptionStmt* _copyAlterSubscriptionStmt ( const AlterSubscriptionStmt from)
static

Definition at line 5431 of file copyfuncs.c.

5432 {
5434 
5435  COPY_SCALAR_FIELD(kind);
5437  COPY_STRING_FIELD(conninfo);
5438  COPY_NODE_FIELD(publication);
5440 
5441  return newnode;
5442 }
NameData subname

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, makeNode, and subname.

Referenced by copyObjectImpl().

◆ _copyAlterSystemStmt()

static AlterSystemStmt* _copyAlterSystemStmt ( const AlterSystemStmt from)
static

Definition at line 4701 of file copyfuncs.c.

4702 {
4704 
4705  COPY_NODE_FIELD(setstmt);
4706 
4707  return newnode;
4708 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterTableCmd()

static AlterTableCmd* _copyAlterTableCmd ( const AlterTableCmd from)
static

Definition at line 3884 of file copyfuncs.c.

3885 {
3886  AlterTableCmd *newnode = makeNode(AlterTableCmd);
3887 
3888  COPY_SCALAR_FIELD(subtype);
3890  COPY_SCALAR_FIELD(num);
3891  COPY_NODE_FIELD(newowner);
3892  COPY_NODE_FIELD(def);
3893  COPY_SCALAR_FIELD(behavior);
3894  COPY_SCALAR_FIELD(missing_ok);
3895 
3896  return newnode;
3897 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, makeNode, and name.

Referenced by copyObjectImpl().

◆ _copyAlterTableMoveAllStmt()

static AlterTableMoveAllStmt* _copyAlterTableMoveAllStmt ( const AlterTableMoveAllStmt from)
static

Definition at line 4807 of file copyfuncs.c.

4808 {
4810 
4811  COPY_STRING_FIELD(orig_tablespacename);
4812  COPY_SCALAR_FIELD(objtype);
4813  COPY_NODE_FIELD(roles);
4814  COPY_STRING_FIELD(new_tablespacename);
4815  COPY_SCALAR_FIELD(nowait);
4816 
4817  return newnode;
4818 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterTableSpaceOptionsStmt()

static AlterTableSpaceOptionsStmt* _copyAlterTableSpaceOptionsStmt ( const AlterTableSpaceOptionsStmt from)
static

Definition at line 4795 of file copyfuncs.c.

4796 {
4798 
4799  COPY_STRING_FIELD(tablespacename);
4801  COPY_SCALAR_FIELD(isReset);
4802 
4803  return newnode;
4804 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterTableStmt()

static AlterTableStmt* _copyAlterTableStmt ( const AlterTableStmt from)
static

Definition at line 3871 of file copyfuncs.c.

3872 {
3874 
3875  COPY_NODE_FIELD(relation);
3876  COPY_NODE_FIELD(cmds);
3877  COPY_SCALAR_FIELD(objtype);
3878  COPY_SCALAR_FIELD(missing_ok);
3879 
3880  return newnode;
3881 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterTSConfigurationStmt()

static AlterTSConfigurationStmt* _copyAlterTSConfigurationStmt ( const AlterTSConfigurationStmt from)
static

Definition at line 5253 of file copyfuncs.c.

5254 {
5256 
5257  COPY_SCALAR_FIELD(kind);
5258  COPY_NODE_FIELD(cfgname);
5259  COPY_NODE_FIELD(tokentype);
5260  COPY_NODE_FIELD(dicts);
5261  COPY_SCALAR_FIELD(override);
5262  COPY_SCALAR_FIELD(replace);
5263  COPY_SCALAR_FIELD(missing_ok);
5264 
5265  return newnode;
5266 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterTSDictionaryStmt()

static AlterTSDictionaryStmt* _copyAlterTSDictionaryStmt ( const AlterTSDictionaryStmt from)
static

Definition at line 5242 of file copyfuncs.c.

5243 {
5245 
5246  COPY_NODE_FIELD(dictname);
5248 
5249  return newnode;
5250 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterTypeStmt()

static AlterTypeStmt* _copyAlterTypeStmt ( const AlterTypeStmt from)
static

Definition at line 4362 of file copyfuncs.c.

4363 {
4364  AlterTypeStmt *newnode = makeNode(AlterTypeStmt);
4365 
4366  COPY_NODE_FIELD(typeName);
4368 
4369  return newnode;
4370 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyAlterUserMappingStmt()

static AlterUserMappingStmt* _copyAlterUserMappingStmt ( const AlterUserMappingStmt from)
static

Definition at line 4922 of file copyfuncs.c.

4923 {
4925 
4927  COPY_STRING_FIELD(servername);
4929 
4930  return newnode;
4931 }
static char * user
Definition: pg_regress.c:95

References COPY_NODE_FIELD, COPY_STRING_FIELD, makeNode, and user.

Referenced by copyObjectImpl().

◆ _copyAppend()

static Append* _copyAppend ( const Append from)
static

Definition at line 240 of file copyfuncs.c.

241 {
242  Append *newnode = makeNode(Append);
243 
244  /*
245  * copy node superclass fields
246  */
247  CopyPlanFields((const Plan *) from, (Plan *) newnode);
248 
249  /*
250  * copy remainder of node
251  */
252  COPY_BITMAPSET_FIELD(apprelids);
253  COPY_NODE_FIELD(appendplans);
254  COPY_SCALAR_FIELD(nasyncplans);
255  COPY_SCALAR_FIELD(first_partial_plan);
256  COPY_NODE_FIELD(part_prune_info);
257 
258  return newnode;
259 }

References COPY_BITMAPSET_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, CopyPlanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyAppendRelInfo()

static AppendRelInfo* _copyAppendRelInfo ( const AppendRelInfo from)
static

Definition at line 2903 of file copyfuncs.c.

2904 {
2905  AppendRelInfo *newnode = makeNode(AppendRelInfo);
2906 
2907  COPY_SCALAR_FIELD(parent_relid);
2908  COPY_SCALAR_FIELD(child_relid);
2909  COPY_SCALAR_FIELD(parent_reltype);
2910  COPY_SCALAR_FIELD(child_reltype);
2911  COPY_NODE_FIELD(translated_vars);
2912  COPY_SCALAR_FIELD(num_child_cols);
2913  COPY_POINTER_FIELD(parent_colnos, from->num_child_cols * sizeof(AttrNumber));
2914  COPY_SCALAR_FIELD(parent_reloid);
2915 
2916  return newnode;
2917 }
int num_child_cols
Definition: pathnodes.h:2574

References COPY_NODE_FIELD, COPY_POINTER_FIELD, COPY_SCALAR_FIELD, makeNode, and AppendRelInfo::num_child_cols.

Referenced by copyObjectImpl().

◆ _copyArrayCoerceExpr()

static ArrayCoerceExpr* _copyArrayCoerceExpr ( const ArrayCoerceExpr from)
static

Definition at line 1879 of file copyfuncs.c.

1880 {
1882 
1884  COPY_NODE_FIELD(elemexpr);
1885  COPY_SCALAR_FIELD(resulttype);
1886  COPY_SCALAR_FIELD(resulttypmod);
1887  COPY_SCALAR_FIELD(resultcollid);
1888  COPY_SCALAR_FIELD(coerceformat);
1889  COPY_LOCATION_FIELD(location);
1890 
1891  return newnode;
1892 }

References arg, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyArrayExpr()

static ArrayExpr* _copyArrayExpr ( const ArrayExpr from)
static

Definition at line 1977 of file copyfuncs.c.

1978 {
1979  ArrayExpr *newnode = makeNode(ArrayExpr);
1980 
1981  COPY_SCALAR_FIELD(array_typeid);
1982  COPY_SCALAR_FIELD(array_collid);
1983  COPY_SCALAR_FIELD(element_typeid);
1984  COPY_NODE_FIELD(elements);
1985  COPY_SCALAR_FIELD(multidims);
1986  COPY_LOCATION_FIELD(location);
1987 
1988  return newnode;
1989 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyBitmapAnd()

static BitmapAnd* _copyBitmapAnd ( const BitmapAnd from)
static

Definition at line 319 of file copyfuncs.c.

320 {
321  BitmapAnd *newnode = makeNode(BitmapAnd);
322 
323  /*
324  * copy node superclass fields
325  */
326  CopyPlanFields((const Plan *) from, (Plan *) newnode);
327 
328  /*
329  * copy remainder of node
330  */
331  COPY_NODE_FIELD(bitmapplans);
332 
333  return newnode;
334 }

References COPY_NODE_FIELD, CopyPlanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyBitmapHeapScan()

static BitmapHeapScan* _copyBitmapHeapScan ( const BitmapHeapScan from)
static

Definition at line 559 of file copyfuncs.c.

560 {
562 
563  /*
564  * copy node superclass fields
565  */
566  CopyScanFields((const Scan *) from, (Scan *) newnode);
567 
568  /*
569  * copy remainder of node
570  */
571  COPY_NODE_FIELD(bitmapqualorig);
572 
573  return newnode;
574 }
static void CopyScanFields(const Scan *from, Scan *newnode)
Definition: copyfuncs.c:418

References COPY_NODE_FIELD, CopyScanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyBitmapIndexScan()

static BitmapIndexScan* _copyBitmapIndexScan ( const BitmapIndexScan from)
static

Definition at line 535 of file copyfuncs.c.

536 {
538 
539  /*
540  * copy node superclass fields
541  */
542  CopyScanFields((const Scan *) from, (Scan *) newnode);
543 
544  /*
545  * copy remainder of node
546  */
547  COPY_SCALAR_FIELD(indexid);
548  COPY_SCALAR_FIELD(isshared);
549  COPY_NODE_FIELD(indexqual);
550  COPY_NODE_FIELD(indexqualorig);
551 
552  return newnode;
553 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, CopyScanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyBitmapOr()

static BitmapOr* _copyBitmapOr ( const BitmapOr from)
static

Definition at line 340 of file copyfuncs.c.

341 {
342  BitmapOr *newnode = makeNode(BitmapOr);
343 
344  /*
345  * copy node superclass fields
346  */
347  CopyPlanFields((const Plan *) from, (Plan *) newnode);
348 
349  /*
350  * copy remainder of node
351  */
352  COPY_SCALAR_FIELD(isshared);
353  COPY_NODE_FIELD(bitmapplans);
354 
355  return newnode;
356 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, CopyPlanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyBitString()

static BitString* _copyBitString ( const BitString from)
static

Definition at line 5522 of file copyfuncs.c.

5523 {
5524  BitString *newnode = makeNode(BitString);
5525 
5526  COPY_STRING_FIELD(bsval);
5527 
5528  return newnode;
5529 }

References COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyBoolean()

static Boolean* _copyBoolean ( const Boolean from)
static

Definition at line 5502 of file copyfuncs.c.

5503 {
5504  Boolean *newnode = makeNode(Boolean);
5505 
5506  COPY_SCALAR_FIELD(boolval);
5507 
5508  return newnode;
5509 }
Definition: value.h:52

References COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyBooleanTest()

static BooleanTest* _copyBooleanTest ( const BooleanTest from)
static

Definition at line 2117 of file copyfuncs.c.

2118 {
2119  BooleanTest *newnode = makeNode(BooleanTest);
2120 
2122  COPY_SCALAR_FIELD(booltesttype);
2123  COPY_LOCATION_FIELD(location);
2124 
2125  return newnode;
2126 }

References arg, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyBoolExpr()

static BoolExpr* _copyBoolExpr ( const BoolExpr from)
static

Definition at line 1737 of file copyfuncs.c.

1738 {
1739  BoolExpr *newnode = makeNode(BoolExpr);
1740 
1743  COPY_LOCATION_FIELD(location);
1744 
1745  return newnode;
1746 }
Datum boolop(PG_FUNCTION_ARGS)
Definition: _int_bool.c:418

References generate_unaccent_rules::args, boolop(), COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCallStmt()

static CallStmt* _copyCallStmt ( const CallStmt from)
static

Definition at line 4015 of file copyfuncs.c.

4016 {
4017  CallStmt *newnode = makeNode(CallStmt);
4018 
4019  COPY_NODE_FIELD(funccall);
4020  COPY_NODE_FIELD(funcexpr);
4021  COPY_NODE_FIELD(outargs);
4022 
4023  return newnode;
4024 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCaseExpr()

static CaseExpr* _copyCaseExpr ( const CaseExpr from)
static

Definition at line 1929 of file copyfuncs.c.

1930 {
1931  CaseExpr *newnode = makeNode(CaseExpr);
1932 
1933  COPY_SCALAR_FIELD(casetype);
1934  COPY_SCALAR_FIELD(casecollid);
1937  COPY_NODE_FIELD(defresult);
1938  COPY_LOCATION_FIELD(location);
1939 
1940  return newnode;
1941 }

References arg, generate_unaccent_rules::args, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCaseTestExpr()

static CaseTestExpr* _copyCaseTestExpr ( const CaseTestExpr from)
static

Definition at line 1962 of file copyfuncs.c.

1963 {
1964  CaseTestExpr *newnode = makeNode(CaseTestExpr);
1965 
1966  COPY_SCALAR_FIELD(typeId);
1967  COPY_SCALAR_FIELD(typeMod);
1968  COPY_SCALAR_FIELD(collation);
1969 
1970  return newnode;
1971 }

References COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCaseWhen()

static CaseWhen* _copyCaseWhen ( const CaseWhen from)
static

Definition at line 1947 of file copyfuncs.c.

1948 {
1949  CaseWhen *newnode = makeNode(CaseWhen);
1950 
1951  COPY_NODE_FIELD(expr);
1952  COPY_NODE_FIELD(result);
1953  COPY_LOCATION_FIELD(location);
1954 
1955  return newnode;
1956 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyClosePortalStmt()

static ClosePortalStmt* _copyClosePortalStmt ( const ClosePortalStmt from)
static

Definition at line 4005 of file copyfuncs.c.

4006 {
4008 
4009  COPY_STRING_FIELD(portalname);
4010 
4011  return newnode;
4012 }

References COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyClusterStmt()

static ClusterStmt* _copyClusterStmt ( const ClusterStmt from)
static

Definition at line 4027 of file copyfuncs.c.

4028 {
4029  ClusterStmt *newnode = makeNode(ClusterStmt);
4030 
4031  COPY_NODE_FIELD(relation);
4032  COPY_STRING_FIELD(indexname);
4033  COPY_NODE_FIELD(params);
4034 
4035  return newnode;
4036 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCoalesceExpr()

static CoalesceExpr* _copyCoalesceExpr ( const CoalesceExpr from)
static

Definition at line 2030 of file copyfuncs.c.

2031 {
2032  CoalesceExpr *newnode = makeNode(CoalesceExpr);
2033 
2034  COPY_SCALAR_FIELD(coalescetype);
2035  COPY_SCALAR_FIELD(coalescecollid);
2037  COPY_LOCATION_FIELD(location);
2038 
2039  return newnode;
2040 }

References generate_unaccent_rules::args, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCoerceToDomain()

static CoerceToDomain* _copyCoerceToDomain ( const CoerceToDomain from)
static

Definition at line 2132 of file copyfuncs.c.

2133 {
2135 
2137  COPY_SCALAR_FIELD(resulttype);
2138  COPY_SCALAR_FIELD(resulttypmod);
2139  COPY_SCALAR_FIELD(resultcollid);
2140  COPY_SCALAR_FIELD(coercionformat);
2141  COPY_LOCATION_FIELD(location);
2142 
2143  return newnode;
2144 }

References arg, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCoerceToDomainValue()

static CoerceToDomainValue* _copyCoerceToDomainValue ( const CoerceToDomainValue from)
static

Definition at line 2150 of file copyfuncs.c.

2151 {
2153 
2154  COPY_SCALAR_FIELD(typeId);
2155  COPY_SCALAR_FIELD(typeMod);
2156  COPY_SCALAR_FIELD(collation);
2157  COPY_LOCATION_FIELD(location);
2158 
2159  return newnode;
2160 }

References COPY_LOCATION_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCoerceViaIO()

static CoerceViaIO* _copyCoerceViaIO ( const CoerceViaIO from)
static

Definition at line 1862 of file copyfuncs.c.

1863 {
1864  CoerceViaIO *newnode = makeNode(CoerceViaIO);
1865 
1867  COPY_SCALAR_FIELD(resulttype);
1868  COPY_SCALAR_FIELD(resultcollid);
1869  COPY_SCALAR_FIELD(coerceformat);
1870  COPY_LOCATION_FIELD(location);
1871 
1872  return newnode;
1873 }

References arg, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCollateClause()

static CollateClause* _copyCollateClause ( const CollateClause from)
static

Definition at line 3511 of file copyfuncs.c.

3512 {
3513  CollateClause *newnode = makeNode(CollateClause);
3514 
3516  COPY_NODE_FIELD(collname);
3517  COPY_LOCATION_FIELD(location);
3518 
3519  return newnode;
3520 }

References arg, COPY_LOCATION_FIELD, COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCollateExpr()

static CollateExpr* _copyCollateExpr ( const CollateExpr from)
static

Definition at line 1914 of file copyfuncs.c.

1915 {
1916  CollateExpr *newnode = makeNode(CollateExpr);
1917 
1919  COPY_SCALAR_FIELD(collOid);
1920  COPY_LOCATION_FIELD(location);
1921 
1922  return newnode;
1923 }

References arg, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyColumnDef()

static ColumnDef* _copyColumnDef ( const ColumnDef from)
static

Definition at line 3551 of file copyfuncs.c.

3552 {
3553  ColumnDef *newnode = makeNode(ColumnDef);
3554 
3555  COPY_STRING_FIELD(colname);
3556  COPY_NODE_FIELD(typeName);
3557  COPY_STRING_FIELD(compression);
3558  COPY_SCALAR_FIELD(inhcount);
3559  COPY_SCALAR_FIELD(is_local);
3560  COPY_SCALAR_FIELD(is_not_null);
3561  COPY_SCALAR_FIELD(is_from_type);
3562  COPY_SCALAR_FIELD(storage);
3563  COPY_NODE_FIELD(raw_default);
3564  COPY_NODE_FIELD(cooked_default);
3565  COPY_SCALAR_FIELD(identity);
3566  COPY_NODE_FIELD(identitySequence);
3567  COPY_SCALAR_FIELD(generated);
3568  COPY_NODE_FIELD(collClause);
3569  COPY_SCALAR_FIELD(collOid);
3570  COPY_NODE_FIELD(constraints);
3571  COPY_NODE_FIELD(fdwoptions);
3572  COPY_LOCATION_FIELD(location);
3573 
3574  return newnode;
3575 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyColumnRef()

static ColumnRef* _copyColumnRef ( const ColumnRef from)
static

Definition at line 3230 of file copyfuncs.c.

3231 {
3232  ColumnRef *newnode = makeNode(ColumnRef);
3233 
3234  COPY_NODE_FIELD(fields);
3235  COPY_LOCATION_FIELD(location);
3236 
3237  return newnode;
3238 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCommentStmt()

static CommentStmt* _copyCommentStmt ( const CommentStmt from)
static

Definition at line 4143 of file copyfuncs.c.

4144 {
4145  CommentStmt *newnode = makeNode(CommentStmt);
4146 
4147  COPY_SCALAR_FIELD(objtype);
4148  COPY_NODE_FIELD(object);
4149  COPY_STRING_FIELD(comment);
4150 
4151  return newnode;
4152 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCommonTableExpr()

static CommonTableExpr* _copyCommonTableExpr ( const CommonTableExpr from)
static

Definition at line 3165 of file copyfuncs.c.

3166 {
3168 
3169  COPY_STRING_FIELD(ctename);
3170  COPY_NODE_FIELD(aliascolnames);
3171  COPY_SCALAR_FIELD(ctematerialized);
3172  COPY_NODE_FIELD(ctequery);
3173  COPY_NODE_FIELD(search_clause);
3174  COPY_NODE_FIELD(cycle_clause);
3175  COPY_LOCATION_FIELD(location);
3176  COPY_SCALAR_FIELD(cterecursive);
3177  COPY_SCALAR_FIELD(cterefcount);
3178  COPY_NODE_FIELD(ctecolnames);
3179  COPY_NODE_FIELD(ctecoltypes);
3180  COPY_NODE_FIELD(ctecoltypmods);
3181  COPY_NODE_FIELD(ctecolcollations);
3182 
3183  return newnode;
3184 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCompositeTypeStmt()

static CompositeTypeStmt* _copyCompositeTypeStmt ( const CompositeTypeStmt from)
static

Definition at line 4434 of file copyfuncs.c.

4435 {
4437 
4438  COPY_NODE_FIELD(typevar);
4439  COPY_NODE_FIELD(coldeflist);
4440 
4441  return newnode;
4442 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyConst()

static Const* _copyConst ( const Const from)
static

Definition at line 1473 of file copyfuncs.c.

1474 {
1475  Const *newnode = makeNode(Const);
1476 
1477  COPY_SCALAR_FIELD(consttype);
1478  COPY_SCALAR_FIELD(consttypmod);
1479  COPY_SCALAR_FIELD(constcollid);
1480  COPY_SCALAR_FIELD(constlen);
1481 
1482  if (from->constbyval || from->constisnull)
1483  {
1484  /*
1485  * passed by value so just copy the datum. Also, don't try to copy
1486  * struct when value is null!
1487  */
1488  newnode->constvalue = from->constvalue;
1489  }
1490  else
1491  {
1492  /*
1493  * passed by reference. We need a palloc'd copy.
1494  */
1495  newnode->constvalue = datumCopy(from->constvalue,
1496  from->constbyval,
1497  from->constlen);
1498  }
1499 
1500  COPY_SCALAR_FIELD(constisnull);
1501  COPY_SCALAR_FIELD(constbyval);
1502  COPY_LOCATION_FIELD(location);
1503 
1504  return newnode;
1505 }
Datum datumCopy(Datum value, bool typByVal, int typLen)
Definition: datum.c:132
int constlen
Definition: primnodes.h:259
Datum constvalue
Definition: primnodes.h:260
bool constisnull
Definition: primnodes.h:261
bool constbyval
Definition: primnodes.h:263

References Const::constbyval, Const::constisnull, Const::constlen, Const::constvalue, COPY_LOCATION_FIELD, COPY_SCALAR_FIELD, datumCopy(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyConstraint()

static Constraint* _copyConstraint ( const Constraint from)
static

Definition at line 3578 of file copyfuncs.c.

3579 {
3580  Constraint *newnode = makeNode(Constraint);
3581 
3582  COPY_SCALAR_FIELD(contype);
3583  COPY_STRING_FIELD(conname);
3584  COPY_SCALAR_FIELD(deferrable);
3585  COPY_SCALAR_FIELD(initdeferred);
3586  COPY_LOCATION_FIELD(location);
3587  COPY_SCALAR_FIELD(is_no_inherit);
3588  COPY_NODE_FIELD(raw_expr);
3589  COPY_STRING_FIELD(cooked_expr);
3590  COPY_SCALAR_FIELD(generated_when);
3591  COPY_SCALAR_FIELD(nulls_not_distinct);
3592  COPY_NODE_FIELD(keys);
3593  COPY_NODE_FIELD(including);
3594  COPY_NODE_FIELD(exclusions);
3596  COPY_STRING_FIELD(indexname);
3597  COPY_STRING_FIELD(indexspace);
3598  COPY_SCALAR_FIELD(reset_default_tblspc);
3599  COPY_STRING_FIELD(access_method);
3600  COPY_NODE_FIELD(where_clause);
3601  COPY_NODE_FIELD(pktable);
3602  COPY_NODE_FIELD(fk_attrs);
3603  COPY_NODE_FIELD(pk_attrs);
3604  COPY_SCALAR_FIELD(fk_matchtype);
3605  COPY_SCALAR_FIELD(fk_upd_action);
3606  COPY_SCALAR_FIELD(fk_del_action);
3607  COPY_NODE_FIELD(fk_del_set_cols);
3608  COPY_NODE_FIELD(old_conpfeqop);
3609  COPY_SCALAR_FIELD(old_pktable_oid);
3610  COPY_SCALAR_FIELD(skip_validation);
3611  COPY_SCALAR_FIELD(initially_valid);
3612 
3613  return newnode;
3614 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyConstraintsSetStmt()

static ConstraintsSetStmt* _copyConstraintsSetStmt ( const ConstraintsSetStmt from)
static

Definition at line 5122 of file copyfuncs.c.

5123 {
5125 
5126  COPY_NODE_FIELD(constraints);
5127  COPY_SCALAR_FIELD(deferred);
5128 
5129  return newnode;
5130 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyConvertRowtypeExpr()

static ConvertRowtypeExpr* _copyConvertRowtypeExpr ( const ConvertRowtypeExpr from)
static

Definition at line 1898 of file copyfuncs.c.

1899 {
1901 
1903  COPY_SCALAR_FIELD(resulttype);
1904  COPY_SCALAR_FIELD(convertformat);
1905  COPY_LOCATION_FIELD(location);
1906 
1907  return newnode;
1908 }

References arg, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCopyStmt()

static CopyStmt* _copyCopyStmt ( const CopyStmt from)
static

Definition at line 4039 of file copyfuncs.c.

4040 {
4041  CopyStmt *newnode = makeNode(CopyStmt);
4042 
4043  COPY_NODE_FIELD(relation);
4044  COPY_NODE_FIELD(query);
4045  COPY_NODE_FIELD(attlist);
4046  COPY_SCALAR_FIELD(is_from);
4047  COPY_SCALAR_FIELD(is_program);
4050  COPY_NODE_FIELD(whereClause);
4051 
4052  return newnode;
4053 }
static char * filename
Definition: pg_dumpall.c:94

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, filename, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateAmStmt()

static CreateAmStmt* _copyCreateAmStmt ( const CreateAmStmt from)
static

Definition at line 4988 of file copyfuncs.c.

4989 {
4990  CreateAmStmt *newnode = makeNode(CreateAmStmt);
4991 
4992  COPY_STRING_FIELD(amname);
4993  COPY_NODE_FIELD(handler_name);
4994  COPY_SCALAR_FIELD(amtype);
4995 
4996  return newnode;
4997 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateCastStmt()

static CreateCastStmt* _copyCreateCastStmt ( const CreateCastStmt from)
static

Definition at line 5173 of file copyfuncs.c.

5174 {
5176 
5177  COPY_NODE_FIELD(sourcetype);
5178  COPY_NODE_FIELD(targettype);
5179  COPY_NODE_FIELD(func);
5180  COPY_SCALAR_FIELD(context);
5181  COPY_SCALAR_FIELD(inout);
5182 
5183  return newnode;
5184 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateConversionStmt()

static CreateConversionStmt* _copyCreateConversionStmt ( const CreateConversionStmt from)
static

Definition at line 5159 of file copyfuncs.c.

5160 {
5162 
5163  COPY_NODE_FIELD(conversion_name);
5164  COPY_STRING_FIELD(for_encoding_name);
5165  COPY_STRING_FIELD(to_encoding_name);
5166  COPY_NODE_FIELD(func_name);
5167  COPY_SCALAR_FIELD(def);
5168 
5169  return newnode;
5170 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreatedbStmt()

static CreatedbStmt* _copyCreatedbStmt ( const CreatedbStmt from)
static

Definition at line 4574 of file copyfuncs.c.

4575 {
4576  CreatedbStmt *newnode = makeNode(CreatedbStmt);
4577 
4580 
4581  return newnode;
4582 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, dbname, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateDomainStmt()

static CreateDomainStmt* _copyCreateDomainStmt ( const CreateDomainStmt from)
static

Definition at line 4507 of file copyfuncs.c.

4508 {
4510 
4511  COPY_NODE_FIELD(domainname);
4512  COPY_NODE_FIELD(typeName);
4513  COPY_NODE_FIELD(collClause);
4514  COPY_NODE_FIELD(constraints);
4515 
4516  return newnode;
4517 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateEnumStmt()

static CreateEnumStmt* _copyCreateEnumStmt ( const CreateEnumStmt from)
static

Definition at line 4445 of file copyfuncs.c.

4446 {
4448 
4449  COPY_NODE_FIELD(typeName);
4450  COPY_NODE_FIELD(vals);
4451 
4452  return newnode;
4453 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateEventTrigStmt()

static CreateEventTrigStmt* _copyCreateEventTrigStmt ( const CreateEventTrigStmt from)
static

Definition at line 5024 of file copyfuncs.c.

5025 {
5027 
5028  COPY_STRING_FIELD(trigname);
5029  COPY_STRING_FIELD(eventname);
5030  COPY_NODE_FIELD(whenclause);
5031  COPY_NODE_FIELD(funcname);
5032 
5033  return newnode;
5034 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateExtensionStmt()

static CreateExtensionStmt* _copyCreateExtensionStmt ( const CreateExtensionStmt from)
static

Definition at line 4821 of file copyfuncs.c.

4822 {
4824 
4825  COPY_STRING_FIELD(extname);
4826  COPY_SCALAR_FIELD(if_not_exists);
4828 
4829  return newnode;
4830 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateFdwStmt()

static CreateFdwStmt* _copyCreateFdwStmt ( const CreateFdwStmt from)
static

Definition at line 4857 of file copyfuncs.c.

4858 {
4859  CreateFdwStmt *newnode = makeNode(CreateFdwStmt);
4860 
4861  COPY_STRING_FIELD(fdwname);
4862  COPY_NODE_FIELD(func_options);
4864 
4865  return newnode;
4866 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateForeignServerStmt()

static CreateForeignServerStmt* _copyCreateForeignServerStmt ( const CreateForeignServerStmt from)
static

Definition at line 4881 of file copyfuncs.c.

4882 {
4884 
4885  COPY_STRING_FIELD(servername);
4886  COPY_STRING_FIELD(servertype);
4887  COPY_STRING_FIELD(version);
4888  COPY_STRING_FIELD(fdwname);
4889  COPY_SCALAR_FIELD(if_not_exists);
4891 
4892  return newnode;
4893 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateForeignTableStmt()

static CreateForeignTableStmt* _copyCreateForeignTableStmt ( const CreateForeignTableStmt from)
static

Definition at line 4946 of file copyfuncs.c.

4947 {
4949 
4950  CopyCreateStmtFields((const CreateStmt *) from, (CreateStmt *) newnode);
4951 
4952  COPY_STRING_FIELD(servername);
4954 
4955  return newnode;
4956 }
static void CopyCreateStmtFields(const CreateStmt *from, CreateStmt *newnode)
Definition: copyfuncs.c:4062

References COPY_NODE_FIELD, COPY_STRING_FIELD, CopyCreateStmtFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateFunctionStmt()

static CreateFunctionStmt* _copyCreateFunctionStmt ( const CreateFunctionStmt from)
static

Definition at line 4242 of file copyfuncs.c.

4243 {
4245 
4246  COPY_SCALAR_FIELD(is_procedure);
4247  COPY_SCALAR_FIELD(replace);
4248  COPY_NODE_FIELD(funcname);
4249  COPY_NODE_FIELD(parameters);
4250  COPY_NODE_FIELD(returnType);
4252  COPY_NODE_FIELD(sql_body);
4253 
4254  return newnode;
4255 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateOpClassItem()

static CreateOpClassItem* _copyCreateOpClassItem ( const CreateOpClassItem from)
static

Definition at line 4535 of file copyfuncs.c.

4536 {
4538 
4539  COPY_SCALAR_FIELD(itemtype);
4541  COPY_SCALAR_FIELD(number);
4542  COPY_NODE_FIELD(order_family);
4543  COPY_NODE_FIELD(class_args);
4544  COPY_NODE_FIELD(storedtype);
4545 
4546  return newnode;
4547 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, makeNode, and name.

Referenced by copyObjectImpl().

◆ _copyCreateOpClassStmt()

static CreateOpClassStmt* _copyCreateOpClassStmt ( const CreateOpClassStmt from)
static

Definition at line 4520 of file copyfuncs.c.

4521 {
4523 
4524  COPY_NODE_FIELD(opclassname);
4525  COPY_NODE_FIELD(opfamilyname);
4526  COPY_STRING_FIELD(amname);
4527  COPY_NODE_FIELD(datatype);
4528  COPY_NODE_FIELD(items);
4529  COPY_SCALAR_FIELD(isDefault);
4530 
4531  return newnode;
4532 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateOpFamilyStmt()

static CreateOpFamilyStmt* _copyCreateOpFamilyStmt ( const CreateOpFamilyStmt from)
static

Definition at line 4550 of file copyfuncs.c.

4551 {
4553 
4554  COPY_NODE_FIELD(opfamilyname);
4555  COPY_STRING_FIELD(amname);
4556 
4557  return newnode;
4558 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreatePLangStmt()

static CreatePLangStmt* _copyCreatePLangStmt ( const CreatePLangStmt from)
static

Definition at line 5048 of file copyfuncs.c.

5049 {
5051 
5052  COPY_SCALAR_FIELD(replace);
5053  COPY_STRING_FIELD(plname);
5054  COPY_NODE_FIELD(plhandler);
5055  COPY_NODE_FIELD(plinline);
5056  COPY_NODE_FIELD(plvalidator);
5057  COPY_SCALAR_FIELD(pltrusted);
5058 
5059  return newnode;
5060 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreatePolicyStmt()

static CreatePolicyStmt* _copyCreatePolicyStmt ( const CreatePolicyStmt from)
static

Definition at line 5269 of file copyfuncs.c.

5270 {
5272 
5273  COPY_STRING_FIELD(policy_name);
5274  COPY_NODE_FIELD(table);
5275  COPY_STRING_FIELD(cmd_name);
5276  COPY_SCALAR_FIELD(permissive);
5277  COPY_NODE_FIELD(roles);
5278  COPY_NODE_FIELD(qual);
5279  COPY_NODE_FIELD(with_check);
5280 
5281  return newnode;
5282 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreatePublicationStmt()

static CreatePublicationStmt* _copyCreatePublicationStmt ( const CreatePublicationStmt from)
static

Definition at line 5391 of file copyfuncs.c.

5392 {
5394 
5395  COPY_STRING_FIELD(pubname);
5397  COPY_NODE_FIELD(pubobjects);
5398  COPY_SCALAR_FIELD(for_all_tables);
5399 
5400  return newnode;
5401 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateRangeStmt()

static CreateRangeStmt* _copyCreateRangeStmt ( const CreateRangeStmt from)
static

Definition at line 4456 of file copyfuncs.c.

4457 {
4459 
4460  COPY_NODE_FIELD(typeName);
4461  COPY_NODE_FIELD(params);
4462 
4463  return newnode;
4464 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateRoleStmt()

static CreateRoleStmt* _copyCreateRoleStmt ( const CreateRoleStmt from)
static

Definition at line 5063 of file copyfuncs.c.

5064 {
5066 
5067  COPY_SCALAR_FIELD(stmt_type);
5068  COPY_STRING_FIELD(role);
5070 
5071  return newnode;
5072 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateSchemaStmt()

static CreateSchemaStmt* _copyCreateSchemaStmt ( const CreateSchemaStmt from)
static

Definition at line 5146 of file copyfuncs.c.

5147 {
5149 
5150  COPY_STRING_FIELD(schemaname);
5151  COPY_NODE_FIELD(authrole);
5152  COPY_NODE_FIELD(schemaElts);
5153  COPY_SCALAR_FIELD(if_not_exists);
5154 
5155  return newnode;
5156 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateSeqStmt()

static CreateSeqStmt* _copyCreateSeqStmt ( const CreateSeqStmt from)
static

Definition at line 4711 of file copyfuncs.c.

4712 {
4713  CreateSeqStmt *newnode = makeNode(CreateSeqStmt);
4714 
4715  COPY_NODE_FIELD(sequence);
4717  COPY_SCALAR_FIELD(ownerId);
4718  COPY_SCALAR_FIELD(for_identity);
4719  COPY_SCALAR_FIELD(if_not_exists);
4720 
4721  return newnode;
4722 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateStatsStmt()

static CreateStatsStmt* _copyCreateStatsStmt ( const CreateStatsStmt from)
static

Definition at line 4214 of file copyfuncs.c.

4215 {
4217 
4218  COPY_NODE_FIELD(defnames);
4219  COPY_NODE_FIELD(stat_types);
4220  COPY_NODE_FIELD(exprs);
4221  COPY_NODE_FIELD(relations);
4222  COPY_STRING_FIELD(stxcomment);
4223  COPY_SCALAR_FIELD(transformed);
4224  COPY_SCALAR_FIELD(if_not_exists);
4225 
4226  return newnode;
4227 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateStmt()

static CreateStmt* _copyCreateStmt ( const CreateStmt from)
static

Definition at line 4079 of file copyfuncs.c.

4080 {
4081  CreateStmt *newnode = makeNode(CreateStmt);
4082 
4083  CopyCreateStmtFields(from, newnode);
4084 
4085  return newnode;
4086 }

References CopyCreateStmtFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateSubscriptionStmt()

static CreateSubscriptionStmt* _copyCreateSubscriptionStmt ( const CreateSubscriptionStmt from)
static

Definition at line 5418 of file copyfuncs.c.

5419 {
5421 
5423  COPY_STRING_FIELD(conninfo);
5424  COPY_NODE_FIELD(publication);
5426 
5427  return newnode;
5428 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, makeNode, and subname.

Referenced by copyObjectImpl().

◆ _copyCreateTableAsStmt()

static CreateTableAsStmt* _copyCreateTableAsStmt ( const CreateTableAsStmt from)
static

Definition at line 4664 of file copyfuncs.c.

4665 {
4667 
4668  COPY_NODE_FIELD(query);
4669  COPY_NODE_FIELD(into);
4670  COPY_SCALAR_FIELD(objtype);
4671  COPY_SCALAR_FIELD(is_select_into);
4672  COPY_SCALAR_FIELD(if_not_exists);
4673 
4674  return newnode;
4675 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateTableSpaceStmt()

static CreateTableSpaceStmt* _copyCreateTableSpaceStmt ( const CreateTableSpaceStmt from)
static

Definition at line 4771 of file copyfuncs.c.

4772 {
4774 
4775  COPY_STRING_FIELD(tablespacename);
4776  COPY_NODE_FIELD(owner);
4777  COPY_STRING_FIELD(location);
4779 
4780  return newnode;
4781 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateTransformStmt()

static CreateTransformStmt* _copyCreateTransformStmt ( const CreateTransformStmt from)
static

Definition at line 4974 of file copyfuncs.c.

4975 {
4977 
4978  COPY_SCALAR_FIELD(replace);
4979  COPY_NODE_FIELD(type_name);
4980  COPY_STRING_FIELD(lang);
4981  COPY_NODE_FIELD(fromsql);
4982  COPY_NODE_FIELD(tosql);
4983 
4984  return newnode;
4985 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateTrigStmt()

static CreateTrigStmt* _copyCreateTrigStmt ( const CreateTrigStmt from)
static

Definition at line 5000 of file copyfuncs.c.

5001 {
5003 
5004  COPY_SCALAR_FIELD(replace);
5005  COPY_SCALAR_FIELD(isconstraint);
5006  COPY_STRING_FIELD(trigname);
5007  COPY_NODE_FIELD(relation);
5008  COPY_NODE_FIELD(funcname);
5010  COPY_SCALAR_FIELD(row);
5011  COPY_SCALAR_FIELD(timing);
5012  COPY_SCALAR_FIELD(events);
5013  COPY_NODE_FIELD(columns);
5014  COPY_NODE_FIELD(whenClause);
5015  COPY_NODE_FIELD(transitionRels);
5016  COPY_SCALAR_FIELD(deferrable);
5017  COPY_SCALAR_FIELD(initdeferred);
5018  COPY_NODE_FIELD(constrrel);
5019 
5020  return newnode;
5021 }

References generate_unaccent_rules::args, COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCreateUserMappingStmt()

static CreateUserMappingStmt* _copyCreateUserMappingStmt ( const CreateUserMappingStmt from)
static

Definition at line 4909 of file copyfuncs.c.

4910 {
4912 
4914  COPY_STRING_FIELD(servername);
4915  COPY_SCALAR_FIELD(if_not_exists);
4917 
4918  return newnode;
4919 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, makeNode, and user.

Referenced by copyObjectImpl().

◆ _copyCTECycleClause()

static CTECycleClause* _copyCTECycleClause ( const CTECycleClause from)
static

Definition at line 3146 of file copyfuncs.c.

3147 {
3149 
3150  COPY_NODE_FIELD(cycle_col_list);
3151  COPY_STRING_FIELD(cycle_mark_column);
3152  COPY_NODE_FIELD(cycle_mark_value);
3153  COPY_NODE_FIELD(cycle_mark_default);
3154  COPY_STRING_FIELD(cycle_path_column);
3155  COPY_LOCATION_FIELD(location);
3156  COPY_SCALAR_FIELD(cycle_mark_type);
3157  COPY_SCALAR_FIELD(cycle_mark_typmod);
3158  COPY_SCALAR_FIELD(cycle_mark_collation);
3159  COPY_SCALAR_FIELD(cycle_mark_neop);
3160 
3161  return newnode;
3162 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCteScan()

static CteScan* _copyCteScan ( const CteScan from)
static

Definition at line 708 of file copyfuncs.c.

709 {
710  CteScan *newnode = makeNode(CteScan);
711 
712  /*
713  * copy node superclass fields
714  */
715  CopyScanFields((const Scan *) from, (Scan *) newnode);
716 
717  /*
718  * copy remainder of node
719  */
720  COPY_SCALAR_FIELD(ctePlanId);
721  COPY_SCALAR_FIELD(cteParam);
722 
723  return newnode;
724 }

References COPY_SCALAR_FIELD, CopyScanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyCTESearchClause()

static CTESearchClause* _copyCTESearchClause ( const CTESearchClause from)
static

Definition at line 3133 of file copyfuncs.c.

3134 {
3136 
3137  COPY_NODE_FIELD(search_col_list);
3138  COPY_SCALAR_FIELD(search_breadth_first);
3139  COPY_STRING_FIELD(search_seq_column);
3140  COPY_LOCATION_FIELD(location);
3141 
3142  return newnode;
3143 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCurrentOfExpr()

static CurrentOfExpr* _copyCurrentOfExpr ( const CurrentOfExpr from)
static

Definition at line 2182 of file copyfuncs.c.

2183 {
2184  CurrentOfExpr *newnode = makeNode(CurrentOfExpr);
2185 
2186  COPY_SCALAR_FIELD(cvarno);
2187  COPY_STRING_FIELD(cursor_name);
2188  COPY_SCALAR_FIELD(cursor_param);
2189 
2190  return newnode;
2191 }

References COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyCustomScan()

static CustomScan* _copyCustomScan ( const CustomScan from)
static

Definition at line 801 of file copyfuncs.c.

802 {
803  CustomScan *newnode = makeNode(CustomScan);
804 
805  /*
806  * copy node superclass fields
807  */
808  CopyScanFields((const Scan *) from, (Scan *) newnode);
809 
810  /*
811  * copy remainder of node
812  */
813  COPY_SCALAR_FIELD(flags);
814  COPY_NODE_FIELD(custom_plans);
815  COPY_NODE_FIELD(custom_exprs);
816  COPY_NODE_FIELD(custom_private);
817  COPY_NODE_FIELD(custom_scan_tlist);
818  COPY_BITMAPSET_FIELD(custom_relids);
819 
820  /*
821  * NOTE: The method field of CustomScan is required to be a pointer to a
822  * static table of callback functions. So we don't copy the table itself,
823  * just reference the original one.
824  */
825  COPY_SCALAR_FIELD(methods);
826 
827  return newnode;
828 }

References COPY_BITMAPSET_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, CopyScanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyDeallocateStmt()

static DeallocateStmt* _copyDeallocateStmt ( const DeallocateStmt from)
static

Definition at line 5210 of file copyfuncs.c.

5211 {
5213 
5215 
5216  return newnode;
5217 }

References COPY_STRING_FIELD, makeNode, and name.

Referenced by copyObjectImpl().

◆ _copyDeclareCursorStmt()

static DeclareCursorStmt* _copyDeclareCursorStmt ( const DeclareCursorStmt from)
static

Definition at line 3993 of file copyfuncs.c.

3994 {
3996 
3997  COPY_STRING_FIELD(portalname);
3999  COPY_NODE_FIELD(query);
4000 
4001  return newnode;
4002 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyDefElem()

static DefElem* _copyDefElem ( const DefElem from)
static

Definition at line 3617 of file copyfuncs.c.

3618 {
3619  DefElem *newnode = makeNode(DefElem);
3620 
3621  COPY_STRING_FIELD(defnamespace);
3622  COPY_STRING_FIELD(defname);
3624  COPY_SCALAR_FIELD(defaction);
3625  COPY_LOCATION_FIELD(location);
3626 
3627  return newnode;
3628 }

References arg, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyDefineStmt()

static DefineStmt* _copyDefineStmt ( const DefineStmt from)
static

Definition at line 4101 of file copyfuncs.c.

4102 {
4103  DefineStmt *newnode = makeNode(DefineStmt);
4104 
4105  COPY_SCALAR_FIELD(kind);
4106  COPY_SCALAR_FIELD(oldstyle);
4107  COPY_NODE_FIELD(defnames);
4109  COPY_NODE_FIELD(definition);
4110  COPY_SCALAR_FIELD(if_not_exists);
4111  COPY_SCALAR_FIELD(replace);
4112 
4113  return newnode;
4114 }

References generate_unaccent_rules::args, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyDeleteStmt()

static DeleteStmt* _copyDeleteStmt ( const DeleteStmt from)
static

Definition at line 3758 of file copyfuncs.c.

3759 {
3760  DeleteStmt *newnode = makeNode(DeleteStmt);
3761 
3762  COPY_NODE_FIELD(relation);
3763  COPY_NODE_FIELD(usingClause);
3764  COPY_NODE_FIELD(whereClause);
3765  COPY_NODE_FIELD(returningList);
3766  COPY_NODE_FIELD(withClause);
3767 
3768  return newnode;
3769 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyDiscardStmt()

static DiscardStmt* _copyDiscardStmt ( const DiscardStmt from)
static

Definition at line 4761 of file copyfuncs.c.

4762 {
4763  DiscardStmt *newnode = makeNode(DiscardStmt);
4764 
4765  COPY_SCALAR_FIELD(target);
4766 
4767  return newnode;
4768 }

References COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyDistinctExpr()

static DistinctExpr* _copyDistinctExpr ( const DistinctExpr from)
static

Definition at line 1677 of file copyfuncs.c.

1678 {
1679  DistinctExpr *newnode = makeNode(DistinctExpr);
1680 
1681  COPY_SCALAR_FIELD(opno);
1682  COPY_SCALAR_FIELD(opfuncid);
1683  COPY_SCALAR_FIELD(opresulttype);
1684  COPY_SCALAR_FIELD(opretset);
1685  COPY_SCALAR_FIELD(opcollid);
1686  COPY_SCALAR_FIELD(inputcollid);
1688  COPY_LOCATION_FIELD(location);
1689 
1690  return newnode;
1691 }

References generate_unaccent_rules::args, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyDoStmt()

static DoStmt* _copyDoStmt ( const DoStmt from)
static

Definition at line 4283 of file copyfuncs.c.

4284 {
4285  DoStmt *newnode = makeNode(DoStmt);
4286 
4288 
4289  return newnode;
4290 }

References generate_unaccent_rules::args, COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyDropdbStmt()

static DropdbStmt* _copyDropdbStmt ( const DropdbStmt from)
static

Definition at line 4617 of file copyfuncs.c.

4618 {
4619  DropdbStmt *newnode = makeNode(DropdbStmt);
4620 
4622  COPY_SCALAR_FIELD(missing_ok);
4624 
4625  return newnode;
4626 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, dbname, and makeNode.

Referenced by copyObjectImpl().

◆ _copyDropOwnedStmt()

static DropOwnedStmt* _copyDropOwnedStmt ( const DropOwnedStmt from)
static

Definition at line 5220 of file copyfuncs.c.

5221 {
5222  DropOwnedStmt *newnode = makeNode(DropOwnedStmt);
5223 
5224  COPY_NODE_FIELD(roles);
5225  COPY_SCALAR_FIELD(behavior);
5226 
5227  return newnode;
5228 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyDropRoleStmt()

static DropRoleStmt* _copyDropRoleStmt ( const DropRoleStmt from)
static

Definition at line 5099 of file copyfuncs.c.

5100 {
5101  DropRoleStmt *newnode = makeNode(DropRoleStmt);
5102 
5103  COPY_NODE_FIELD(roles);
5104  COPY_SCALAR_FIELD(missing_ok);
5105 
5106  return newnode;
5107 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyDropStmt()

static DropStmt* _copyDropStmt ( const DropStmt from)
static

Definition at line 4117 of file copyfuncs.c.

4118 {
4119  DropStmt *newnode = makeNode(DropStmt);
4120 
4121  COPY_NODE_FIELD(objects);
4122  COPY_SCALAR_FIELD(removeType);
4123  COPY_SCALAR_FIELD(behavior);
4124  COPY_SCALAR_FIELD(missing_ok);
4125  COPY_SCALAR_FIELD(concurrent);
4126 
4127  return newnode;
4128 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyDropSubscriptionStmt()

static DropSubscriptionStmt* _copyDropSubscriptionStmt ( const DropSubscriptionStmt from)
static

Definition at line 5445 of file copyfuncs.c.

5446 {
5448 
5450  COPY_SCALAR_FIELD(missing_ok);
5451  COPY_SCALAR_FIELD(behavior);
5452 
5453  return newnode;
5454 }

References COPY_SCALAR_FIELD, COPY_STRING_FIELD, makeNode, and subname.

Referenced by copyObjectImpl().

◆ _copyDropTableSpaceStmt()

static DropTableSpaceStmt* _copyDropTableSpaceStmt ( const DropTableSpaceStmt from)
static

Definition at line 4784 of file copyfuncs.c.

4785 {
4787 
4788  COPY_STRING_FIELD(tablespacename);
4789  COPY_SCALAR_FIELD(missing_ok);
4790 
4791  return newnode;
4792 }

References COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyDropUserMappingStmt()

static DropUserMappingStmt* _copyDropUserMappingStmt ( const DropUserMappingStmt from)
static

Definition at line 4934 of file copyfuncs.c.

4935 {
4937 
4939  COPY_STRING_FIELD(servername);
4940  COPY_SCALAR_FIELD(missing_ok);
4941 
4942  return newnode;
4943 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, makeNode, and user.

Referenced by copyObjectImpl().

◆ _copyExecuteStmt()

static ExecuteStmt* _copyExecuteStmt ( const ExecuteStmt from)
static

Definition at line 5199 of file copyfuncs.c.

5200 {
5201  ExecuteStmt *newnode = makeNode(ExecuteStmt);
5202 
5204  COPY_NODE_FIELD(params);
5205 
5206  return newnode;
5207 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, makeNode, and name.

Referenced by copyObjectImpl().

◆ _copyExplainStmt()

static ExplainStmt* _copyExplainStmt ( const ExplainStmt from)
static

Definition at line 4653 of file copyfuncs.c.

4654 {
4655  ExplainStmt *newnode = makeNode(ExplainStmt);
4656 
4657  COPY_NODE_FIELD(query);
4659 
4660  return newnode;
4661 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyExtensibleNode()

static ExtensibleNode* _copyExtensibleNode ( const ExtensibleNode from)
static

Definition at line 5461 of file copyfuncs.c.

5462 {
5463  ExtensibleNode *newnode;
5464  const ExtensibleNodeMethods *methods;
5465 
5466  methods = GetExtensibleNodeMethods(from->extnodename, false);
5467  newnode = (ExtensibleNode *) newNode(methods->node_size,
5469  COPY_STRING_FIELD(extnodename);
5470 
5471  /* copy the private fields */
5472  methods->nodeCopy(newnode, from);
5473 
5474  return newnode;
5475 }
const ExtensibleNodeMethods * GetExtensibleNodeMethods(const char *extnodename, bool missing_ok)
Definition: extensible.c:125
#define newNode(size, tag)
Definition: nodes.h:611
@ T_ExtensibleNode
Definition: nodes.h:324
void(* nodeCopy)(struct ExtensibleNode *newnode, const struct ExtensibleNode *oldnode)
Definition: extensible.h:64
const char * extnodename
Definition: extensible.h:35

References COPY_STRING_FIELD, ExtensibleNode::extnodename, GetExtensibleNodeMethods(), newNode, ExtensibleNodeMethods::node_size, ExtensibleNodeMethods::nodeCopy, and T_ExtensibleNode.

Referenced by copyObjectImpl().

◆ _copyFetchStmt()

static FetchStmt* _copyFetchStmt ( const FetchStmt from)
static

Definition at line 4168 of file copyfuncs.c.

4169 {
4170  FetchStmt *newnode = makeNode(FetchStmt);
4171 
4172  COPY_SCALAR_FIELD(direction);
4173  COPY_SCALAR_FIELD(howMany);
4174  COPY_STRING_FIELD(portalname);
4175  COPY_SCALAR_FIELD(ismove);
4176 
4177  return newnode;
4178 }

References COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyFieldSelect()

static FieldSelect* _copyFieldSelect ( const FieldSelect from)
static

Definition at line 1811 of file copyfuncs.c.

1812 {
1813  FieldSelect *newnode = makeNode(FieldSelect);
1814 
1816  COPY_SCALAR_FIELD(fieldnum);
1817  COPY_SCALAR_FIELD(resulttype);
1818  COPY_SCALAR_FIELD(resulttypmod);
1819  COPY_SCALAR_FIELD(resultcollid);
1820 
1821  return newnode;
1822 }

References arg, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyFieldStore()

static FieldStore* _copyFieldStore ( const FieldStore from)
static

Definition at line 1828 of file copyfuncs.c.

1829 {
1830  FieldStore *newnode = makeNode(FieldStore);
1831 
1833  COPY_NODE_FIELD(newvals);
1834  COPY_NODE_FIELD(fieldnums);
1835  COPY_SCALAR_FIELD(resulttype);
1836 
1837  return newnode;
1838 }

References arg, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyFloat()

static Float* _copyFloat ( const Float from)
static

Definition at line 5492 of file copyfuncs.c.

5493 {
5494  Float *newnode = makeNode(Float);
5495 
5496  COPY_STRING_FIELD(fval);
5497 
5498  return newnode;
5499 }
Definition: value.h:46

References COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyForeignKeyCacheInfo()

static ForeignKeyCacheInfo* _copyForeignKeyCacheInfo ( const ForeignKeyCacheInfo from)
static

Definition at line 5533 of file copyfuncs.c.

5534 {
5536 
5537  COPY_SCALAR_FIELD(conoid);
5538  COPY_SCALAR_FIELD(conrelid);
5539  COPY_SCALAR_FIELD(confrelid);
5540  COPY_SCALAR_FIELD(nkeys);
5541  COPY_ARRAY_FIELD(conkey);
5542  COPY_ARRAY_FIELD(confkey);
5543  COPY_ARRAY_FIELD(conpfeqop);
5544 
5545  return newnode;
5546 }
#define COPY_ARRAY_FIELD(fldname)
Definition: copyfuncs.c:57

References COPY_ARRAY_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyForeignScan()

static ForeignScan* _copyForeignScan ( const ForeignScan from)
static

Definition at line 772 of file copyfuncs.c.

773 {
774  ForeignScan *newnode = makeNode(ForeignScan);
775 
776  /*
777  * copy node superclass fields
778  */
779  CopyScanFields((const Scan *) from, (Scan *) newnode);
780 
781  /*
782  * copy remainder of node
783  */
784  COPY_SCALAR_FIELD(operation);
785  COPY_SCALAR_FIELD(resultRelation);
786  COPY_SCALAR_FIELD(fs_server);
787  COPY_NODE_FIELD(fdw_exprs);
788  COPY_NODE_FIELD(fdw_private);
789  COPY_NODE_FIELD(fdw_scan_tlist);
790  COPY_NODE_FIELD(fdw_recheck_quals);
791  COPY_BITMAPSET_FIELD(fs_relids);
792  COPY_SCALAR_FIELD(fsSystemCol);
793 
794  return newnode;
795 }

References COPY_BITMAPSET_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, CopyScanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyFromExpr()

static FromExpr* _copyFromExpr ( const FromExpr from)
static

Definition at line 2279 of file copyfuncs.c.

2280 {
2281  FromExpr *newnode = makeNode(FromExpr);
2282 
2283  COPY_NODE_FIELD(fromlist);
2284  COPY_NODE_FIELD(quals);
2285 
2286  return newnode;
2287 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyFuncCall()

static FuncCall* _copyFuncCall ( const FuncCall from)
static

Definition at line 3291 of file copyfuncs.c.

3292 {
3293  FuncCall *newnode = makeNode(FuncCall);
3294 
3295  COPY_NODE_FIELD(funcname);
3297  COPY_NODE_FIELD(agg_order);
3298  COPY_NODE_FIELD(agg_filter);
3299  COPY_NODE_FIELD(over);
3300  COPY_SCALAR_FIELD(agg_within_group);
3301  COPY_SCALAR_FIELD(agg_star);
3302  COPY_SCALAR_FIELD(agg_distinct);
3303  COPY_SCALAR_FIELD(func_variadic);
3304  COPY_SCALAR_FIELD(funcformat);
3305  COPY_LOCATION_FIELD(location);
3306 
3307  return newnode;
3308 }

References generate_unaccent_rules::args, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyFuncExpr()

static FuncExpr* _copyFuncExpr ( const FuncExpr from)
static

Definition at line 1620 of file copyfuncs.c.

1621 {
1622  FuncExpr *newnode = makeNode(FuncExpr);
1623 
1624  COPY_SCALAR_FIELD(funcid);
1625  COPY_SCALAR_FIELD(funcresulttype);
1626  COPY_SCALAR_FIELD(funcretset);
1627  COPY_SCALAR_FIELD(funcvariadic);
1628  COPY_SCALAR_FIELD(funcformat);
1629  COPY_SCALAR_FIELD(funccollid);
1630  COPY_SCALAR_FIELD(inputcollid);
1632  COPY_LOCATION_FIELD(location);
1633 
1634  return newnode;
1635 }

References generate_unaccent_rules::args, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyFunctionParameter()

static FunctionParameter* _copyFunctionParameter ( const FunctionParameter from)
static

Definition at line 4258 of file copyfuncs.c.

4259 {
4261 
4263  COPY_NODE_FIELD(argType);
4265  COPY_NODE_FIELD(defexpr);
4266 
4267  return newnode;
4268 }
static PgChecksumMode mode
Definition: pg_checksums.c:65

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, makeNode, mode, and name.

Referenced by copyObjectImpl().

◆ _copyFunctionScan()

static FunctionScan* _copyFunctionScan ( const FunctionScan from)
static

Definition at line 644 of file copyfuncs.c.

645 {
646  FunctionScan *newnode = makeNode(FunctionScan);
647 
648  /*
649  * copy node superclass fields
650  */
651  CopyScanFields((const Scan *) from, (Scan *) newnode);
652 
653  /*
654  * copy remainder of node
655  */
657  COPY_SCALAR_FIELD(funcordinality);
658 
659  return newnode;
660 }
static const struct fns functions
Definition: regcomp.c:313

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, CopyScanFields(), functions, and makeNode.

Referenced by copyObjectImpl().

◆ _copyGather()

static Gather* _copyGather ( const Gather from)
static

Definition at line 362 of file copyfuncs.c.

363 {
364  Gather *newnode = makeNode(Gather);
365 
366  /*
367  * copy node superclass fields
368  */
369  CopyPlanFields((const Plan *) from, (Plan *) newnode);
370 
371  /*
372  * copy remainder of node
373  */
374  COPY_SCALAR_FIELD(num_workers);
375  COPY_SCALAR_FIELD(rescan_param);
376  COPY_SCALAR_FIELD(single_copy);
377  COPY_SCALAR_FIELD(invisible);
378  COPY_BITMAPSET_FIELD(initParam);
379 
380  return newnode;
381 }

References COPY_BITMAPSET_FIELD, COPY_SCALAR_FIELD, CopyPlanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyGatherMerge()

static GatherMerge* _copyGatherMerge ( const GatherMerge from)
static

Definition at line 387 of file copyfuncs.c.

388 {
389  GatherMerge *newnode = makeNode(GatherMerge);
390 
391  /*
392  * copy node superclass fields
393  */
394  CopyPlanFields((const Plan *) from, (Plan *) newnode);
395 
396  /*
397  * copy remainder of node
398  */
399  COPY_SCALAR_FIELD(num_workers);
400  COPY_SCALAR_FIELD(rescan_param);
401  COPY_SCALAR_FIELD(numCols);
402  COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
403  COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid));
404  COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid));
405  COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool));
406  COPY_BITMAPSET_FIELD(initParam);
407 
408  return newnode;
409 }

References COPY_BITMAPSET_FIELD, COPY_POINTER_FIELD, COPY_SCALAR_FIELD, CopyPlanFields(), makeNode, and GatherMerge::numCols.

Referenced by copyObjectImpl().

◆ _copyGrantRoleStmt()

static GrantRoleStmt* _copyGrantRoleStmt ( const GrantRoleStmt from)
static

Definition at line 3967 of file copyfuncs.c.

3968 {
3969  GrantRoleStmt *newnode = makeNode(GrantRoleStmt);
3970 
3971  COPY_NODE_FIELD(granted_roles);
3972  COPY_NODE_FIELD(grantee_roles);
3973  COPY_SCALAR_FIELD(is_grant);
3974  COPY_SCALAR_FIELD(admin_opt);
3975  COPY_NODE_FIELD(grantor);
3976  COPY_SCALAR_FIELD(behavior);
3977 
3978  return newnode;
3979 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyGrantStmt()

static GrantStmt* _copyGrantStmt ( const GrantStmt from)
static

Definition at line 3925 of file copyfuncs.c.

3926 {
3927  GrantStmt *newnode = makeNode(GrantStmt);
3928 
3929  COPY_SCALAR_FIELD(is_grant);
3930  COPY_SCALAR_FIELD(targtype);
3931  COPY_SCALAR_FIELD(objtype);
3932  COPY_NODE_FIELD(objects);
3933  COPY_NODE_FIELD(privileges);
3934  COPY_NODE_FIELD(grantees);
3935  COPY_SCALAR_FIELD(grant_option);
3936  COPY_NODE_FIELD(grantor);
3937  COPY_SCALAR_FIELD(behavior);
3938 
3939  return newnode;
3940 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyGroup()

static Group* _copyGroup ( const Group from)
static

Definition at line 1046 of file copyfuncs.c.

1047 {
1048  Group *newnode = makeNode(Group);
1049 
1050  CopyPlanFields((const Plan *) from, (Plan *) newnode);
1051 
1052  COPY_SCALAR_FIELD(numCols);
1053  COPY_POINTER_FIELD(grpColIdx, from->numCols * sizeof(AttrNumber));
1054  COPY_POINTER_FIELD(grpOperators, from->numCols * sizeof(Oid));
1055  COPY_POINTER_FIELD(grpCollations, from->numCols * sizeof(Oid));
1056 
1057  return newnode;
1058 }

References COPY_POINTER_FIELD, COPY_SCALAR_FIELD, CopyPlanFields(), makeNode, and Group::numCols.

Referenced by copyObjectImpl().

◆ _copyGroupingFunc()

static GroupingFunc* _copyGroupingFunc ( const GroupingFunc from)
static

Definition at line 1560 of file copyfuncs.c.

1561 {
1562  GroupingFunc *newnode = makeNode(GroupingFunc);
1563 
1565  COPY_NODE_FIELD(refs);
1566  COPY_NODE_FIELD(cols);
1567  COPY_SCALAR_FIELD(agglevelsup);
1568  COPY_LOCATION_FIELD(location);
1569 
1570  return newnode;
1571 }

References generate_unaccent_rules::args, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyGroupingSet()

static GroupingSet* _copyGroupingSet ( const GroupingSet from)
static

Definition at line 3045 of file copyfuncs.c.

3046 {
3047  GroupingSet *newnode = makeNode(GroupingSet);
3048 
3049  COPY_SCALAR_FIELD(kind);
3050  COPY_NODE_FIELD(content);
3051  COPY_LOCATION_FIELD(location);
3052 
3053  return newnode;
3054 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyHash()

static Hash* _copyHash ( const Hash from)
static

Definition at line 1147 of file copyfuncs.c.

1148 {
1149  Hash *newnode = makeNode(Hash);
1150 
1151  /*
1152  * copy node superclass fields
1153  */
1154  CopyPlanFields((const Plan *) from, (Plan *) newnode);
1155 
1156  /*
1157  * copy remainder of node
1158  */
1159  COPY_NODE_FIELD(hashkeys);
1160  COPY_SCALAR_FIELD(skewTable);
1161  COPY_SCALAR_FIELD(skewColumn);
1162  COPY_SCALAR_FIELD(skewInherit);
1163  COPY_SCALAR_FIELD(rows_total);
1164 
1165  return newnode;
1166 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, CopyPlanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyHashJoin()

static HashJoin* _copyHashJoin ( const HashJoin from)
static

Definition at line 918 of file copyfuncs.c.

919 {
920  HashJoin *newnode = makeNode(HashJoin);
921 
922  /*
923  * copy node superclass fields
924  */
925  CopyJoinFields((const Join *) from, (Join *) newnode);
926 
927  /*
928  * copy remainder of node
929  */
930  COPY_NODE_FIELD(hashclauses);
931  COPY_NODE_FIELD(hashoperators);
932  COPY_NODE_FIELD(hashcollations);
933  COPY_NODE_FIELD(hashkeys);
934 
935  return newnode;
936 }
static void CopyJoinFields(const Join *from, Join *newnode)
Definition: copyfuncs.c:837

References COPY_NODE_FIELD, CopyJoinFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyImportForeignSchemaStmt()

static ImportForeignSchemaStmt* _copyImportForeignSchemaStmt ( const ImportForeignSchemaStmt from)
static

Definition at line 4959 of file copyfuncs.c.

4960 {
4962 
4963  COPY_STRING_FIELD(server_name);
4964  COPY_STRING_FIELD(remote_schema);
4965  COPY_STRING_FIELD(local_schema);
4966  COPY_SCALAR_FIELD(list_type);
4967  COPY_NODE_FIELD(table_list);
4969 
4970  return newnode;
4971 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyIncrementalSort()

static IncrementalSort* _copyIncrementalSort ( const IncrementalSort from)
static

Definition at line 1024 of file copyfuncs.c.

1025 {
1027 
1028  /*
1029  * copy node superclass fields
1030  */
1031  CopySortFields((const Sort *) from, (Sort *) newnode);
1032 
1033  /*
1034  * copy remainder of node
1035  */
1036  COPY_SCALAR_FIELD(nPresortedCols);
1037 
1038  return newnode;
1039 }
static void CopySortFields(const Sort *from, Sort *newnode)
Definition: copyfuncs.c:992

References COPY_SCALAR_FIELD, CopySortFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyIndexElem()

static IndexElem* _copyIndexElem ( const IndexElem from)
static

Definition at line 3523 of file copyfuncs.c.

3524 {
3525  IndexElem *newnode = makeNode(IndexElem);
3526 
3528  COPY_NODE_FIELD(expr);
3529  COPY_STRING_FIELD(indexcolname);
3530  COPY_NODE_FIELD(collation);
3531  COPY_NODE_FIELD(opclass);
3532  COPY_NODE_FIELD(opclassopts);
3533  COPY_SCALAR_FIELD(ordering);
3534  COPY_SCALAR_FIELD(nulls_ordering);
3535 
3536  return newnode;
3537 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, makeNode, and name.

Referenced by copyObjectImpl().

◆ _copyIndexOnlyScan()

static IndexOnlyScan* _copyIndexOnlyScan ( const IndexOnlyScan from)
static

Definition at line 509 of file copyfuncs.c.

510 {
512 
513  /*
514  * copy node superclass fields
515  */
516  CopyScanFields((const Scan *) from, (Scan *) newnode);
517 
518  /*
519  * copy remainder of node
520  */
521  COPY_SCALAR_FIELD(indexid);
522  COPY_NODE_FIELD(indexqual);
523  COPY_NODE_FIELD(recheckqual);
524  COPY_NODE_FIELD(indexorderby);
525  COPY_NODE_FIELD(indextlist);
526  COPY_SCALAR_FIELD(indexorderdir);
527 
528  return newnode;
529 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, CopyScanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyIndexScan()

static IndexScan* _copyIndexScan ( const IndexScan from)
static

Definition at line 482 of file copyfuncs.c.

483 {
484  IndexScan *newnode = makeNode(IndexScan);
485 
486  /*
487  * copy node superclass fields
488  */
489  CopyScanFields((const Scan *) from, (Scan *) newnode);
490 
491  /*
492  * copy remainder of node
493  */
494  COPY_SCALAR_FIELD(indexid);
495  COPY_NODE_FIELD(indexqual);
496  COPY_NODE_FIELD(indexqualorig);
497  COPY_NODE_FIELD(indexorderby);
498  COPY_NODE_FIELD(indexorderbyorig);
499  COPY_NODE_FIELD(indexorderbyops);
500  COPY_SCALAR_FIELD(indexorderdir);
501 
502  return newnode;
503 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, CopyScanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyIndexStmt()

static IndexStmt* _copyIndexStmt ( const IndexStmt from)
static

Definition at line 4181 of file copyfuncs.c.

4182 {
4183  IndexStmt *newnode = makeNode(IndexStmt);
4184 
4185  COPY_STRING_FIELD(idxname);
4186  COPY_NODE_FIELD(relation);
4187  COPY_STRING_FIELD(accessMethod);
4188  COPY_STRING_FIELD(tableSpace);
4189  COPY_NODE_FIELD(indexParams);
4190  COPY_NODE_FIELD(indexIncludingParams);
4192  COPY_NODE_FIELD(whereClause);
4193  COPY_NODE_FIELD(excludeOpNames);
4194  COPY_STRING_FIELD(idxcomment);
4195  COPY_SCALAR_FIELD(indexOid);
4196  COPY_SCALAR_FIELD(oldNode);
4197  COPY_SCALAR_FIELD(oldCreateSubid);
4198  COPY_SCALAR_FIELD(oldFirstRelfilenodeSubid);
4199  COPY_SCALAR_FIELD(unique);
4200  COPY_SCALAR_FIELD(nulls_not_distinct);
4201  COPY_SCALAR_FIELD(primary);
4202  COPY_SCALAR_FIELD(isconstraint);
4203  COPY_SCALAR_FIELD(deferrable);
4204  COPY_SCALAR_FIELD(initdeferred);
4205  COPY_SCALAR_FIELD(transformed);
4206  COPY_SCALAR_FIELD(concurrent);
4207  COPY_SCALAR_FIELD(if_not_exists);
4208  COPY_SCALAR_FIELD(reset_default_tblspc);
4209 
4210  return newnode;
4211 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyInferClause()

static InferClause* _copyInferClause ( const InferClause from)
static

Definition at line 3106 of file copyfuncs.c.

3107 {
3108  InferClause *newnode = makeNode(InferClause);
3109 
3110  COPY_NODE_FIELD(indexElems);
3111  COPY_NODE_FIELD(whereClause);
3112  COPY_STRING_FIELD(conname);
3113  COPY_LOCATION_FIELD(location);
3114 
3115  return newnode;
3116 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyInferenceElem()

static InferenceElem* _copyInferenceElem ( const InferenceElem from)
static

Definition at line 2211 of file copyfuncs.c.

2212 {
2213  InferenceElem *newnode = makeNode(InferenceElem);
2214 
2215  COPY_NODE_FIELD(expr);
2216  COPY_SCALAR_FIELD(infercollid);
2217  COPY_SCALAR_FIELD(inferopclass);
2218 
2219  return newnode;
2220 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyInsertStmt()

static InsertStmt* _copyInsertStmt ( const InsertStmt from)
static

Definition at line 3742 of file copyfuncs.c.

3743 {
3744  InsertStmt *newnode = makeNode(InsertStmt);
3745 
3746  COPY_NODE_FIELD(relation);
3747  COPY_NODE_FIELD(cols);
3748  COPY_NODE_FIELD(selectStmt);
3749  COPY_NODE_FIELD(onConflictClause);
3750  COPY_NODE_FIELD(returningList);
3751  COPY_NODE_FIELD(withClause);
3752  COPY_SCALAR_FIELD(override);
3753 
3754  return newnode;
3755 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyInteger()

static Integer* _copyInteger ( const Integer from)
static

Definition at line 5482 of file copyfuncs.c.

5483 {
5484  Integer *newnode = makeNode(Integer);
5485 
5486  COPY_SCALAR_FIELD(ival);
5487 
5488  return newnode;
5489 }
Definition: value.h:29

References COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyIntoClause()

static IntoClause* _copyIntoClause ( const IntoClause from)
static

Definition at line 1425 of file copyfuncs.c.

1426 {
1427  IntoClause *newnode = makeNode(IntoClause);
1428 
1429  COPY_NODE_FIELD(rel);
1430  COPY_NODE_FIELD(colNames);
1431  COPY_STRING_FIELD(accessMethod);
1433  COPY_SCALAR_FIELD(onCommit);
1434  COPY_STRING_FIELD(tableSpaceName);
1435  COPY_NODE_FIELD(viewQuery);
1436  COPY_SCALAR_FIELD(skipData);
1437 
1438  return newnode;
1439 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyJoin()

static Join* _copyJoin ( const Join from)
static

Definition at line 851 of file copyfuncs.c.

852 {
853  Join *newnode = makeNode(Join);
854 
855  /*
856  * copy node superclass fields
857  */
858  CopyJoinFields(from, newnode);
859 
860  return newnode;
861 }

References CopyJoinFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyJoinExpr()

static JoinExpr* _copyJoinExpr ( const JoinExpr from)
static

Definition at line 2258 of file copyfuncs.c.

2259 {
2260  JoinExpr *newnode = makeNode(JoinExpr);
2261 
2262  COPY_SCALAR_FIELD(jointype);
2263  COPY_SCALAR_FIELD(isNatural);
2264  COPY_NODE_FIELD(larg);
2265  COPY_NODE_FIELD(rarg);
2266  COPY_NODE_FIELD(usingClause);
2267  COPY_NODE_FIELD(join_using_alias);
2268  COPY_NODE_FIELD(quals);
2269  COPY_NODE_FIELD(alias);
2270  COPY_SCALAR_FIELD(rtindex);
2271 
2272  return newnode;
2273 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyJsonAggConstructor()

static JsonAggConstructor* _copyJsonAggConstructor ( const JsonAggConstructor from)
static

Definition at line 2456 of file copyfuncs.c.

2457 {
2459 
2461  COPY_NODE_FIELD(agg_filter);
2462  COPY_NODE_FIELD(agg_order);
2463  COPY_NODE_FIELD(over);
2464  COPY_LOCATION_FIELD(location);
2465 
2466  return newnode;
2467 }
static void output(uint64 loop_count)

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, makeNode, and output().

Referenced by copyObjectImpl().

◆ _copyJsonArgument()

static JsonArgument* _copyJsonArgument ( const JsonArgument from)
static

Definition at line 2683 of file copyfuncs.c.

2684 {
2685  JsonArgument *newnode = makeNode(JsonArgument);
2686 
2689 
2690  return newnode;
2691 }

References COPY_NODE_FIELD, COPY_STRING_FIELD, makeNode, name, and val.

Referenced by copyObjectImpl().

◆ _copyJsonArrayAgg()

static JsonArrayAgg* _copyJsonArrayAgg ( const JsonArrayAgg from)
static

Definition at line 2519 of file copyfuncs.c.

2520 {
2521  JsonArrayAgg *newnode = makeNode(JsonArrayAgg);
2522 
2523  COPY_NODE_FIELD(constructor);
2525  COPY_SCALAR_FIELD(absent_on_null);
2526 
2527  return newnode;
2528 }

References arg, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyJsonArrayConstructor()

static JsonArrayConstructor* _copyJsonArrayConstructor ( const JsonArrayConstructor from)
static

Definition at line 2503 of file copyfuncs.c.

2504 {
2506 
2507  COPY_NODE_FIELD(exprs);
2509  COPY_SCALAR_FIELD(absent_on_null);
2510  COPY_LOCATION_FIELD(location);
2511 
2512  return newnode;
2513 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, makeNode, and output().

Referenced by copyObjectImpl().

◆ _copyJsonArrayQueryConstructor()

static JsonArrayQueryConstructor* _copyJsonArrayQueryConstructor ( const JsonArrayQueryConstructor from)
static

Definition at line 2534 of file copyfuncs.c.

2535 {
2537 
2538  COPY_NODE_FIELD(query);
2541  COPY_SCALAR_FIELD(absent_on_null);
2542  COPY_LOCATION_FIELD(location);
2543 
2544  return newnode;
2545 }
static char format

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, format, makeNode, and output().

Referenced by copyObjectImpl().

◆ _copyJsonBehavior()

static JsonBehavior* _copyJsonBehavior ( const JsonBehavior from)
static

Definition at line 2652 of file copyfuncs.c.

2653 {
2654  JsonBehavior *newnode = makeNode(JsonBehavior);
2655 
2656  COPY_SCALAR_FIELD(btype);
2657  COPY_NODE_FIELD(default_expr);
2658 
2659  return newnode;
2660 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyJsonCoercion()

static JsonCoercion* _copyJsonCoercion ( const JsonCoercion from)
static

Definition at line 2577 of file copyfuncs.c.

2578 {
2579  JsonCoercion *newnode = makeNode(JsonCoercion);
2580 
2581  COPY_NODE_FIELD(expr);
2582  COPY_SCALAR_FIELD(via_populate);
2583  COPY_SCALAR_FIELD(via_io);
2584  COPY_SCALAR_FIELD(collation);
2585 
2586  return newnode;
2587 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyJsonCommon()

static JsonCommon* _copyJsonCommon ( const JsonCommon from)
static

Definition at line 2666 of file copyfuncs.c.

2667 {
2668  JsonCommon *newnode = makeNode(JsonCommon);
2669 
2670  COPY_NODE_FIELD(expr);
2671  COPY_NODE_FIELD(pathspec);
2672  COPY_STRING_FIELD(pathname);
2673  COPY_NODE_FIELD(passing);
2674  COPY_LOCATION_FIELD(location);
2675 
2676  return newnode;
2677 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyJsonConstructorExpr()

static JsonConstructorExpr* _copyJsonConstructorExpr ( const JsonConstructorExpr from)
static

Definition at line 2405 of file copyfuncs.c.

2406 {
2408 
2411  COPY_NODE_FIELD(func);
2412  COPY_NODE_FIELD(coercion);
2413  COPY_NODE_FIELD(returning);
2414  COPY_SCALAR_FIELD(absent_on_null);
2415  COPY_SCALAR_FIELD(unique);
2416  COPY_LOCATION_FIELD(location);
2417 
2418  return newnode;
2419 }

References generate_unaccent_rules::args, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, makeNode, and generate_unaccent_rules::type.

Referenced by copyObjectImpl().

◆ _copyJsonExpr()

static JsonExpr* _copyJsonExpr ( const JsonExpr from)
static

Definition at line 2551 of file copyfuncs.c.

2552 {
2553  JsonExpr *newnode = makeNode(JsonExpr);
2554 
2555  COPY_SCALAR_FIELD(op);
2556  COPY_NODE_FIELD(formatted_expr);
2557  COPY_NODE_FIELD(result_coercion);
2559  COPY_NODE_FIELD(path_spec);
2560  COPY_NODE_FIELD(passing_names);
2561  COPY_NODE_FIELD(passing_values);
2562  COPY_NODE_FIELD(returning);
2563  COPY_NODE_FIELD(on_empty);
2564  COPY_NODE_FIELD(on_error);
2565  COPY_NODE_FIELD(coercions);
2566  COPY_SCALAR_FIELD(wrapper);
2567  COPY_SCALAR_FIELD(omit_quotes);
2568  COPY_LOCATION_FIELD(location);
2569 
2570  return newnode;
2571 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, format, and makeNode.

Referenced by copyObjectImpl().

◆ _copyJsonFormat()

static JsonFormat* _copyJsonFormat ( const JsonFormat from)
static

Definition at line 2314 of file copyfuncs.c.

2315 {
2316  JsonFormat *newnode = makeNode(JsonFormat);
2317 
2320  COPY_LOCATION_FIELD(location);
2321 
2322  return newnode;
2323 }
Datum format_type(PG_FUNCTION_ARGS)
Definition: format_type.c:60
int32 encoding
Definition: pg_database.h:41

References COPY_LOCATION_FIELD, COPY_SCALAR_FIELD, encoding, format_type(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyJsonFuncExpr()

static JsonFuncExpr* _copyJsonFuncExpr ( const JsonFuncExpr from)
static

Definition at line 2615 of file copyfuncs.c.

2616 {
2617  JsonFuncExpr *newnode = makeNode(JsonFuncExpr);
2618 
2619  COPY_SCALAR_FIELD(op);
2620  COPY_NODE_FIELD(common);
2622  COPY_NODE_FIELD(on_empty);
2623  COPY_NODE_FIELD(on_error);
2624  COPY_SCALAR_FIELD(wrapper);
2625  COPY_SCALAR_FIELD(omit_quotes);
2626  COPY_LOCATION_FIELD(location);
2627 
2628  return newnode;
2629 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, makeNode, and output().

Referenced by copyObjectImpl().

◆ _copyJsonIsPredicate()

static JsonIsPredicate* _copyJsonIsPredicate ( const JsonIsPredicate from)
static

Definition at line 2635 of file copyfuncs.c.

2636 {
2638 
2639  COPY_NODE_FIELD(expr);
2641  COPY_SCALAR_FIELD(item_type);
2642  COPY_SCALAR_FIELD(unique_keys);
2643  COPY_LOCATION_FIELD(location);
2644 
2645  return newnode;
2646 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, format, and makeNode.

Referenced by copyObjectImpl().

◆ _copyJsonItemCoercions()

static JsonItemCoercions* _copyJsonItemCoercions ( const JsonItemCoercions from)
static

Definition at line 2593 of file copyfuncs.c.

2594 {
2596 
2597  COPY_NODE_FIELD(null);
2598  COPY_NODE_FIELD(string);
2600  COPY_NODE_FIELD(boolean);
2602  COPY_NODE_FIELD(time);
2603  COPY_NODE_FIELD(timetz);
2605  COPY_NODE_FIELD(timestamptz);
2606  COPY_NODE_FIELD(composite);
2607 
2608  return newnode;
2609 }
long date
Definition: pgtypes_date.h:9
int64 timestamp

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyJsonKeyValue()

static JsonKeyValue* _copyJsonKeyValue ( const JsonKeyValue from)
static

Definition at line 2425 of file copyfuncs.c.

2426 {
2427  JsonKeyValue *newnode = makeNode(JsonKeyValue);
2428 
2431 
2432  return newnode;
2433 }
static struct @151 value

References COPY_NODE_FIELD, sort-test::key, makeNode, and value.

Referenced by copyObjectImpl().

◆ _copyJsonObjectAgg()

static JsonObjectAgg* _copyJsonObjectAgg ( const JsonObjectAgg from)
static

Definition at line 2473 of file copyfuncs.c.

2474 {
2475  JsonObjectAgg *newnode = makeNode(JsonObjectAgg);
2476 
2477  COPY_NODE_FIELD(constructor);
2479  COPY_SCALAR_FIELD(absent_on_null);
2480  COPY_SCALAR_FIELD(unique);
2481 
2482  return newnode;
2483 }

References arg, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyJsonObjectConstructor()

static JsonObjectConstructor* _copyJsonObjectConstructor ( const JsonObjectConstructor from)
static

Definition at line 2439 of file copyfuncs.c.

2440 {
2442 
2443  COPY_NODE_FIELD(exprs);
2445  COPY_SCALAR_FIELD(absent_on_null);
2446  COPY_SCALAR_FIELD(unique);
2447  COPY_LOCATION_FIELD(location);
2448 
2449  return newnode;
2450 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, makeNode, and output().

Referenced by copyObjectImpl().

◆ _copyJsonOutput()

static JsonOutput* _copyJsonOutput ( const JsonOutput from)
static

Definition at line 2489 of file copyfuncs.c.

2490 {
2491  JsonOutput *newnode = makeNode(JsonOutput);
2492 
2493  COPY_NODE_FIELD(typeName);
2494  COPY_NODE_FIELD(returning);
2495 
2496  return newnode;
2497 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyJsonParseExpr()

static JsonParseExpr* _copyJsonParseExpr ( const JsonParseExpr from)
static

Definition at line 2359 of file copyfuncs.c.

2360 {
2361  JsonParseExpr *newnode = makeNode(JsonParseExpr);
2362 
2363  COPY_NODE_FIELD(expr);
2365  COPY_SCALAR_FIELD(unique_keys);
2366  COPY_LOCATION_FIELD(location);
2367 
2368  return newnode;
2369 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, makeNode, and output().

Referenced by copyObjectImpl().

◆ _copyJsonReturning()

static JsonReturning* _copyJsonReturning ( const JsonReturning from)
static

Definition at line 2329 of file copyfuncs.c.

2330 {
2331  JsonReturning *newnode = makeNode(JsonReturning);
2332 
2334  COPY_SCALAR_FIELD(typid);
2335  COPY_SCALAR_FIELD(typmod);
2336 
2337  return newnode;
2338 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, format, and makeNode.

Referenced by copyObjectImpl().

◆ _copyJsonScalarExpr()

static JsonScalarExpr* _copyJsonScalarExpr ( const JsonScalarExpr from)
static

Definition at line 2375 of file copyfuncs.c.

2376 {
2378 
2379  COPY_NODE_FIELD(expr);
2381  COPY_LOCATION_FIELD(location);
2382 
2383  return newnode;
2384 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, makeNode, and output().

Referenced by copyObjectImpl().

◆ _copyJsonSerializeExpr()

static JsonSerializeExpr* _copyJsonSerializeExpr ( const JsonSerializeExpr from)
static

Definition at line 2390 of file copyfuncs.c.

2391 {
2393 
2394  COPY_NODE_FIELD(expr);
2396  COPY_LOCATION_FIELD(location);
2397 
2398  return newnode;
2399 }

References COPY_LOCATION_FIELD, COPY_NODE_FIELD, makeNode, and output().

Referenced by copyObjectImpl().

◆ _copyJsonTable()

static JsonTable* _copyJsonTable ( const JsonTable from)
static

Definition at line 2697 of file copyfuncs.c.

2698 {
2699  JsonTable *newnode = makeNode(JsonTable);
2700 
2701  COPY_NODE_FIELD(common);
2702  COPY_NODE_FIELD(columns);
2703  COPY_NODE_FIELD(plan);
2704  COPY_NODE_FIELD(on_error);
2705  COPY_NODE_FIELD(alias);
2706  COPY_SCALAR_FIELD(location);
2707 
2708  return newnode;
2709 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyJsonTableColumn()

static JsonTableColumn* _copyJsonTableColumn ( const JsonTableColumn from)
static

Definition at line 2715 of file copyfuncs.c.

2716 {
2718 
2719  COPY_SCALAR_FIELD(coltype);
2721  COPY_NODE_FIELD(typeName);
2722  COPY_STRING_FIELD(pathspec);
2723  COPY_STRING_FIELD(pathname);
2725  COPY_SCALAR_FIELD(wrapper);
2726  COPY_SCALAR_FIELD(omit_quotes);
2727  COPY_NODE_FIELD(columns);
2728  COPY_NODE_FIELD(on_empty);
2729  COPY_NODE_FIELD(on_error);
2730  COPY_SCALAR_FIELD(location);
2731 
2732  return newnode;
2733 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, format, makeNode, and name.

Referenced by copyObjectImpl().

◆ _copyJsonTableParent()

static JsonTableParent* _copyJsonTableParent ( const JsonTableParent from)
static

Definition at line 2757 of file copyfuncs.c.

2758 {
2760 
2761  COPY_NODE_FIELD(path);
2763  COPY_NODE_FIELD(child);
2764  COPY_SCALAR_FIELD(outerJoin);
2765  COPY_SCALAR_FIELD(colMin);
2766  COPY_SCALAR_FIELD(colMax);
2767  COPY_SCALAR_FIELD(errorOnError);
2768 
2769  return newnode;
2770 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, makeNode, and name.

Referenced by copyObjectImpl().

◆ _copyJsonTablePlan()

static JsonTablePlan* _copyJsonTablePlan ( const JsonTablePlan from)
static

Definition at line 2739 of file copyfuncs.c.

2740 {
2741  JsonTablePlan *newnode = makeNode(JsonTablePlan);
2742 
2743  COPY_SCALAR_FIELD(plan_type);
2744  COPY_SCALAR_FIELD(join_type);
2745  COPY_STRING_FIELD(pathname);
2746  COPY_NODE_FIELD(plan1);
2747  COPY_NODE_FIELD(plan2);
2748  COPY_SCALAR_FIELD(location);
2749 
2750  return newnode;
2751 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyJsonTableSibling()

static JsonTableSibling* _copyJsonTableSibling ( const JsonTableSibling from)
static

Definition at line 2776 of file copyfuncs.c.

2777 {
2779 
2780  COPY_NODE_FIELD(larg);
2781  COPY_NODE_FIELD(rarg);
2782  COPY_SCALAR_FIELD(cross);
2783 
2784  return newnode;
2785 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyJsonValueExpr()

static JsonValueExpr* _copyJsonValueExpr ( const JsonValueExpr from)
static

Definition at line 2344 of file copyfuncs.c.

2345 {
2346  JsonValueExpr *newnode = makeNode(JsonValueExpr);
2347 
2348  COPY_NODE_FIELD(raw_expr);
2349  COPY_NODE_FIELD(formatted_expr);
2351 
2352  return newnode;
2353 }

References COPY_NODE_FIELD, format, and makeNode.

Referenced by copyObjectImpl().

◆ _copyLimit()

static Limit* _copyLimit ( const Limit from)
static

Definition at line 1223 of file copyfuncs.c.

1224 {
1225  Limit *newnode = makeNode(Limit);
1226 
1227  /*
1228  * copy node superclass fields
1229  */
1230  CopyPlanFields((const Plan *) from, (Plan *) newnode);
1231 
1232  /*
1233  * copy remainder of node
1234  */
1235  COPY_NODE_FIELD(limitOffset);
1236  COPY_NODE_FIELD(limitCount);
1237  COPY_SCALAR_FIELD(limitOption);
1238  COPY_SCALAR_FIELD(uniqNumCols);
1239  COPY_POINTER_FIELD(uniqColIdx, from->uniqNumCols * sizeof(AttrNumber));
1240  COPY_POINTER_FIELD(uniqOperators, from->uniqNumCols * sizeof(Oid));
1241  COPY_POINTER_FIELD(uniqCollations, from->uniqNumCols * sizeof(Oid));
1242 
1243  return newnode;
1244 }

References COPY_NODE_FIELD, COPY_POINTER_FIELD, COPY_SCALAR_FIELD, CopyPlanFields(), makeNode, and Limit::uniqNumCols.

Referenced by copyObjectImpl().

◆ _copyListenStmt()

static ListenStmt* _copyListenStmt ( const ListenStmt from)
static

Definition at line 4400 of file copyfuncs.c.

4401 {
4402  ListenStmt *newnode = makeNode(ListenStmt);
4403 
4404  COPY_STRING_FIELD(conditionname);
4405 
4406  return newnode;
4407 }

References COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyLoadStmt()

static LoadStmt* _copyLoadStmt ( const LoadStmt from)
static

Definition at line 4497 of file copyfuncs.c.

4498 {
4499  LoadStmt *newnode = makeNode(LoadStmt);
4500 
4502 
4503  return newnode;
4504 }

References COPY_STRING_FIELD, filename, and makeNode.

Referenced by copyObjectImpl().

◆ _copyLockingClause()

static LockingClause* _copyLockingClause ( const LockingClause from)
static

Definition at line 3631 of file copyfuncs.c.

3632 {
3633  LockingClause *newnode = makeNode(LockingClause);
3634 
3635  COPY_NODE_FIELD(lockedRels);
3636  COPY_SCALAR_FIELD(strength);
3637  COPY_SCALAR_FIELD(waitPolicy);
3638 
3639  return newnode;
3640 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyLockRows()

static LockRows* _copyLockRows ( const LockRows from)
static

Definition at line 1201 of file copyfuncs.c.

1202 {
1203  LockRows *newnode = makeNode(LockRows);
1204 
1205  /*
1206  * copy node superclass fields
1207  */
1208  CopyPlanFields((const Plan *) from, (Plan *) newnode);
1209 
1210  /*
1211  * copy remainder of node
1212  */
1213  COPY_NODE_FIELD(rowMarks);
1214  COPY_SCALAR_FIELD(epqParam);
1215 
1216  return newnode;
1217 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, CopyPlanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyLockStmt()

static LockStmt* _copyLockStmt ( const LockStmt from)
static

Definition at line 5110 of file copyfuncs.c.

5111 {
5112  LockStmt *newnode = makeNode(LockStmt);
5113 
5114  COPY_NODE_FIELD(relations);
5116  COPY_SCALAR_FIELD(nowait);
5117 
5118  return newnode;
5119 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, makeNode, and mode.

Referenced by copyObjectImpl().

◆ _copyMaterial()

static Material* _copyMaterial ( const Material from)
static

Definition at line 943 of file copyfuncs.c.

944 {
945  Material *newnode = makeNode(Material);
946 
947  /*
948  * copy node superclass fields
949  */
950  CopyPlanFields((const Plan *) from, (Plan *) newnode);
951 
952  return newnode;
953 }

References CopyPlanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyMemoize()

static Memoize* _copyMemoize ( const Memoize from)
static

Definition at line 960 of file copyfuncs.c.

961 {
962  Memoize *newnode = makeNode(Memoize);
963 
964  /*
965  * copy node superclass fields
966  */
967  CopyPlanFields((const Plan *) from, (Plan *) newnode);
968 
969  /*
970  * copy remainder of node
971  */
972  COPY_SCALAR_FIELD(numKeys);
973  COPY_POINTER_FIELD(hashOperators, sizeof(Oid) * from->numKeys);
974  COPY_POINTER_FIELD(collations, sizeof(Oid) * from->numKeys);
975  COPY_NODE_FIELD(param_exprs);
976  COPY_SCALAR_FIELD(singlerow);
977  COPY_SCALAR_FIELD(binary_mode);
978  COPY_SCALAR_FIELD(est_entries);
979  COPY_BITMAPSET_FIELD(keyparamids);
980 
981  return newnode;
982 }

References COPY_BITMAPSET_FIELD, COPY_NODE_FIELD, COPY_POINTER_FIELD, COPY_SCALAR_FIELD, CopyPlanFields(), makeNode, and Memoize::numKeys.

Referenced by copyObjectImpl().

◆ _copyMergeAction()

static MergeAction* _copyMergeAction ( const MergeAction from)
static

Definition at line 3201 of file copyfuncs.c.

3202 {
3203  MergeAction *newnode = makeNode(MergeAction);
3204 
3205  COPY_SCALAR_FIELD(matched);
3206  COPY_SCALAR_FIELD(commandType);
3207  COPY_SCALAR_FIELD(override);
3208  COPY_NODE_FIELD(qual);
3209  COPY_NODE_FIELD(targetList);
3210  COPY_NODE_FIELD(updateColnos);
3211 
3212  return newnode;
3213 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyMergeAppend()

static MergeAppend* _copyMergeAppend ( const MergeAppend from)
static

Definition at line 265 of file copyfuncs.c.

266 {
267  MergeAppend *newnode = makeNode(MergeAppend);
268 
269  /*
270  * copy node superclass fields
271  */
272  CopyPlanFields((const Plan *) from, (Plan *) newnode);
273 
274  /*
275  * copy remainder of node
276  */
277  COPY_BITMAPSET_FIELD(apprelids);
278  COPY_NODE_FIELD(mergeplans);
279  COPY_SCALAR_FIELD(numCols);
280  COPY_POINTER_FIELD(sortColIdx, from->numCols * sizeof(AttrNumber));
281  COPY_POINTER_FIELD(sortOperators, from->numCols * sizeof(Oid));
282  COPY_POINTER_FIELD(collations, from->numCols * sizeof(Oid));
283  COPY_POINTER_FIELD(nullsFirst, from->numCols * sizeof(bool));
284  COPY_NODE_FIELD(part_prune_info);
285 
286  return newnode;
287 }

References COPY_BITMAPSET_FIELD, COPY_NODE_FIELD, COPY_POINTER_FIELD, COPY_SCALAR_FIELD, CopyPlanFields(), makeNode, and MergeAppend::numCols.

Referenced by copyObjectImpl().

◆ _copyMergeJoin()

static MergeJoin* _copyMergeJoin ( const MergeJoin from)
static

Definition at line 890 of file copyfuncs.c.

891 {
892  MergeJoin *newnode = makeNode(MergeJoin);
893  int numCols;
894 
895  /*
896  * copy node superclass fields
897  */
898  CopyJoinFields((const Join *) from, (Join *) newnode);
899 
900  /*
901  * copy remainder of node
902  */
903  COPY_SCALAR_FIELD(skip_mark_restore);
904  COPY_NODE_FIELD(mergeclauses);
905  numCols = list_length(from->mergeclauses);
906  COPY_POINTER_FIELD(mergeFamilies, numCols * sizeof(Oid));
907  COPY_POINTER_FIELD(mergeCollations, numCols * sizeof(Oid));
908  COPY_POINTER_FIELD(mergeStrategies, numCols * sizeof(int));
909  COPY_POINTER_FIELD(mergeNullsFirst, numCols * sizeof(bool));
910 
911  return newnode;
912 }
static int list_length(const List *l)
Definition: pg_list.h:149

References COPY_NODE_FIELD, COPY_POINTER_FIELD, COPY_SCALAR_FIELD, CopyJoinFields(), list_length(), makeNode, and MergeJoin::mergeclauses.

Referenced by copyObjectImpl().

◆ _copyMergeStmt()

static MergeStmt* _copyMergeStmt ( const MergeStmt from)
static

Definition at line 3787 of file copyfuncs.c.

3788 {
3789  MergeStmt *newnode = makeNode(MergeStmt);
3790 
3791  COPY_NODE_FIELD(relation);
3792  COPY_NODE_FIELD(sourceRelation);
3793  COPY_NODE_FIELD(joinCondition);
3794  COPY_NODE_FIELD(mergeWhenClauses);
3795  COPY_NODE_FIELD(withClause);
3796 
3797  return newnode;
3798 }

References COPY_NODE_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyMergeWhenClause()

static MergeWhenClause* _copyMergeWhenClause ( const MergeWhenClause from)
static

Definition at line 3187 of file copyfuncs.c.

3188 {
3190 
3191  COPY_SCALAR_FIELD(matched);
3192  COPY_SCALAR_FIELD(commandType);
3193  COPY_SCALAR_FIELD(override);
3194  COPY_NODE_FIELD(condition);
3195  COPY_NODE_FIELD(targetList);
3197  return newnode;
3198 }
static Datum values[MAXATTR]
Definition: bootstrap.c:156

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, makeNode, and values.

Referenced by copyObjectImpl().

◆ _copyMinMaxExpr()

static MinMaxExpr* _copyMinMaxExpr ( const MinMaxExpr from)
static

Definition at line 2046 of file copyfuncs.c.

2047 {
2048  MinMaxExpr *newnode = makeNode(MinMaxExpr);
2049 
2050  COPY_SCALAR_FIELD(minmaxtype);
2051  COPY_SCALAR_FIELD(minmaxcollid);
2052  COPY_SCALAR_FIELD(inputcollid);
2053  COPY_SCALAR_FIELD(op);
2055  COPY_LOCATION_FIELD(location);
2056 
2057  return newnode;
2058 }

References generate_unaccent_rules::args, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyModifyTable()

static ModifyTable* _copyModifyTable ( const ModifyTable from)
static

Definition at line 199 of file copyfuncs.c.

200 {
201  ModifyTable *newnode = makeNode(ModifyTable);
202 
203  /*
204  * copy node superclass fields
205  */
206  CopyPlanFields((const Plan *) from, (Plan *) newnode);
207 
208  /*
209  * copy remainder of node
210  */
211  COPY_SCALAR_FIELD(operation);
212  COPY_SCALAR_FIELD(canSetTag);
213  COPY_SCALAR_FIELD(nominalRelation);
214  COPY_SCALAR_FIELD(rootRelation);
215  COPY_SCALAR_FIELD(partColsUpdated);
216  COPY_NODE_FIELD(resultRelations);
217  COPY_NODE_FIELD(updateColnosLists);
218  COPY_NODE_FIELD(withCheckOptionLists);
219  COPY_NODE_FIELD(returningLists);
220  COPY_NODE_FIELD(fdwPrivLists);
221  COPY_BITMAPSET_FIELD(fdwDirectModifyPlans);
222  COPY_NODE_FIELD(rowMarks);
223  COPY_SCALAR_FIELD(epqParam);
224  COPY_SCALAR_FIELD(onConflictAction);
225  COPY_NODE_FIELD(arbiterIndexes);
226  COPY_NODE_FIELD(onConflictSet);
227  COPY_NODE_FIELD(onConflictCols);
228  COPY_NODE_FIELD(onConflictWhere);
229  COPY_SCALAR_FIELD(exclRelRTI);
230  COPY_NODE_FIELD(exclRelTlist);
231  COPY_NODE_FIELD(mergeActionLists);
232 
233  return newnode;
234 }

References COPY_BITMAPSET_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, CopyPlanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyMultiAssignRef()

static MultiAssignRef* _copyMultiAssignRef ( const MultiAssignRef from)
static

Definition at line 3366 of file copyfuncs.c.

3367 {
3369 
3371  COPY_SCALAR_FIELD(colno);
3372  COPY_SCALAR_FIELD(ncolumns);
3373 
3374  return newnode;
3375 }
static rewind_source * source
Definition: pg_rewind.c:81

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, makeNode, and source.

Referenced by copyObjectImpl().

◆ _copyNamedArgExpr()

static NamedArgExpr* _copyNamedArgExpr ( const NamedArgExpr from)
static

Definition at line 1641 of file copyfuncs.c.

1642 {
1643  NamedArgExpr *newnode = makeNode(NamedArgExpr);
1644 
1647  COPY_SCALAR_FIELD(argnumber);
1648  COPY_LOCATION_FIELD(location);
1649 
1650  return newnode;
1651 }

References arg, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, makeNode, and name.

Referenced by copyObjectImpl().

◆ _copyNamedTuplestoreScan()

static NamedTuplestoreScan* _copyNamedTuplestoreScan ( const NamedTuplestoreScan from)
static

Definition at line 730 of file copyfuncs.c.

731 {
733 
734  /*
735  * copy node superclass fields
736  */
737  CopyScanFields((const Scan *) from, (Scan *) newnode);
738 
739  /*
740  * copy remainder of node
741  */
742  COPY_STRING_FIELD(enrname);
743 
744  return newnode;
745 }

References COPY_STRING_FIELD, CopyScanFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyNestLoop()

static NestLoop* _copyNestLoop ( const NestLoop from)
static

Definition at line 868 of file copyfuncs.c.

869 {
870  NestLoop *newnode = makeNode(NestLoop);
871 
872  /*
873  * copy node superclass fields
874  */
875  CopyJoinFields((const Join *) from, (Join *) newnode);
876 
877  /*
878  * copy remainder of node
879  */
880  COPY_NODE_FIELD(nestParams);
881 
882  return newnode;
883 }

References COPY_NODE_FIELD, CopyJoinFields(), and makeNode.

Referenced by copyObjectImpl().

◆ _copyNestLoopParam()

static NestLoopParam* _copyNestLoopParam ( const NestLoopParam from)
static

Definition at line 1250 of file copyfuncs.c.

1251 {
1252  NestLoopParam *newnode = makeNode(NestLoopParam);
1253 
1254  COPY_SCALAR_FIELD(paramno);
1255  COPY_NODE_FIELD(paramval);
1256 
1257  return newnode;
1258 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyNextValueExpr()

static NextValueExpr* _copyNextValueExpr ( const NextValueExpr from)
static

Definition at line 2197 of file copyfuncs.c.

2198 {
2199  NextValueExpr *newnode = makeNode(NextValueExpr);
2200 
2201  COPY_SCALAR_FIELD(seqid);
2202  COPY_SCALAR_FIELD(typeId);
2203 
2204  return newnode;
2205 }

References COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyNotifyStmt()

static NotifyStmt* _copyNotifyStmt ( const NotifyStmt from)
static

Definition at line 4389 of file copyfuncs.c.

4390 {
4391  NotifyStmt *newnode = makeNode(NotifyStmt);
4392 
4393  COPY_STRING_FIELD(conditionname);
4394  COPY_STRING_FIELD(payload);
4395 
4396  return newnode;
4397 }

References COPY_STRING_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyNullIfExpr()

static NullIfExpr* _copyNullIfExpr ( const NullIfExpr from)
static

Definition at line 1697 of file copyfuncs.c.

1698 {
1699  NullIfExpr *newnode = makeNode(NullIfExpr);
1700 
1701  COPY_SCALAR_FIELD(opno);
1702  COPY_SCALAR_FIELD(opfuncid);
1703  COPY_SCALAR_FIELD(opresulttype);
1704  COPY_SCALAR_FIELD(opretset);
1705  COPY_SCALAR_FIELD(opcollid);
1706  COPY_SCALAR_FIELD(inputcollid);
1708  COPY_LOCATION_FIELD(location);
1709 
1710  return newnode;
1711 }

References generate_unaccent_rules::args, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyNullTest()

static NullTest* _copyNullTest ( const NullTest from)
static

Definition at line 2101 of file copyfuncs.c.

2102 {
2103  NullTest *newnode = makeNode(NullTest);
2104 
2106  COPY_SCALAR_FIELD(nulltesttype);
2107  COPY_SCALAR_FIELD(argisrow);
2108  COPY_LOCATION_FIELD(location);
2109 
2110  return newnode;
2111 }

References arg, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyObjectWithArgs()

static ObjectWithArgs* _copyObjectWithArgs ( const ObjectWithArgs from)
static

Definition at line 3943 of file copyfuncs.c.

3944 {
3946 
3947  COPY_NODE_FIELD(objname);
3948  COPY_NODE_FIELD(objargs);
3949  COPY_NODE_FIELD(objfuncargs);
3950  COPY_SCALAR_FIELD(args_unspecified);
3951 
3952  return newnode;
3953 }

References COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyOnConflictClause()

static OnConflictClause* _copyOnConflictClause ( const OnConflictClause from)
static

Definition at line 3119 of file copyfuncs.c.

3120 {
3122 
3124  COPY_NODE_FIELD(infer);
3125  COPY_NODE_FIELD(targetList);
3126  COPY_NODE_FIELD(whereClause);
3127  COPY_LOCATION_FIELD(location);
3128 
3129  return newnode;
3130 }

References generate_unaccent_rules::action, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyOnConflictExpr()

static OnConflictExpr* _copyOnConflictExpr ( const OnConflictExpr from)
static

Definition at line 2293 of file copyfuncs.c.

2294 {
2296 
2298  COPY_NODE_FIELD(arbiterElems);
2299  COPY_NODE_FIELD(arbiterWhere);
2300  COPY_SCALAR_FIELD(constraint);
2301  COPY_NODE_FIELD(onConflictSet);
2302  COPY_NODE_FIELD(onConflictWhere);
2303  COPY_SCALAR_FIELD(exclRelIndex);
2304  COPY_NODE_FIELD(exclRelTlist);
2305 
2306  return newnode;
2307 }

References generate_unaccent_rules::action, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyOpExpr()

static OpExpr* _copyOpExpr ( const OpExpr from)
static

Definition at line 1657 of file copyfuncs.c.

1658 {
1659  OpExpr *newnode = makeNode(OpExpr);
1660 
1661  COPY_SCALAR_FIELD(opno);
1662  COPY_SCALAR_FIELD(opfuncid);
1663  COPY_SCALAR_FIELD(opresulttype);
1664  COPY_SCALAR_FIELD(opretset);
1665  COPY_SCALAR_FIELD(opcollid);
1666  COPY_SCALAR_FIELD(inputcollid);
1668  COPY_LOCATION_FIELD(location);
1669 
1670  return newnode;
1671 }

References generate_unaccent_rules::args, COPY_LOCATION_FIELD, COPY_NODE_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyParam()

static Param* _copyParam ( const Param from)
static

Definition at line 1511 of file copyfuncs.c.

1512 {
1513  Param *newnode = makeNode(Param);
1514 
1515  COPY_SCALAR_FIELD(paramkind);
1516  COPY_SCALAR_FIELD(paramid);
1517  COPY_SCALAR_FIELD(paramtype);
1518  COPY_SCALAR_FIELD(paramtypmod);
1519  COPY_SCALAR_FIELD(paramcollid);
1520  COPY_LOCATION_FIELD(location);
1521 
1522  return newnode;
1523 }

References COPY_LOCATION_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyParamRef()

static ParamRef* _copyParamRef ( const ParamRef from)
static

Definition at line 3241 of file copyfuncs.c.

3242 {
3243  ParamRef *newnode = makeNode(ParamRef);
3244 
3245  COPY_SCALAR_FIELD(number);
3246  COPY_LOCATION_FIELD(location);
3247 
3248  return newnode;
3249 }

References COPY_LOCATION_FIELD, COPY_SCALAR_FIELD, and makeNode.

Referenced by copyObjectImpl().

◆ _copyPartitionBoundSpec()