createas.h File Reference

#include "catalog/objectaddress.h"
#include "nodes/params.h"
#include "parser/parse_node.h"
#include "tcop/dest.h"
#include "utils/queryenvironment.h"

Include dependency graph for createas.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Functions
ObjectAddress	ExecCreateTableAs (ParseState *pstate, CreateTableAsStmt *stmt, ParamListInfo params, QueryEnvironment *queryEnv, QueryCompletion *qc)
int	GetIntoRelEFlags (IntoClause *intoClause)
DestReceiver *	CreateIntoRelDestReceiver (IntoClause *intoClause)
bool	CreateTableAsRelExists (CreateTableAsStmt *ctas)

Function Documentation

CreateIntoRelDestReceiver()

DestReceiver * CreateIntoRelDestReceiver

(

IntoClause *

intoClause

)

Definition at line 440 of file createas.c.

{
    DR_intorel *self = (DR_intorel *) palloc0(sizeof(DR_intorel));
 
    self->pub.receiveSlot = intorel_receive;
    self->pub.rStartup = intorel_startup;
    self->pub.rShutdown = intorel_shutdown;
    self->pub.rDestroy = intorel_destroy;
    self->pub.mydest = DestIntoRel;
    self->into = intoClause;
    /* other private fields will be set during intorel_startup */
 
    return (DestReceiver *) self;
}

References DestIntoRel, DR_intorel::into, intorel_destroy(), intorel_receive(), intorel_shutdown(), intorel_startup(), _DestReceiver::mydest, palloc0(), DR_intorel::pub, _DestReceiver::rDestroy, _DestReceiver::receiveSlot, _DestReceiver::rShutdown, and _DestReceiver::rStartup.

Referenced by CreateDestReceiver(), ExecCreateTableAs(), and ExplainOnePlan().

CreateTableAsRelExists()

bool CreateTableAsRelExists

(

CreateTableAsStmt *

ctas

)

Definition at line 393 of file createas.c.

{
    Oid         nspid;
    Oid         oldrelid;
    ObjectAddress address;
    IntoClause *into = ctas->into;
 
    nspid = RangeVarGetCreationNamespace(into->rel);
 
    oldrelid = get_relname_relid(into->rel->relname, nspid);
    if (OidIsValid(oldrelid))
    {
        if (!ctas->if_not_exists)
            ereport(ERROR,
                    (errcode(ERRCODE_DUPLICATE_TABLE),
                     errmsg("relation \"%s\" already exists",
                            into->rel->relname)));
 
        /*
         * The relation exists and IF NOT EXISTS has been specified.
         *
         * If we are in an extension script, insist that the pre-existing
         * object be a member of the extension, to avoid security risks.
         */
        ObjectAddressSet(address, RelationRelationId, oldrelid);
        checkMembershipInCurrentExtension(&address);
 
        /* OK to skip */
        ereport(NOTICE,
                (errcode(ERRCODE_DUPLICATE_TABLE),
                 errmsg("relation \"%s\" already exists, skipping",
                        into->rel->relname)));
        return true;
    }
 
    /* Relation does not exist, it can be created */
    return false;
}

References checkMembershipInCurrentExtension(), ereport, errcode(), errmsg(), ERROR, get_relname_relid(), CreateTableAsStmt::if_not_exists, CreateTableAsStmt::into, NOTICE, nspid, ObjectAddressSet, OidIsValid, RangeVarGetCreationNamespace(), IntoClause::rel, and RangeVar::relname.

Referenced by ExecCreateTableAs(), and ExplainOneUtility().

ExecCreateTableAs()

ObjectAddress ExecCreateTableAs	(	ParseState *	pstate,
		CreateTableAsStmt *	stmt,
		ParamListInfo	params,
		QueryEnvironment *	queryEnv,
		QueryCompletion *	qc
	)

Definition at line 223 of file createas.c.

{
    Query      *query = castNode(Query, stmt->query);
    IntoClause *into = stmt->into;
    JumbleState *jstate = NULL;
    bool        is_matview = (into->viewQuery != NULL);
    bool        do_refresh = false;
    DestReceiver *dest;
    ObjectAddress address;
 
    /* Check if the relation exists or not */
    if (CreateTableAsRelExists(stmt))
        return InvalidObjectAddress;
 
    /*
     * Create the tuple receiver object and insert info it will need
     */
    dest = CreateIntoRelDestReceiver(into);
 
    /* Query contained by CTAS needs to be jumbled if requested */
    if (IsQueryIdEnabled())
        jstate = JumbleQuery(query);
 
    if (post_parse_analyze_hook)
        (*post_parse_analyze_hook) (pstate, query, jstate);
 
    /*
     * The contained Query could be a SELECT, or an EXECUTE utility command.
     * If the latter, we just pass it off to ExecuteQuery.
     */
    if (query->commandType == CMD_UTILITY &&
        IsA(query->utilityStmt, ExecuteStmt))
    {
        ExecuteStmt *estmt = castNode(ExecuteStmt, query->utilityStmt);
 
        Assert(!is_matview);    /* excluded by syntax */
        ExecuteQuery(pstate, estmt, into, params, dest, qc);
 
        /* get object address that intorel_startup saved for us */
        address = ((DR_intorel *) dest)->reladdr;
 
        return address;
    }
    Assert(query->commandType == CMD_SELECT);
 
    /*
     * For materialized views, always skip data during table creation, and use
     * REFRESH instead (see below).
     */
    if (is_matview)
    {
        do_refresh = !into->skipData;
        into->skipData = true;
    }
 
    if (into->skipData)
    {
        /*
         * If WITH NO DATA was specified, do not go through the rewriter,
         * planner and executor.  Just define the relation using a code path
         * similar to CREATE VIEW.  This avoids dump/restore problems stemming
         * from running the planner before all dependencies are set up.
         */
        address = create_ctas_nodata(query->targetList, into);
 
        /*
         * For materialized views, reuse the REFRESH logic, which locks down
         * security-restricted operations and restricts the search_path.  This
         * reduces the chance that a subsequent refresh will fail.
         */
        if (do_refresh)
            RefreshMatViewByOid(address.objectId, true, false, false,
                                pstate->p_sourcetext, qc);
 
    }
    else
    {
        List       *rewritten;
        PlannedStmt *plan;
        QueryDesc  *queryDesc;
 
        Assert(!is_matview);
 
        /*
         * Parse analysis was done already, but we still have to run the rule
         * rewriter.  We do not do AcquireRewriteLocks: we assume the query
         * either came straight from the parser, or suitable locks were
         * acquired by plancache.c.
         */
        rewritten = QueryRewrite(query);
 
        /* SELECT should never rewrite to more or less than one SELECT query */
        if (list_length(rewritten) != 1)
            elog(ERROR, "unexpected rewrite result for CREATE TABLE AS SELECT");
        query = linitial_node(Query, rewritten);
        Assert(query->commandType == CMD_SELECT);
 
        /* plan the query */
        plan = pg_plan_query(query, pstate->p_sourcetext,
                             CURSOR_OPT_PARALLEL_OK, params, NULL);
 
        /*
         * Use a snapshot with an updated command ID to ensure this query sees
         * results of any previously executed queries.  (This could only
         * matter if the planner executed an allegedly-stable function that
         * changed the database contents, but let's do it anyway to be
         * parallel to the EXPLAIN code path.)
         */
        PushCopiedSnapshot(GetActiveSnapshot());
        UpdateActiveSnapshotCommandId();
 
        /* Create a QueryDesc, redirecting output to our tuple receiver */
        queryDesc = CreateQueryDesc(plan, pstate->p_sourcetext,
                                    GetActiveSnapshot(), InvalidSnapshot,
                                    dest, params, queryEnv, 0);
 
        /* call ExecutorStart to prepare the plan for execution */
        ExecutorStart(queryDesc, GetIntoRelEFlags(into));
 
        /* run the plan to completion */
        ExecutorRun(queryDesc, ForwardScanDirection, 0);
 
        /* save the rowcount if we're given a qc to fill */
        if (qc)
            SetQueryCompletion(qc, CMDTAG_SELECT, queryDesc->estate->es_processed);
 
        /* get object address that intorel_startup saved for us */
        address = ((DR_intorel *) dest)->reladdr;
 
        /* and clean up */
        ExecutorFinish(queryDesc);
        ExecutorEnd(queryDesc);
 
        FreeQueryDesc(queryDesc);
 
        PopActiveSnapshot();
    }
 
    return address;
}

References Assert(), castNode, CMD_SELECT, CMD_UTILITY, Query::commandType, create_ctas_nodata(), CreateIntoRelDestReceiver(), CreateQueryDesc(), CreateTableAsRelExists(), CURSOR_OPT_PARALLEL_OK, generate_unaccent_rules::dest, elog, ERROR, EState::es_processed, QueryDesc::estate, ExecuteQuery(), ExecutorEnd(), ExecutorFinish(), ExecutorRun(), ExecutorStart(), ForwardScanDirection, FreeQueryDesc(), GetActiveSnapshot(), GetIntoRelEFlags(), InvalidObjectAddress, InvalidSnapshot, IsA, IsQueryIdEnabled(), JumbleQuery(), linitial_node, list_length(), ObjectAddress::objectId, ParseState::p_sourcetext, pg_plan_query(), plan, PopActiveSnapshot(), post_parse_analyze_hook, PushCopiedSnapshot(), QueryRewrite(), RefreshMatViewByOid(), SetQueryCompletion(), IntoClause::skipData, stmt, Query::targetList, UpdateActiveSnapshotCommandId(), and Query::utilityStmt.

Referenced by ProcessUtilitySlow().

GetIntoRelEFlags()

int GetIntoRelEFlags

(

IntoClause *

intoClause

)

Definition at line 375 of file createas.c.

{
    int         flags = 0;
 
    if (intoClause->skipData)
        flags |= EXEC_FLAG_WITH_NO_DATA;
 
    return flags;
}

References EXEC_FLAG_WITH_NO_DATA, and IntoClause::skipData.

Referenced by ExecCreateTableAs(), ExecuteQuery(), and ExplainOnePlan().