LCOV - code coverage report
Current view: top level - src/backend/commands - createas.c (source / functions) Hit Total Coverage
Test: PostgreSQL 17devel Lines: 161 164 98.2 %
Date: 2024-04-13 09:11:47 Functions: 10 10 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * createas.c
       4             :  *    Execution of CREATE TABLE ... AS, a/k/a SELECT INTO.
       5             :  *    Since CREATE MATERIALIZED VIEW shares syntax and most behaviors,
       6             :  *    we implement that here, too.
       7             :  *
       8             :  * We implement this by diverting the query's normal output to a
       9             :  * specialized DestReceiver type.
      10             :  *
      11             :  * Formerly, CTAS was implemented as a variant of SELECT, which led
      12             :  * to assorted legacy behaviors that we still try to preserve, notably that
      13             :  * we must return a tuples-processed count in the QueryCompletion.  (We no
      14             :  * longer do that for CTAS ... WITH NO DATA, however.)
      15             :  *
      16             :  * Portions Copyright (c) 1996-2024, PostgreSQL Global Development Group
      17             :  * Portions Copyright (c) 1994, Regents of the University of California
      18             :  *
      19             :  *
      20             :  * IDENTIFICATION
      21             :  *    src/backend/commands/createas.c
      22             :  *
      23             :  *-------------------------------------------------------------------------
      24             :  */
      25             : #include "postgres.h"
      26             : 
      27             : #include "access/heapam.h"
      28             : #include "access/reloptions.h"
      29             : #include "access/tableam.h"
      30             : #include "access/xact.h"
      31             : #include "catalog/namespace.h"
      32             : #include "catalog/toasting.h"
      33             : #include "commands/createas.h"
      34             : #include "commands/matview.h"
      35             : #include "commands/prepare.h"
      36             : #include "commands/tablecmds.h"
      37             : #include "commands/view.h"
      38             : #include "miscadmin.h"
      39             : #include "nodes/makefuncs.h"
      40             : #include "nodes/nodeFuncs.h"
      41             : #include "rewrite/rewriteHandler.h"
      42             : #include "tcop/tcopprot.h"
      43             : #include "utils/builtins.h"
      44             : #include "utils/lsyscache.h"
      45             : #include "utils/rel.h"
      46             : #include "utils/rls.h"
      47             : #include "utils/snapmgr.h"
      48             : 
      49             : typedef struct
      50             : {
      51             :     DestReceiver pub;           /* publicly-known function pointers */
      52             :     IntoClause *into;           /* target relation specification */
      53             :     /* These fields are filled by intorel_startup: */
      54             :     Relation    rel;            /* relation to write to */
      55             :     ObjectAddress reladdr;      /* address of rel, for ExecCreateTableAs */
      56             :     CommandId   output_cid;     /* cmin to insert in output tuples */
      57             :     int         ti_options;     /* table_tuple_insert performance options */
      58             :     BulkInsertState bistate;    /* bulk insert state */
      59             : } DR_intorel;
      60             : 
      61             : /* utility functions for CTAS definition creation */
      62             : static ObjectAddress create_ctas_internal(List *attrList, IntoClause *into);
      63             : static ObjectAddress create_ctas_nodata(List *tlist, IntoClause *into);
      64             : 
      65             : /* DestReceiver routines for collecting data */
      66             : static void intorel_startup(DestReceiver *self, int operation, TupleDesc typeinfo);
      67             : static bool intorel_receive(TupleTableSlot *slot, DestReceiver *self);
      68             : static void intorel_shutdown(DestReceiver *self);
      69             : static void intorel_destroy(DestReceiver *self);
      70             : 
      71             : 
      72             : /*
      73             :  * create_ctas_internal
      74             :  *
      75             :  * Internal utility used for the creation of the definition of a relation
      76             :  * created via CREATE TABLE AS or a materialized view.  Caller needs to
      77             :  * provide a list of attributes (ColumnDef nodes).
      78             :  */
      79             : static ObjectAddress
      80        1604 : create_ctas_internal(List *attrList, IntoClause *into)
      81             : {
      82        1604 :     CreateStmt *create = makeNode(CreateStmt);
      83             :     bool        is_matview;
      84             :     char        relkind;
      85             :     Datum       toast_options;
      86             :     static char *validnsps[] = HEAP_RELOPT_NAMESPACES;
      87             :     ObjectAddress intoRelationAddr;
      88             : 
      89             :     /* This code supports both CREATE TABLE AS and CREATE MATERIALIZED VIEW */
      90        1604 :     is_matview = (into->viewQuery != NULL);
      91        1604 :     relkind = is_matview ? RELKIND_MATVIEW : RELKIND_RELATION;
      92             : 
      93             :     /*
      94             :      * Create the target relation by faking up a CREATE TABLE parsetree and
      95             :      * passing it to DefineRelation.
      96             :      */
      97        1604 :     create->relation = into->rel;
      98        1604 :     create->tableElts = attrList;
      99        1604 :     create->inhRelations = NIL;
     100        1604 :     create->ofTypename = NULL;
     101        1604 :     create->constraints = NIL;
     102        1604 :     create->options = into->options;
     103        1604 :     create->oncommit = into->onCommit;
     104        1604 :     create->tablespacename = into->tableSpaceName;
     105        1604 :     create->if_not_exists = false;
     106        1604 :     create->accessMethod = into->accessMethod;
     107             : 
     108             :     /*
     109             :      * Create the relation.  (This will error out if there's an existing view,
     110             :      * so we don't need more code to complain if "replace" is false.)
     111             :      */
     112        1604 :     intoRelationAddr = DefineRelation(create, relkind, InvalidOid, NULL, NULL);
     113             : 
     114             :     /*
     115             :      * If necessary, create a TOAST table for the target table.  Note that
     116             :      * NewRelationCreateToastTable ends with CommandCounterIncrement(), so
     117             :      * that the TOAST table will be visible for insertion.
     118             :      */
     119        1586 :     CommandCounterIncrement();
     120             : 
     121             :     /* parse and validate reloptions for the toast table */
     122        1586 :     toast_options = transformRelOptions((Datum) 0,
     123             :                                         create->options,
     124             :                                         "toast",
     125             :                                         validnsps,
     126             :                                         true, false);
     127             : 
     128        1586 :     (void) heap_reloptions(RELKIND_TOASTVALUE, toast_options, true);
     129             : 
     130        1586 :     NewRelationCreateToastTable(intoRelationAddr.objectId, toast_options);
     131             : 
     132             :     /* Create the "view" part of a materialized view. */
     133        1586 :     if (is_matview)
     134             :     {
     135             :         /* StoreViewQuery scribbles on tree, so make a copy */
     136         438 :         Query      *query = (Query *) copyObject(into->viewQuery);
     137             : 
     138         438 :         StoreViewQuery(intoRelationAddr.objectId, query, false);
     139         438 :         CommandCounterIncrement();
     140             :     }
     141             : 
     142        1586 :     return intoRelationAddr;
     143             : }
     144             : 
     145             : 
     146             : /*
     147             :  * create_ctas_nodata
     148             :  *
     149             :  * Create CTAS or materialized view when WITH NO DATA is used, starting from
     150             :  * the targetlist of the SELECT or view definition.
     151             :  */
     152             : static ObjectAddress
     153         110 : create_ctas_nodata(List *tlist, IntoClause *into)
     154             : {
     155             :     List       *attrList;
     156             :     ListCell   *t,
     157             :                *lc;
     158             : 
     159             :     /*
     160             :      * Build list of ColumnDefs from non-junk elements of the tlist.  If a
     161             :      * column name list was specified in CREATE TABLE AS, override the column
     162             :      * names in the query.  (Too few column names are OK, too many are not.)
     163             :      */
     164         110 :     attrList = NIL;
     165         110 :     lc = list_head(into->colNames);
     166         352 :     foreach(t, tlist)
     167             :     {
     168         242 :         TargetEntry *tle = (TargetEntry *) lfirst(t);
     169             : 
     170         242 :         if (!tle->resjunk)
     171             :         {
     172             :             ColumnDef  *col;
     173             :             char       *colname;
     174             : 
     175         242 :             if (lc)
     176             :             {
     177          76 :                 colname = strVal(lfirst(lc));
     178          76 :                 lc = lnext(into->colNames, lc);
     179             :             }
     180             :             else
     181         166 :                 colname = tle->resname;
     182             : 
     183         242 :             col = makeColumnDef(colname,
     184         242 :                                 exprType((Node *) tle->expr),
     185         242 :                                 exprTypmod((Node *) tle->expr),
     186         242 :                                 exprCollation((Node *) tle->expr));
     187             : 
     188             :             /*
     189             :              * It's possible that the column is of a collatable type but the
     190             :              * collation could not be resolved, so double-check.  (We must
     191             :              * check this here because DefineRelation would adopt the type's
     192             :              * default collation rather than complaining.)
     193             :              */
     194         464 :             if (!OidIsValid(col->collOid) &&
     195         222 :                 type_is_collatable(col->typeName->typeOid))
     196           0 :                 ereport(ERROR,
     197             :                         (errcode(ERRCODE_INDETERMINATE_COLLATION),
     198             :                          errmsg("no collation was derived for column \"%s\" with collatable type %s",
     199             :                                 col->colname,
     200             :                                 format_type_be(col->typeName->typeOid)),
     201             :                          errhint("Use the COLLATE clause to set the collation explicitly.")));
     202             : 
     203         242 :             attrList = lappend(attrList, col);
     204             :         }
     205             :     }
     206             : 
     207         110 :     if (lc != NULL)
     208          12 :         ereport(ERROR,
     209             :                 (errcode(ERRCODE_SYNTAX_ERROR),
     210             :                  errmsg("too many column names were specified")));
     211             : 
     212             :     /* Create the relation definition using the ColumnDef list */
     213          98 :     return create_ctas_internal(attrList, into);
     214             : }
     215             : 
     216             : 
     217             : /*
     218             :  * ExecCreateTableAs -- execute a CREATE TABLE AS command
     219             :  */
     220             : ObjectAddress
     221        1684 : ExecCreateTableAs(ParseState *pstate, CreateTableAsStmt *stmt,
     222             :                   ParamListInfo params, QueryEnvironment *queryEnv,
     223             :                   QueryCompletion *qc)
     224             : {
     225        1684 :     Query      *query = castNode(Query, stmt->query);
     226        1684 :     IntoClause *into = stmt->into;
     227        1684 :     bool        is_matview = (into->viewQuery != NULL);
     228             :     DestReceiver *dest;
     229        1684 :     Oid         save_userid = InvalidOid;
     230        1684 :     int         save_sec_context = 0;
     231        1684 :     int         save_nestlevel = 0;
     232             :     ObjectAddress address;
     233             :     List       *rewritten;
     234             :     PlannedStmt *plan;
     235             :     QueryDesc  *queryDesc;
     236             : 
     237             :     /* Check if the relation exists or not */
     238        1684 :     if (CreateTableAsRelExists(stmt))
     239          46 :         return InvalidObjectAddress;
     240             : 
     241             :     /*
     242             :      * Create the tuple receiver object and insert info it will need
     243             :      */
     244        1592 :     dest = CreateIntoRelDestReceiver(into);
     245             : 
     246             :     /*
     247             :      * The contained Query could be a SELECT, or an EXECUTE utility command.
     248             :      * If the latter, we just pass it off to ExecuteQuery.
     249             :      */
     250        1592 :     if (query->commandType == CMD_UTILITY &&
     251          42 :         IsA(query->utilityStmt, ExecuteStmt))
     252             :     {
     253          42 :         ExecuteStmt *estmt = castNode(ExecuteStmt, query->utilityStmt);
     254             : 
     255             :         Assert(!is_matview);    /* excluded by syntax */
     256          42 :         ExecuteQuery(pstate, estmt, into, params, dest, qc);
     257             : 
     258             :         /* get object address that intorel_startup saved for us */
     259          42 :         address = ((DR_intorel *) dest)->reladdr;
     260             : 
     261          42 :         return address;
     262             :     }
     263             :     Assert(query->commandType == CMD_SELECT);
     264             : 
     265             :     /*
     266             :      * For materialized views, lock down security-restricted operations and
     267             :      * arrange to make GUC variable changes local to this command.  This is
     268             :      * not necessary for security, but this keeps the behavior similar to
     269             :      * REFRESH MATERIALIZED VIEW.  Otherwise, one could create a materialized
     270             :      * view not possible to refresh.
     271             :      */
     272        1550 :     if (is_matview)
     273             :     {
     274         444 :         GetUserIdAndSecContext(&save_userid, &save_sec_context);
     275         444 :         SetUserIdAndSecContext(save_userid,
     276             :                                save_sec_context | SECURITY_RESTRICTED_OPERATION);
     277         444 :         save_nestlevel = NewGUCNestLevel();
     278             :     }
     279             : 
     280        1550 :     if (into->skipData)
     281             :     {
     282             :         /*
     283             :          * If WITH NO DATA was specified, do not go through the rewriter,
     284             :          * planner and executor.  Just define the relation using a code path
     285             :          * similar to CREATE VIEW.  This avoids dump/restore problems stemming
     286             :          * from running the planner before all dependencies are set up.
     287             :          */
     288         110 :         address = create_ctas_nodata(query->targetList, into);
     289             :     }
     290             :     else
     291             :     {
     292             :         /*
     293             :          * Parse analysis was done already, but we still have to run the rule
     294             :          * rewriter.  We do not do AcquireRewriteLocks: we assume the query
     295             :          * either came straight from the parser, or suitable locks were
     296             :          * acquired by plancache.c.
     297             :          */
     298        1440 :         rewritten = QueryRewrite(query);
     299             : 
     300             :         /* SELECT should never rewrite to more or less than one SELECT query */
     301        1440 :         if (list_length(rewritten) != 1)
     302           0 :             elog(ERROR, "unexpected rewrite result for %s",
     303             :                  is_matview ? "CREATE MATERIALIZED VIEW" :
     304             :                  "CREATE TABLE AS SELECT");
     305        1440 :         query = linitial_node(Query, rewritten);
     306             :         Assert(query->commandType == CMD_SELECT);
     307             : 
     308             :         /* plan the query */
     309        1440 :         plan = pg_plan_query(query, pstate->p_sourcetext,
     310             :                              CURSOR_OPT_PARALLEL_OK, params);
     311             : 
     312             :         /*
     313             :          * Use a snapshot with an updated command ID to ensure this query sees
     314             :          * results of any previously executed queries.  (This could only
     315             :          * matter if the planner executed an allegedly-stable function that
     316             :          * changed the database contents, but let's do it anyway to be
     317             :          * parallel to the EXPLAIN code path.)
     318             :          */
     319        1434 :         PushCopiedSnapshot(GetActiveSnapshot());
     320        1434 :         UpdateActiveSnapshotCommandId();
     321             : 
     322             :         /* Create a QueryDesc, redirecting output to our tuple receiver */
     323        1434 :         queryDesc = CreateQueryDesc(plan, pstate->p_sourcetext,
     324             :                                     GetActiveSnapshot(), InvalidSnapshot,
     325             :                                     dest, params, queryEnv, 0);
     326             : 
     327             :         /* call ExecutorStart to prepare the plan for execution */
     328        1434 :         ExecutorStart(queryDesc, GetIntoRelEFlags(into));
     329             : 
     330             :         /* run the plan to completion */
     331        1434 :         ExecutorRun(queryDesc, ForwardScanDirection, 0, true);
     332             : 
     333             :         /* save the rowcount if we're given a qc to fill */
     334        1392 :         if (qc)
     335        1372 :             SetQueryCompletion(qc, CMDTAG_SELECT, queryDesc->estate->es_processed);
     336             : 
     337             :         /* get object address that intorel_startup saved for us */
     338        1392 :         address = ((DR_intorel *) dest)->reladdr;
     339             : 
     340             :         /* and clean up */
     341        1392 :         ExecutorFinish(queryDesc);
     342        1392 :         ExecutorEnd(queryDesc);
     343             : 
     344        1392 :         FreeQueryDesc(queryDesc);
     345             : 
     346        1392 :         PopActiveSnapshot();
     347             :     }
     348             : 
     349        1490 :     if (is_matview)
     350             :     {
     351             :         /* Roll back any GUC changes */
     352         426 :         AtEOXact_GUC(false, save_nestlevel);
     353             : 
     354             :         /* Restore userid and security context */
     355         426 :         SetUserIdAndSecContext(save_userid, save_sec_context);
     356             :     }
     357             : 
     358        1490 :     return address;
     359             : }
     360             : 
     361             : /*
     362             :  * GetIntoRelEFlags --- compute executor flags needed for CREATE TABLE AS
     363             :  *
     364             :  * This is exported because EXPLAIN and PREPARE need it too.  (Note: those
     365             :  * callers still need to deal explicitly with the skipData flag; since they
     366             :  * use different methods for suppressing execution, it doesn't seem worth
     367             :  * trying to encapsulate that part.)
     368             :  */
     369             : int
     370        1572 : GetIntoRelEFlags(IntoClause *intoClause)
     371             : {
     372        1572 :     int         flags = 0;
     373             : 
     374        1572 :     if (intoClause->skipData)
     375          42 :         flags |= EXEC_FLAG_WITH_NO_DATA;
     376             : 
     377        1572 :     return flags;
     378             : }
     379             : 
     380             : /*
     381             :  * CreateTableAsRelExists --- check existence of relation for CreateTableAsStmt
     382             :  *
     383             :  * Utility wrapper checking if the relation pending for creation in this
     384             :  * CreateTableAsStmt query already exists or not.  Returns true if the
     385             :  * relation exists, otherwise false.
     386             :  */
     387             : bool
     388        1840 : CreateTableAsRelExists(CreateTableAsStmt *ctas)
     389             : {
     390             :     Oid         nspid;
     391             :     Oid         oldrelid;
     392             :     ObjectAddress address;
     393        1840 :     IntoClause *into = ctas->into;
     394             : 
     395        1840 :     nspid = RangeVarGetCreationNamespace(into->rel);
     396             : 
     397        1840 :     oldrelid = get_relname_relid(into->rel->relname, nspid);
     398        1840 :     if (OidIsValid(oldrelid))
     399             :     {
     400         152 :         if (!ctas->if_not_exists)
     401          72 :             ereport(ERROR,
     402             :                     (errcode(ERRCODE_DUPLICATE_TABLE),
     403             :                      errmsg("relation \"%s\" already exists",
     404             :                             into->rel->relname)));
     405             : 
     406             :         /*
     407             :          * The relation exists and IF NOT EXISTS has been specified.
     408             :          *
     409             :          * If we are in an extension script, insist that the pre-existing
     410             :          * object be a member of the extension, to avoid security risks.
     411             :          */
     412          80 :         ObjectAddressSet(address, RelationRelationId, oldrelid);
     413          80 :         checkMembershipInCurrentExtension(&address);
     414             : 
     415             :         /* OK to skip */
     416          76 :         ereport(NOTICE,
     417             :                 (errcode(ERRCODE_DUPLICATE_TABLE),
     418             :                  errmsg("relation \"%s\" already exists, skipping",
     419             :                         into->rel->relname)));
     420          76 :         return true;
     421             :     }
     422             : 
     423             :     /* Relation does not exist, it can be created */
     424        1688 :     return false;
     425             : }
     426             : 
     427             : /*
     428             :  * CreateIntoRelDestReceiver -- create a suitable DestReceiver object
     429             :  *
     430             :  * intoClause will be NULL if called from CreateDestReceiver(), in which
     431             :  * case it has to be provided later.  However, it is convenient to allow
     432             :  * self->into to be filled in immediately for other callers.
     433             :  */
     434             : DestReceiver *
     435        1688 : CreateIntoRelDestReceiver(IntoClause *intoClause)
     436             : {
     437        1688 :     DR_intorel *self = (DR_intorel *) palloc0(sizeof(DR_intorel));
     438             : 
     439        1688 :     self->pub.receiveSlot = intorel_receive;
     440        1688 :     self->pub.rStartup = intorel_startup;
     441        1688 :     self->pub.rShutdown = intorel_shutdown;
     442        1688 :     self->pub.rDestroy = intorel_destroy;
     443        1688 :     self->pub.mydest = DestIntoRel;
     444        1688 :     self->into = intoClause;
     445             :     /* other private fields will be set during intorel_startup */
     446             : 
     447        1688 :     return (DestReceiver *) self;
     448             : }
     449             : 
     450             : /*
     451             :  * intorel_startup --- executor startup
     452             :  */
     453             : static void
     454        1530 : intorel_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
     455             : {
     456        1530 :     DR_intorel *myState = (DR_intorel *) self;
     457        1530 :     IntoClause *into = myState->into;
     458             :     bool        is_matview;
     459             :     List       *attrList;
     460             :     ObjectAddress intoRelationAddr;
     461             :     Relation    intoRelationDesc;
     462             :     ListCell   *lc;
     463             :     int         attnum;
     464             : 
     465             :     Assert(into != NULL);       /* else somebody forgot to set it */
     466             : 
     467             :     /* This code supports both CREATE TABLE AS and CREATE MATERIALIZED VIEW */
     468        1530 :     is_matview = (into->viewQuery != NULL);
     469             : 
     470             :     /*
     471             :      * Build column definitions using "pre-cooked" type and collation info. If
     472             :      * a column name list was specified in CREATE TABLE AS, override the
     473             :      * column names derived from the query.  (Too few column names are OK, too
     474             :      * many are not.)
     475             :      */
     476        1530 :     attrList = NIL;
     477        1530 :     lc = list_head(into->colNames);
     478        5932 :     for (attnum = 0; attnum < typeinfo->natts; attnum++)
     479             :     {
     480        4414 :         Form_pg_attribute attribute = TupleDescAttr(typeinfo, attnum);
     481             :         ColumnDef  *col;
     482             :         char       *colname;
     483             : 
     484        4414 :         if (lc)
     485             :         {
     486         264 :             colname = strVal(lfirst(lc));
     487         264 :             lc = lnext(into->colNames, lc);
     488             :         }
     489             :         else
     490        4150 :             colname = NameStr(attribute->attname);
     491             : 
     492        4414 :         col = makeColumnDef(colname,
     493             :                             attribute->atttypid,
     494             :                             attribute->atttypmod,
     495             :                             attribute->attcollation);
     496             : 
     497             :         /*
     498             :          * It's possible that the column is of a collatable type but the
     499             :          * collation could not be resolved, so double-check.  (We must check
     500             :          * this here because DefineRelation would adopt the type's default
     501             :          * collation rather than complaining.)
     502             :          */
     503        8144 :         if (!OidIsValid(col->collOid) &&
     504        3730 :             type_is_collatable(col->typeName->typeOid))
     505          12 :             ereport(ERROR,
     506             :                     (errcode(ERRCODE_INDETERMINATE_COLLATION),
     507             :                      errmsg("no collation was derived for column \"%s\" with collatable type %s",
     508             :                             col->colname,
     509             :                             format_type_be(col->typeName->typeOid)),
     510             :                      errhint("Use the COLLATE clause to set the collation explicitly.")));
     511             : 
     512        4402 :         attrList = lappend(attrList, col);
     513             :     }
     514             : 
     515        1518 :     if (lc != NULL)
     516          12 :         ereport(ERROR,
     517             :                 (errcode(ERRCODE_SYNTAX_ERROR),
     518             :                  errmsg("too many column names were specified")));
     519             : 
     520             :     /*
     521             :      * Actually create the target table
     522             :      */
     523        1506 :     intoRelationAddr = create_ctas_internal(attrList, into);
     524             : 
     525             :     /*
     526             :      * Finally we can open the target table
     527             :      */
     528        1488 :     intoRelationDesc = table_open(intoRelationAddr.objectId, AccessExclusiveLock);
     529             : 
     530             :     /*
     531             :      * Make sure the constructed table does not have RLS enabled.
     532             :      *
     533             :      * check_enable_rls() will ereport(ERROR) itself if the user has requested
     534             :      * something invalid, and otherwise will return RLS_ENABLED if RLS should
     535             :      * be enabled here.  We don't actually support that currently, so throw
     536             :      * our own ereport(ERROR) if that happens.
     537             :      */
     538        1488 :     if (check_enable_rls(intoRelationAddr.objectId, InvalidOid, false) == RLS_ENABLED)
     539           0 :         ereport(ERROR,
     540             :                 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
     541             :                  errmsg("policies not yet implemented for this command")));
     542             : 
     543             :     /*
     544             :      * Tentatively mark the target as populated, if it's a matview and we're
     545             :      * going to fill it; otherwise, no change needed.
     546             :      */
     547        1488 :     if (is_matview && !into->skipData)
     548         356 :         SetMatViewPopulatedState(intoRelationDesc, true);
     549             : 
     550             :     /*
     551             :      * Fill private fields of myState for use by later routines
     552             :      */
     553        1488 :     myState->rel = intoRelationDesc;
     554        1488 :     myState->reladdr = intoRelationAddr;
     555        1488 :     myState->output_cid = GetCurrentCommandId(true);
     556        1488 :     myState->ti_options = TABLE_INSERT_SKIP_FSM;
     557             : 
     558             :     /*
     559             :      * If WITH NO DATA is specified, there is no need to set up the state for
     560             :      * bulk inserts as there are no tuples to insert.
     561             :      */
     562        1488 :     if (!into->skipData)
     563        1452 :         myState->bistate = GetBulkInsertState();
     564             :     else
     565          36 :         myState->bistate = NULL;
     566             : 
     567             :     /*
     568             :      * Valid smgr_targblock implies something already wrote to the relation.
     569             :      * This may be harmless, but this function hasn't planned for it.
     570             :      */
     571             :     Assert(RelationGetTargetBlock(intoRelationDesc) == InvalidBlockNumber);
     572        1488 : }
     573             : 
     574             : /*
     575             :  * intorel_receive --- receive one tuple
     576             :  */
     577             : static bool
     578     2123710 : intorel_receive(TupleTableSlot *slot, DestReceiver *self)
     579             : {
     580     2123710 :     DR_intorel *myState = (DR_intorel *) self;
     581             : 
     582             :     /* Nothing to insert if WITH NO DATA is specified. */
     583     2123710 :     if (!myState->into->skipData)
     584             :     {
     585             :         /*
     586             :          * Note that the input slot might not be of the type of the target
     587             :          * relation. That's supported by table_tuple_insert(), but slightly
     588             :          * less efficient than inserting with the right slot - but the
     589             :          * alternative would be to copy into a slot of the right type, which
     590             :          * would not be cheap either. This also doesn't allow accessing per-AM
     591             :          * data (say a tuple's xmin), but since we don't do that here...
     592             :          */
     593     2123710 :         table_tuple_insert(myState->rel,
     594             :                            slot,
     595             :                            myState->output_cid,
     596             :                            myState->ti_options,
     597             :                            myState->bistate);
     598             :     }
     599             : 
     600             :     /* We know this is a newly created relation, so there are no indexes */
     601             : 
     602     2123710 :     return true;
     603             : }
     604             : 
     605             : /*
     606             :  * intorel_shutdown --- executor end
     607             :  */
     608             : static void
     609        1488 : intorel_shutdown(DestReceiver *self)
     610             : {
     611        1488 :     DR_intorel *myState = (DR_intorel *) self;
     612        1488 :     IntoClause *into = myState->into;
     613             : 
     614        1488 :     if (!into->skipData)
     615             :     {
     616        1452 :         FreeBulkInsertState(myState->bistate);
     617        1452 :         table_finish_bulk_insert(myState->rel, myState->ti_options);
     618             :     }
     619             : 
     620             :     /* close rel, but keep lock until commit */
     621        1488 :     table_close(myState->rel, NoLock);
     622        1488 :     myState->rel = NULL;
     623        1488 : }
     624             : 
     625             : /*
     626             :  * intorel_destroy --- release DestReceiver object
     627             :  */
     628             : static void
     629          96 : intorel_destroy(DestReceiver *self)
     630             : {
     631          96 :     pfree(self);
     632          96 : }

Generated by: LCOV version 1.14