PostgreSQL Source Code: src/backend/commands/createas.c Source File

PostgreSQL Source Code git master
createas.c
Go to the documentation of this file.
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-2025, 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 "executor/execdesc.h"
39#include "executor/executor.h"
40#include "nodes/makefuncs.h"
41#include "nodes/nodeFuncs.h"
42#include "nodes/queryjumble.h"
43#include "parser/analyze.h"
44#include "rewrite/rewriteHandler.h"
45#include "tcop/tcopprot.h"
46#include "utils/builtins.h"
47#include "utils/lsyscache.h"
48#include "utils/rls.h"
49#include "utils/snapmgr.h"
50
51 typedef struct
52{
53 DestReceiver pub; /* publicly-known function pointers */
54 IntoClause *into; /* target relation specification */
55 /* These fields are filled by intorel_startup: */
56 Relation rel; /* relation to write to */
57 ObjectAddress reladdr; /* address of rel, for ExecCreateTableAs */
58 CommandId output_cid; /* cmin to insert in output tuples */
59 int ti_options; /* table_tuple_insert performance options */
60 BulkInsertState bistate; /* bulk insert state */
61} DR_intorel;
62
63/* utility functions for CTAS definition creation */
64static ObjectAddress create_ctas_internal(List *attrList, IntoClause *into);
65static ObjectAddress create_ctas_nodata(List *tlist, IntoClause *into);
66
67/* DestReceiver routines for collecting data */
68static void intorel_startup(DestReceiver *self, int operation, TupleDesc typeinfo);
69static bool intorel_receive(TupleTableSlot *slot, DestReceiver *self);
70static void intorel_shutdown(DestReceiver *self);
71static void intorel_destroy(DestReceiver *self);
72
73
74/*
75 * create_ctas_internal
76 *
77 * Internal utility used for the creation of the definition of a relation
78 * created via CREATE TABLE AS or a materialized view. Caller needs to
79 * provide a list of attributes (ColumnDef nodes).
80 */
81static ObjectAddress
82 create_ctas_internal(List *attrList, IntoClause *into)
83{
84 CreateStmt *create = makeNode(CreateStmt);
85 bool is_matview;
86 char relkind;
87 Datum toast_options;
88 const char *const validnsps[] = HEAP_RELOPT_NAMESPACES;
89 ObjectAddress intoRelationAddr;
90
91 /* This code supports both CREATE TABLE AS and CREATE MATERIALIZED VIEW */
92 is_matview = (into->viewQuery != NULL);
93 relkind = is_matview ? RELKIND_MATVIEW : RELKIND_RELATION;
94
95 /*
96 * Create the target relation by faking up a CREATE TABLE parsetree and
97 * passing it to DefineRelation.
98 */
99 create->relation = into->rel;
100 create->tableElts = attrList;
101 create->inhRelations = NIL;
102 create->ofTypename = NULL;
103 create->constraints = NIL;
104 create->options = into->options;
105 create->oncommit = into->onCommit;
106 create->tablespacename = into->tableSpaceName;
107 create->if_not_exists = false;
108 create->accessMethod = into->accessMethod;
109
110 /*
111 * Create the relation. (This will error out if there's an existing view,
112 * so we don't need more code to complain if "replace" is false.)
113 */
114 intoRelationAddr = DefineRelation(create, relkind, InvalidOid, NULL, NULL);
115
116 /*
117 * If necessary, create a TOAST table for the target table. Note that
118 * NewRelationCreateToastTable ends with CommandCounterIncrement(), so
119 * that the TOAST table will be visible for insertion.
120 */
121 CommandCounterIncrement();
122
123 /* parse and validate reloptions for the toast table */
124 toast_options = transformRelOptions((Datum) 0,
125 create->options,
126 "toast",
127 validnsps,
128 true, false);
129
130 (void) heap_reloptions(RELKIND_TOASTVALUE, toast_options, true);
131
132 NewRelationCreateToastTable(intoRelationAddr.objectId, toast_options);
133
134 /* Create the "view" part of a materialized view. */
135 if (is_matview)
136 {
137 /* StoreViewQuery scribbles on tree, so make a copy */
138 Query *query = copyObject(into->viewQuery);
139
140 StoreViewQuery(intoRelationAddr.objectId, query, false);
141 CommandCounterIncrement();
142 }
143
144 return intoRelationAddr;
145}
146
147
148/*
149 * create_ctas_nodata
150 *
151 * Create CTAS or materialized view when WITH NO DATA is used, starting from
152 * the targetlist of the SELECT or view definition.
153 */
154static ObjectAddress
155 create_ctas_nodata(List *tlist, IntoClause *into)
156{
157 List *attrList;
158 ListCell *t,
159 *lc;
160
161 /*
162 * Build list of ColumnDefs from non-junk elements of the tlist. If a
163 * column name list was specified in CREATE TABLE AS, override the column
164 * names in the query. (Too few column names are OK, too many are not.)
165 */
166 attrList = NIL;
167 lc = list_head(into->colNames);
168 foreach(t, tlist)
169 {
170 TargetEntry *tle = (TargetEntry *) lfirst(t);
171
172 if (!tle->resjunk)
173 {
174 ColumnDef *col;
175 char *colname;
176
177 if (lc)
178 {
179 colname = strVal(lfirst(lc));
180 lc = lnext(into->colNames, lc);
181 }
182 else
183 colname = tle->resname;
184
185 col = makeColumnDef(colname,
186 exprType((Node *) tle->expr),
187 exprTypmod((Node *) tle->expr),
188 exprCollation((Node *) tle->expr));
189
190 /*
191 * It's possible that the column is of a collatable type but the
192 * collation could not be resolved, so double-check. (We must
193 * check this here because DefineRelation would adopt the type's
194 * default collation rather than complaining.)
195 */
196 if (!OidIsValid(col->collOid) &&
197 type_is_collatable(col->typeName->typeOid))
198 ereport(ERROR,
199 (errcode(ERRCODE_INDETERMINATE_COLLATION),
200 errmsg("no collation was derived for column \"%s\" with collatable type %s",
201 col->colname,
202 format_type_be(col->typeName->typeOid)),
203 errhint("Use the COLLATE clause to set the collation explicitly.")));
204
205 attrList = lappend(attrList, col);
206 }
207 }
208
209 if (lc != NULL)
210 ereport(ERROR,
211 (errcode(ERRCODE_SYNTAX_ERROR),
212 errmsg("too many column names were specified")));
213
214 /* Create the relation definition using the ColumnDef list */
215 return create_ctas_internal(attrList, into);
216}
217
218
219/*
220 * ExecCreateTableAs -- execute a CREATE TABLE AS command
221 */
222ObjectAddress
223 ExecCreateTableAs(ParseState *pstate, CreateTableAsStmt *stmt,
224 ParamListInfo params, QueryEnvironment *queryEnv,
225 QueryCompletion *qc)
226{
227 Query *query = castNode(Query, stmt->query);
228 IntoClause *into = stmt->into;
229 JumbleState *jstate = NULL;
230 bool is_matview = (into->viewQuery != NULL);
231 bool do_refresh = false;
232 DestReceiver *dest;
233 ObjectAddress address;
234
235 /* Check if the relation exists or not */
236 if (CreateTableAsRelExists(stmt))
237 return InvalidObjectAddress;
238
239 /*
240 * Create the tuple receiver object and insert info it will need
241 */
242 dest = CreateIntoRelDestReceiver(into);
243
244 /* Query contained by CTAS needs to be jumbled if requested */
245 if (IsQueryIdEnabled())
246 jstate = JumbleQuery(query);
247
248 if (post_parse_analyze_hook)
249 (*post_parse_analyze_hook) (pstate, query, jstate);
250
251 /*
252 * The contained Query could be a SELECT, or an EXECUTE utility command.
253 * If the latter, we just pass it off to ExecuteQuery.
254 */
255 if (query->commandType == CMD_UTILITY &&
256 IsA(query->utilityStmt, ExecuteStmt))
257 {
258 ExecuteStmt *estmt = castNode(ExecuteStmt, query->utilityStmt);
259
260 Assert(!is_matview); /* excluded by syntax */
261 ExecuteQuery(pstate, estmt, into, params, dest, qc);
262
263 /* get object address that intorel_startup saved for us */
264 address = ((DR_intorel *) dest)->reladdr;
265
266 return address;
267 }
268 Assert(query->commandType == CMD_SELECT);
269
270 /*
271 * For materialized views, always skip data during table creation, and use
272 * REFRESH instead (see below).
273 */
274 if (is_matview)
275 {
276 do_refresh = !into->skipData;
277 into->skipData = true;
278 }
279
280 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 address = create_ctas_nodata(query->targetList, into);
289
290 /*
291 * For materialized views, reuse the REFRESH logic, which locks down
292 * security-restricted operations and restricts the search_path. This
293 * reduces the chance that a subsequent refresh will fail.
294 */
295 if (do_refresh)
296 RefreshMatViewByOid(address.objectId, true, false, false,
297 pstate->p_sourcetext, qc);
298
299 }
300 else
301 {
302 List *rewritten;
303 PlannedStmt *plan;
304 QueryDesc *queryDesc;
305
306 Assert(!is_matview);
307
308 /*
309 * Parse analysis was done already, but we still have to run the rule
310 * rewriter. We do not do AcquireRewriteLocks: we assume the query
311 * either came straight from the parser, or suitable locks were
312 * acquired by plancache.c.
313 */
314 rewritten = QueryRewrite(query);
315
316 /* SELECT should never rewrite to more or less than one SELECT query */
317 if (list_length(rewritten) != 1)
318 elog(ERROR, "unexpected rewrite result for CREATE TABLE AS SELECT");
319 query = linitial_node(Query, rewritten);
320 Assert(query->commandType == CMD_SELECT);
321
322 /* plan the query */
323 plan = pg_plan_query(query, pstate->p_sourcetext,
324 CURSOR_OPT_PARALLEL_OK, params);
325
326 /*
327 * Use a snapshot with an updated command ID to ensure this query sees
328 * results of any previously executed queries. (This could only
329 * matter if the planner executed an allegedly-stable function that
330 * changed the database contents, but let's do it anyway to be
331 * parallel to the EXPLAIN code path.)
332 */
333 PushCopiedSnapshot(GetActiveSnapshot());
334 UpdateActiveSnapshotCommandId();
335
336 /* Create a QueryDesc, redirecting output to our tuple receiver */
337 queryDesc = CreateQueryDesc(plan, pstate->p_sourcetext,
338 GetActiveSnapshot(), InvalidSnapshot,
339 dest, params, queryEnv, 0);
340
341 /* call ExecutorStart to prepare the plan for execution */
342 ExecutorStart(queryDesc, GetIntoRelEFlags(into));
343
344 /* run the plan to completion */
345 ExecutorRun(queryDesc, ForwardScanDirection, 0);
346
347 /* save the rowcount if we're given a qc to fill */
348 if (qc)
349 SetQueryCompletion(qc, CMDTAG_SELECT, queryDesc->estate->es_processed);
350
351 /* get object address that intorel_startup saved for us */
352 address = ((DR_intorel *) dest)->reladdr;
353
354 /* and clean up */
355 ExecutorFinish(queryDesc);
356 ExecutorEnd(queryDesc);
357
358 FreeQueryDesc(queryDesc);
359
360 PopActiveSnapshot();
361 }
362
363 return address;
364}
365
366/*
367 * GetIntoRelEFlags --- compute executor flags needed for CREATE TABLE AS
368 *
369 * This is exported because EXPLAIN and PREPARE need it too. (Note: those
370 * callers still need to deal explicitly with the skipData flag; since they
371 * use different methods for suppressing execution, it doesn't seem worth
372 * trying to encapsulate that part.)
373 */
374int
375 GetIntoRelEFlags(IntoClause *intoClause)
376{
377 int flags = 0;
378
379 if (intoClause->skipData)
380 flags |= EXEC_FLAG_WITH_NO_DATA;
381
382 return flags;
383}
384
385/*
386 * CreateTableAsRelExists --- check existence of relation for CreateTableAsStmt
387 *
388 * Utility wrapper checking if the relation pending for creation in this
389 * CreateTableAsStmt query already exists or not. Returns true if the
390 * relation exists, otherwise false.
391 */
392bool
393 CreateTableAsRelExists(CreateTableAsStmt *ctas)
394{
395 Oid nspid;
396 Oid oldrelid;
397 ObjectAddress address;
398 IntoClause *into = ctas->into;
399
400 nspid = RangeVarGetCreationNamespace(into->rel);
401
402 oldrelid = get_relname_relid(into->rel->relname, nspid);
403 if (OidIsValid(oldrelid))
404 {
405 if (!ctas->if_not_exists)
406 ereport(ERROR,
407 (errcode(ERRCODE_DUPLICATE_TABLE),
408 errmsg("relation \"%s\" already exists",
409 into->rel->relname)));
410
411 /*
412 * The relation exists and IF NOT EXISTS has been specified.
413 *
414 * If we are in an extension script, insist that the pre-existing
415 * object be a member of the extension, to avoid security risks.
416 */
417 ObjectAddressSet(address, RelationRelationId, oldrelid);
418 checkMembershipInCurrentExtension(&address);
419
420 /* OK to skip */
421 ereport(NOTICE,
422 (errcode(ERRCODE_DUPLICATE_TABLE),
423 errmsg("relation \"%s\" already exists, skipping",
424 into->rel->relname)));
425 return true;
426 }
427
428 /* Relation does not exist, it can be created */
429 return false;
430}
431
432/*
433 * CreateIntoRelDestReceiver -- create a suitable DestReceiver object
434 *
435 * intoClause will be NULL if called from CreateDestReceiver(), in which
436 * case it has to be provided later. However, it is convenient to allow
437 * self->into to be filled in immediately for other callers.
438 */
439DestReceiver *
440 CreateIntoRelDestReceiver(IntoClause *intoClause)
441{
442 DR_intorel *self = (DR_intorel *) palloc0(sizeof(DR_intorel));
443
444 self->pub.receiveSlot = intorel_receive;
445 self->pub.rStartup = intorel_startup;
446 self->pub.rShutdown = intorel_shutdown;
447 self->pub.rDestroy = intorel_destroy;
448 self->pub.mydest = DestIntoRel;
449 self->into = intoClause;
450 /* other private fields will be set during intorel_startup */
451
452 return (DestReceiver *) self;
453}
454
455/*
456 * intorel_startup --- executor startup
457 */
458static void
459 intorel_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
460{
461 DR_intorel *myState = (DR_intorel *) self;
462 IntoClause *into = myState->into;
463 bool is_matview;
464 List *attrList;
465 ObjectAddress intoRelationAddr;
466 Relation intoRelationDesc;
467 ListCell *lc;
468 int attnum;
469
470 Assert(into != NULL); /* else somebody forgot to set it */
471
472 /* This code supports both CREATE TABLE AS and CREATE MATERIALIZED VIEW */
473 is_matview = (into->viewQuery != NULL);
474
475 /*
476 * Build column definitions using "pre-cooked" type and collation info. If
477 * a column name list was specified in CREATE TABLE AS, override the
478 * column names derived from the query. (Too few column names are OK, too
479 * many are not.)
480 */
481 attrList = NIL;
482 lc = list_head(into->colNames);
483 for (attnum = 0; attnum < typeinfo->natts; attnum++)
484 {
485 Form_pg_attribute attribute = TupleDescAttr(typeinfo, attnum);
486 ColumnDef *col;
487 char *colname;
488
489 if (lc)
490 {
491 colname = strVal(lfirst(lc));
492 lc = lnext(into->colNames, lc);
493 }
494 else
495 colname = NameStr(attribute->attname);
496
497 col = makeColumnDef(colname,
498 attribute->atttypid,
499 attribute->atttypmod,
500 attribute->attcollation);
501
502 /*
503 * It's possible that the column is of a collatable type but the
504 * collation could not be resolved, so double-check. (We must check
505 * this here because DefineRelation would adopt the type's default
506 * collation rather than complaining.)
507 */
508 if (!OidIsValid(col->collOid) &&
509 type_is_collatable(col->typeName->typeOid))
510 ereport(ERROR,
511 (errcode(ERRCODE_INDETERMINATE_COLLATION),
512 errmsg("no collation was derived for column \"%s\" with collatable type %s",
513 col->colname,
514 format_type_be(col->typeName->typeOid)),
515 errhint("Use the COLLATE clause to set the collation explicitly.")));
516
517 attrList = lappend(attrList, col);
518 }
519
520 if (lc != NULL)
521 ereport(ERROR,
522 (errcode(ERRCODE_SYNTAX_ERROR),
523 errmsg("too many column names were specified")));
524
525 /*
526 * Actually create the target table
527 */
528 intoRelationAddr = create_ctas_internal(attrList, into);
529
530 /*
531 * Finally we can open the target table
532 */
533 intoRelationDesc = table_open(intoRelationAddr.objectId, AccessExclusiveLock);
534
535 /*
536 * Make sure the constructed table does not have RLS enabled.
537 *
538 * check_enable_rls() will ereport(ERROR) itself if the user has requested
539 * something invalid, and otherwise will return RLS_ENABLED if RLS should
540 * be enabled here. We don't actually support that currently, so throw
541 * our own ereport(ERROR) if that happens.
542 */
543 if (check_enable_rls(intoRelationAddr.objectId, InvalidOid, false) == RLS_ENABLED)
544 ereport(ERROR,
545 (errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
546 errmsg("policies not yet implemented for this command")));
547
548 /*
549 * Tentatively mark the target as populated, if it's a matview and we're
550 * going to fill it; otherwise, no change needed.
551 */
552 if (is_matview && !into->skipData)
553 SetMatViewPopulatedState(intoRelationDesc, true);
554
555 /*
556 * Fill private fields of myState for use by later routines
557 */
558 myState->rel = intoRelationDesc;
559 myState->reladdr = intoRelationAddr;
560 myState->output_cid = GetCurrentCommandId(true);
561 myState->ti_options = TABLE_INSERT_SKIP_FSM;
562
563 /*
564 * If WITH NO DATA is specified, there is no need to set up the state for
565 * bulk inserts as there are no tuples to insert.
566 */
567 if (!into->skipData)
568 myState->bistate = GetBulkInsertState();
569 else
570 myState->bistate = NULL;
571
572 /*
573 * Valid smgr_targblock implies something already wrote to the relation.
574 * This may be harmless, but this function hasn't planned for it.
575 */
576 Assert(RelationGetTargetBlock(intoRelationDesc) == InvalidBlockNumber);
577}
578
579/*
580 * intorel_receive --- receive one tuple
581 */
582static bool
583 intorel_receive(TupleTableSlot *slot, DestReceiver *self)
584{
585 DR_intorel *myState = (DR_intorel *) self;
586
587 /* Nothing to insert if WITH NO DATA is specified. */
588 if (!myState->into->skipData)
589 {
590 /*
591 * Note that the input slot might not be of the type of the target
592 * relation. That's supported by table_tuple_insert(), but slightly
593 * less efficient than inserting with the right slot - but the
594 * alternative would be to copy into a slot of the right type, which
595 * would not be cheap either. This also doesn't allow accessing per-AM
596 * data (say a tuple's xmin), but since we don't do that here...
597 */
598 table_tuple_insert(myState->rel,
599 slot,
600 myState->output_cid,
601 myState->ti_options,
602 myState->bistate);
603 }
604
605 /* We know this is a newly created relation, so there are no indexes */
606
607 return true;
608}
609
610/*
611 * intorel_shutdown --- executor end
612 */
613static void
614 intorel_shutdown(DestReceiver *self)
615{
616 DR_intorel *myState = (DR_intorel *) self;
617 IntoClause *into = myState->into;
618
619 if (!into->skipData)
620 {
621 FreeBulkInsertState(myState->bistate);
622 table_finish_bulk_insert(myState->rel, myState->ti_options);
623 }
624
625 /* close rel, but keep lock until commit */
626 table_close(myState->rel, NoLock);
627 myState->rel = NULL;
628}
629
630/*
631 * intorel_destroy --- release DestReceiver object
632 */
633static void
634 intorel_destroy(DestReceiver *self)
635{
636 pfree(self);
637}
void ExecuteQuery(ParseState *pstate, ExecuteStmt *stmt, IntoClause *intoClause, ParamListInfo params, DestReceiver *dest, QueryCompletion *qc)
Definition: prepare.c:150
#define InvalidBlockNumber
Definition: block.h:33
#define NameStr(name)
Definition: c.h:751
uint32 CommandId
Definition: c.h:671
#define OidIsValid(objectId)
Definition: c.h:774
static void SetQueryCompletion(QueryCompletion *qc, CommandTag commandTag, uint64 nprocessed)
Definition: cmdtag.h:37
int nspid
Definition: collationcmds.c:696
static void intorel_shutdown(DestReceiver *self)
Definition: createas.c:614
static ObjectAddress create_ctas_internal(List *attrList, IntoClause *into)
Definition: createas.c:82
bool CreateTableAsRelExists(CreateTableAsStmt *ctas)
Definition: createas.c:393
static ObjectAddress create_ctas_nodata(List *tlist, IntoClause *into)
Definition: createas.c:155
int GetIntoRelEFlags(IntoClause *intoClause)
Definition: createas.c:375
static bool intorel_receive(TupleTableSlot *slot, DestReceiver *self)
Definition: createas.c:583
DestReceiver * CreateIntoRelDestReceiver(IntoClause *intoClause)
Definition: createas.c:440
static void intorel_startup(DestReceiver *self, int operation, TupleDesc typeinfo)
Definition: createas.c:459
ObjectAddress ExecCreateTableAs(ParseState *pstate, CreateTableAsStmt *stmt, ParamListInfo params, QueryEnvironment *queryEnv, QueryCompletion *qc)
Definition: createas.c:223
static void intorel_destroy(DestReceiver *self)
Definition: createas.c:634
@ DestIntoRel
Definition: dest.h:94
int errhint(const char *fmt,...)
Definition: elog.c:1321
int errcode(int sqlerrcode)
Definition: elog.c:854
int errmsg(const char *fmt,...)
Definition: elog.c:1071
#define ERROR
Definition: elog.h:39
#define elog(elevel,...)
Definition: elog.h:226
#define NOTICE
Definition: elog.h:35
#define ereport(elevel,...)
Definition: elog.h:150
void ExecutorEnd(QueryDesc *queryDesc)
Definition: execMain.c:466
void ExecutorFinish(QueryDesc *queryDesc)
Definition: execMain.c:406
void ExecutorStart(QueryDesc *queryDesc, int eflags)
Definition: execMain.c:122
void ExecutorRun(QueryDesc *queryDesc, ScanDirection direction, uint64 count)
Definition: execMain.c:297
#define EXEC_FLAG_WITH_NO_DATA
Definition: executor.h:72
char * format_type_be(Oid type_oid)
Definition: format_type.c:343
Assert(PointerIsAligned(start, uint64))
BulkInsertState GetBulkInsertState(void)
Definition: heapam.c:2021
void FreeBulkInsertState(BulkInsertState bistate)
Definition: heapam.c:2038
#define stmt
Definition: indent_codes.h:59
List * lappend(List *list, void *datum)
Definition: list.c:339
#define NoLock
Definition: lockdefs.h:34
#define AccessExclusiveLock
Definition: lockdefs.h:43
bool type_is_collatable(Oid typid)
Definition: lsyscache.c:3248
Oid get_relname_relid(const char *relname, Oid relnamespace)
Definition: lsyscache.c:2052
ColumnDef * makeColumnDef(const char *colname, Oid typeOid, int32 typmod, Oid collOid)
Definition: makefuncs.c:565
void SetMatViewPopulatedState(Relation relation, bool newstate)
Definition: matview.c:79
ObjectAddress RefreshMatViewByOid(Oid matviewOid, bool is_create, bool skipData, bool concurrent, const char *queryString, QueryCompletion *qc)
Definition: matview.c:165
void pfree(void *pointer)
Definition: mcxt.c:1594
void * palloc0(Size size)
Definition: mcxt.c:1395
Oid RangeVarGetCreationNamespace(const RangeVar *newRelation)
Definition: namespace.c:653
dest
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
int32 exprTypmod(const Node *expr)
Definition: nodeFuncs.c:301
Oid exprCollation(const Node *expr)
Definition: nodeFuncs.c:821
#define IsA(nodeptr, _type_)
Definition: nodes.h:164
#define copyObject(obj)
Definition: nodes.h:232
@ CMD_UTILITY
Definition: nodes.h:280
@ CMD_SELECT
Definition: nodes.h:275
#define makeNode(_type_)
Definition: nodes.h:161
#define castNode(_type_, nodeptr)
Definition: nodes.h:182
const ObjectAddress InvalidObjectAddress
Definition: objectaddress.c:836
#define ObjectAddressSet(addr, class_id, object_id)
Definition: objectaddress.h:40
#define CURSOR_OPT_PARALLEL_OK
Definition: parsenodes.h:3396
post_parse_analyze_hook_type post_parse_analyze_hook
Definition: analyze.c:67
int16 attnum
Definition: pg_attribute.h:74
FormData_pg_attribute * Form_pg_attribute
Definition: pg_attribute.h:202
void checkMembershipInCurrentExtension(const ObjectAddress *object)
Definition: pg_depend.c:258
#define lfirst(lc)
Definition: pg_list.h:172
static int list_length(const List *l)
Definition: pg_list.h:152
#define linitial_node(type, l)
Definition: pg_list.h:181
#define NIL
Definition: pg_list.h:68
static ListCell * list_head(const List *l)
Definition: pg_list.h:128
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:343
#define plan(x)
Definition: pg_regress.c:161
PlannedStmt * pg_plan_query(Query *querytree, const char *query_string, int cursorOptions, ParamListInfo boundParams)
Definition: postgres.c:886
uint64_t Datum
Definition: postgres.h:70
#define InvalidOid
Definition: postgres_ext.h:37
unsigned int Oid
Definition: postgres_ext.h:32
void FreeQueryDesc(QueryDesc *qdesc)
Definition: pquery.c:106
QueryDesc * CreateQueryDesc(PlannedStmt *plannedstmt, const char *sourceText, Snapshot snapshot, Snapshot crosscheck_snapshot, DestReceiver *dest, ParamListInfo params, QueryEnvironment *queryEnv, int instrument_options)
Definition: pquery.c:68
static bool IsQueryIdEnabled(void)
Definition: queryjumble.h:104
JumbleState * JumbleQuery(Query *query)
#define RelationGetTargetBlock(relation)
Definition: rel.h:610
Datum transformRelOptions(Datum oldOptions, List *defList, const char *nameSpace, const char *const validnsps[], bool acceptOidsOff, bool isReset)
Definition: reloptions.c:1167
bytea * heap_reloptions(char relkind, Datum reloptions, bool validate)
Definition: reloptions.c:2055
#define HEAP_RELOPT_NAMESPACES
Definition: reloptions.h:61
List * QueryRewrite(Query *parsetree)
int check_enable_rls(Oid relid, Oid checkAsUser, bool noError)
Definition: rls.c:52
@ RLS_ENABLED
Definition: rls.h:45
@ ForwardScanDirection
Definition: sdir.h:28
void UpdateActiveSnapshotCommandId(void)
Definition: snapmgr.c:742
void PopActiveSnapshot(void)
Definition: snapmgr.c:773
void PushCopiedSnapshot(Snapshot snapshot)
Definition: snapmgr.c:730
Snapshot GetActiveSnapshot(void)
Definition: snapmgr.c:798
#define InvalidSnapshot
Definition: snapshot.h:119
char * colname
Definition: parsenodes.h:754
TypeName * typeName
Definition: parsenodes.h:755
Oid collOid
Definition: parsenodes.h:770
List * tableElts
Definition: parsenodes.h:2751
TypeName * ofTypename
Definition: parsenodes.h:2756
OnCommitAction oncommit
Definition: parsenodes.h:2760
List * options
Definition: parsenodes.h:2759
bool if_not_exists
Definition: parsenodes.h:2763
List * inhRelations
Definition: parsenodes.h:2752
RangeVar * relation
Definition: parsenodes.h:2750
char * tablespacename
Definition: parsenodes.h:2761
char * accessMethod
Definition: parsenodes.h:2762
List * constraints
Definition: parsenodes.h:2757
IntoClause * into
Definition: parsenodes.h:4028
Definition: createas.c:52
Relation rel
Definition: createas.c:56
ObjectAddress reladdr
Definition: createas.c:57
BulkInsertState bistate
Definition: createas.c:60
IntoClause * into
Definition: createas.c:54
int ti_options
Definition: createas.c:59
CommandId output_cid
Definition: createas.c:58
DestReceiver pub
Definition: createas.c:53
uint64 es_processed
Definition: execnodes.h:714
List * colNames
Definition: primnodes.h:164
char * tableSpaceName
Definition: primnodes.h:168
bool skipData
Definition: primnodes.h:171
OnCommitAction onCommit
Definition: primnodes.h:167
List * options
Definition: primnodes.h:166
char * accessMethod
Definition: primnodes.h:165
RangeVar * rel
Definition: primnodes.h:163
Definition: pg_list.h:54
Definition: nodes.h:135
const char * p_sourcetext
Definition: parse_node.h:195
EState * estate
Definition: execdesc.h:48
Definition: parsenodes.h:118
CmdType commandType
Definition: parsenodes.h:121
Node * utilityStmt
Definition: parsenodes.h:141
List * targetList
Definition: parsenodes.h:198
char * relname
Definition: primnodes.h:83
Definition: rel.h:56
Expr * expr
Definition: primnodes.h:2238
int natts
Definition: tupdesc.h:137
Oid typeOid
Definition: parsenodes.h:286
Definition: dest.h:116
void(* rStartup)(DestReceiver *self, int operation, TupleDesc typeinfo)
Definition: dest.h:121
void(* rShutdown)(DestReceiver *self)
Definition: dest.h:124
bool(* receiveSlot)(TupleTableSlot *slot, DestReceiver *self)
Definition: dest.h:118
void(* rDestroy)(DestReceiver *self)
Definition: dest.h:126
CommandDest mydest
Definition: dest.h:128
void table_close(Relation relation, LOCKMODE lockmode)
Definition: table.c:126
Relation table_open(Oid relationId, LOCKMODE lockmode)
Definition: table.c:40
#define TABLE_INSERT_SKIP_FSM
Definition: tableam.h:259
static void table_tuple_insert(Relation rel, TupleTableSlot *slot, CommandId cid, int options, BulkInsertStateData *bistate)
Definition: tableam.h:1367
static void table_finish_bulk_insert(Relation rel, int options)
Definition: tableam.h:1564
ObjectAddress DefineRelation(CreateStmt *stmt, char relkind, Oid ownerId, ObjectAddress *typaddress, const char *queryString)
Definition: tablecmds.c:765
void NewRelationCreateToastTable(Oid relOid, Datum reloptions)
Definition: toasting.c:71
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:160
Definition: pg_list.h:46
#define strVal(v)
Definition: value.h:82
void StoreViewQuery(Oid viewOid, Query *viewParse, bool replace)
Definition: view.c:511
void CommandCounterIncrement(void)
Definition: xact.c:1100
CommandId GetCurrentCommandId(bool used)
Definition: xact.c:829

AltStyle によって変換されたページ (->オリジナル) /