copyfuncs.c File Reference

#include "postgres.h"
#include "miscadmin.h"
#include "utils/datum.h"
#include "copyfuncs.funcs.c"
#include "copyfuncs.switch.c"

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) : 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 Const *	_copyConst (const Const *from)
static A_Const *	_copyA_Const (const A_Const *from)
static ExtensibleNode *	_copyExtensibleNode (const ExtensibleNode *from)
static Bitmapset *	_copyBitmapset (const Bitmapset *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 46 of file copyfuncs.c.

COPY_BITMAPSET_FIELD

#define COPY_BITMAPSET_FIELD

(

fldname

)

(newnode->fldname = bms_copy(from->fldname))

Definition at line 38 of file copyfuncs.c.

COPY_LOCATION_FIELD

#define COPY_LOCATION_FIELD

(

fldname

)

(newnode->fldname = from->fldname)

Definition at line 61 of file copyfuncs.c.

COPY_NODE_FIELD

#define COPY_NODE_FIELD

(

fldname

)

(newnode->fldname = copyObjectImpl(from->fldname))

Definition at line 34 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)

Definition at line 50 of file copyfuncs.c.

COPY_SCALAR_FIELD

#define COPY_SCALAR_FIELD

(

fldname

)

(newnode->fldname = from->fldname)

Definition at line 30 of file copyfuncs.c.

COPY_STRING_FIELD

#define COPY_STRING_FIELD

(

fldname

)

(newnode->fldname = from->fldname ? pstrdup(from->fldname) : NULL)

Definition at line 42 of file copyfuncs.c.

Function Documentation

_copyA_Const()

static A_Const * _copyA_Const ( const A_Const *  from )

static

Definition at line 108 of file copyfuncs.c.

{
    A_Const    *newnode = makeNode(A_Const);
 
    COPY_SCALAR_FIELD(isnull);
    if (!from->isnull)
    {
        /* This part must duplicate other _copy*() functions. */
        COPY_SCALAR_FIELD(val.node.type);
        switch (nodeTag(&from->val))
        {
            case T_Integer:
                COPY_SCALAR_FIELD(val.ival.ival);
                break;
            case T_Float:
                COPY_STRING_FIELD(val.fval.fval);
                break;
            case T_Boolean:
                COPY_SCALAR_FIELD(val.boolval.boolval);
                break;
            case T_String:
                COPY_STRING_FIELD(val.sval.sval);
                break;
            case T_BitString:
                COPY_STRING_FIELD(val.bsval.bsval);
                break;
            default:
                elog(ERROR, "unrecognized node type: %d",
                     (int) nodeTag(&from->val));
                break;
        }
    }
 
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}

References COPY_LOCATION_FIELD, COPY_SCALAR_FIELD, COPY_STRING_FIELD, elog, ERROR, A_Const::isnull, makeNode, nodeTag, A_Const::val, and val.

_copyBitmapset()

static Bitmapset * _copyBitmapset ( const Bitmapset *  from )

static

Definition at line 164 of file copyfuncs.c.

{
    return bms_copy(from);
}

References bms_copy().

_copyConst()

static Const * _copyConst ( const Const *  from )

static

Definition at line 73 of file copyfuncs.c.

{
    Const      *newnode = makeNode(Const);
 
    COPY_SCALAR_FIELD(consttype);
    COPY_SCALAR_FIELD(consttypmod);
    COPY_SCALAR_FIELD(constcollid);
    COPY_SCALAR_FIELD(constlen);
 
    if (from->constbyval || from->constisnull)
    {
        /*
         * passed by value so just copy the datum. Also, don't try to copy
         * struct when value is null!
         */
        newnode->constvalue = from->constvalue;
    }
    else
    {
        /*
         * passed by reference.  We need a palloc'd copy.
         */
        newnode->constvalue = datumCopy(from->constvalue,
                                        from->constbyval,
                                        from->constlen);
    }
 
    COPY_SCALAR_FIELD(constisnull);
    COPY_SCALAR_FIELD(constbyval);
    COPY_LOCATION_FIELD(location);
 
    return newnode;
}

References COPY_LOCATION_FIELD, COPY_SCALAR_FIELD, datumCopy(), and makeNode.

_copyExtensibleNode()

static ExtensibleNode * _copyExtensibleNode ( const ExtensibleNode *  from )

static

Definition at line 147 of file copyfuncs.c.

{
    ExtensibleNode *newnode;
    const ExtensibleNodeMethods *methods;
 
    methods = GetExtensibleNodeMethods(from->extnodename, false);
    newnode = (ExtensibleNode *) newNode(methods->node_size,
                                         T_ExtensibleNode);
    COPY_STRING_FIELD(extnodename);
 
    /* copy the private fields */
    methods->nodeCopy(newnode, from);
 
    return newnode;
}

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

copyObjectImpl()

void * copyObjectImpl

(

const void *

from

)

Definition at line 177 of file copyfuncs.c.

{
    void       *retval;
 
    if (from == NULL)
        return NULL;
 
    /* Guard against stack overflow due to overly complex expressions */
    check_stack_depth();
 
    switch (nodeTag(from))
    {
#include "copyfuncs.switch.c"
 
        case T_List:
            retval = list_copy_deep(from);
            break;
 
            /*
             * Lists of integers, OIDs and XIDs don't need to be deep-copied,
             * so we perform a shallow copy via list_copy()
             */
        case T_IntList:
        case T_OidList:
        case T_XidList:
            retval = list_copy(from);
            break;
 
        default:
            elog(ERROR, "unrecognized node type: %d", (int) nodeTag(from));
            retval = 0;         /* keep compiler quiet */
            break;
    }
 
    return retval;
}

References check_stack_depth(), elog, ERROR, list_copy(), list_copy_deep(), and nodeTag.

Referenced by list_copy_deep().