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

PostgreSQL Source Code git master
prepare.c
Go to the documentation of this file.
1/*-------------------------------------------------------------------------
2 *
3 * prepare.c
4 * Prepareable SQL statements via PREPARE, EXECUTE and DEALLOCATE
5 *
6 * This module also implements storage of prepared statements that are
7 * accessed via the extended FE/BE query protocol.
8 *
9 *
10 * Copyright (c) 2002-2025, PostgreSQL Global Development Group
11 *
12 * IDENTIFICATION
13 * src/backend/commands/prepare.c
14 *
15 *-------------------------------------------------------------------------
16 */
17#include "postgres.h"
18
19#include <limits.h>
20
21#include "access/xact.h"
22#include "catalog/pg_type.h"
23#include "commands/createas.h"
24#include "commands/explain.h"
25#include "commands/explain_format.h"
26#include "commands/explain_state.h"
27#include "commands/prepare.h"
28#include "funcapi.h"
29#include "nodes/nodeFuncs.h"
30#include "parser/parse_coerce.h"
31#include "parser/parse_collate.h"
32#include "parser/parse_expr.h"
33#include "parser/parse_type.h"
34#include "tcop/pquery.h"
35#include "tcop/utility.h"
36#include "utils/builtins.h"
37#include "utils/snapmgr.h"
38#include "utils/timestamp.h"
39
40
41/*
42 * The hash table in which prepared queries are stored. This is
43 * per-backend: query plans are not shared between backends.
44 * The keys for this hash table are the arguments to PREPARE and EXECUTE
45 * (statement names); the entries are PreparedStatement structs.
46 */
47 static HTAB *prepared_queries = NULL;
48
49static void InitQueryHashTable(void);
50static ParamListInfo EvaluateParams(ParseState *pstate,
51 PreparedStatement *pstmt, List *params,
52 EState *estate);
53static Datum build_regtype_array(Oid *param_types, int num_params);
54
55/*
56 * Implements the 'PREPARE' utility statement.
57 */
58void
59 PrepareQuery(ParseState *pstate, PrepareStmt *stmt,
60 int stmt_location, int stmt_len)
61{
62 RawStmt *rawstmt;
63 CachedPlanSource *plansource;
64 Oid *argtypes = NULL;
65 int nargs;
66 List *query_list;
67
68 /*
69 * Disallow empty-string statement name (conflicts with protocol-level
70 * unnamed statement).
71 */
72 if (!stmt->name || stmt->name[0] == '0円')
73 ereport(ERROR,
74 (errcode(ERRCODE_INVALID_PSTATEMENT_DEFINITION),
75 errmsg("invalid statement name: must not be empty")));
76
77 /*
78 * Need to wrap the contained statement in a RawStmt node to pass it to
79 * parse analysis.
80 */
81 rawstmt = makeNode(RawStmt);
82 rawstmt->stmt = stmt->query;
83 rawstmt->stmt_location = stmt_location;
84 rawstmt->stmt_len = stmt_len;
85
86 /*
87 * Create the CachedPlanSource before we do parse analysis, since it needs
88 * to see the unmodified raw parse tree.
89 */
90 plansource = CreateCachedPlan(rawstmt, pstate->p_sourcetext,
91 CreateCommandTag(stmt->query));
92
93 /* Transform list of TypeNames to array of type OIDs */
94 nargs = list_length(stmt->argtypes);
95
96 if (nargs)
97 {
98 int i;
99 ListCell *l;
100
101 argtypes = palloc_array(Oid, nargs);
102 i = 0;
103
104 foreach(l, stmt->argtypes)
105 {
106 TypeName *tn = lfirst(l);
107 Oid toid = typenameTypeId(pstate, tn);
108
109 argtypes[i++] = toid;
110 }
111 }
112
113 /*
114 * Analyze the statement using these parameter types (any parameters
115 * passed in from above us will not be visible to it), allowing
116 * information about unknown parameters to be deduced from context.
117 * Rewrite the query. The result could be 0, 1, or many queries.
118 */
119 query_list = pg_analyze_and_rewrite_varparams(rawstmt, pstate->p_sourcetext,
120 &argtypes, &nargs, NULL);
121
122 /* Finish filling in the CachedPlanSource */
123 CompleteCachedPlan(plansource,
124 query_list,
125 NULL,
126 argtypes,
127 nargs,
128 NULL,
129 NULL,
130 CURSOR_OPT_PARALLEL_OK, /* allow parallel mode */
131 true); /* fixed result */
132
133 /*
134 * Save the results.
135 */
136 StorePreparedStatement(stmt->name,
137 plansource,
138 true);
139}
140
141/*
142 * ExecuteQuery --- implement the 'EXECUTE' utility statement.
143 *
144 * This code also supports CREATE TABLE ... AS EXECUTE. That case is
145 * indicated by passing a non-null intoClause. The DestReceiver is already
146 * set up correctly for CREATE TABLE AS, but we still have to make a few
147 * other adjustments here.
148 */
149void
150 ExecuteQuery(ParseState *pstate,
151 ExecuteStmt *stmt, IntoClause *intoClause,
152 ParamListInfo params,
153 DestReceiver *dest, QueryCompletion *qc)
154{
155 PreparedStatement *entry;
156 CachedPlan *cplan;
157 List *plan_list;
158 ParamListInfo paramLI = NULL;
159 EState *estate = NULL;
160 Portal portal;
161 char *query_string;
162 int eflags;
163 long count;
164
165 /* Look it up in the hash table */
166 entry = FetchPreparedStatement(stmt->name, true);
167
168 /* Shouldn't find a non-fixed-result cached plan */
169 if (!entry->plansource->fixed_result)
170 elog(ERROR, "EXECUTE does not support variable-result cached plans");
171
172 /* Evaluate parameters, if any */
173 if (entry->plansource->num_params > 0)
174 {
175 /*
176 * Need an EState to evaluate parameters; must not delete it till end
177 * of query, in case parameters are pass-by-reference. Note that the
178 * passed-in "params" could possibly be referenced in the parameter
179 * expressions.
180 */
181 estate = CreateExecutorState();
182 estate->es_param_list_info = params;
183 paramLI = EvaluateParams(pstate, entry, stmt->params, estate);
184 }
185
186 /* Create a new portal to run the query in */
187 portal = CreateNewPortal();
188 /* Don't display the portal in pg_cursors, it is for internal use only */
189 portal->visible = false;
190
191 /* Copy the plan's saved query string into the portal's memory */
192 query_string = MemoryContextStrdup(portal->portalContext,
193 entry->plansource->query_string);
194
195 /* Replan if needed, and increment plan refcount for portal */
196 cplan = GetCachedPlan(entry->plansource, paramLI, NULL, NULL);
197 plan_list = cplan->stmt_list;
198
199 /*
200 * DO NOT add any logic that could possibly throw an error between
201 * GetCachedPlan and PortalDefineQuery, or you'll leak the plan refcount.
202 */
203 PortalDefineQuery(portal,
204 NULL,
205 query_string,
206 entry->plansource->commandTag,
207 plan_list,
208 cplan);
209
210 /*
211 * For CREATE TABLE ... AS EXECUTE, we must verify that the prepared
212 * statement is one that produces tuples. Currently we insist that it be
213 * a plain old SELECT. In future we might consider supporting other
214 * things such as INSERT ... RETURNING, but there are a couple of issues
215 * to be settled first, notably how WITH NO DATA should be handled in such
216 * a case (do we really want to suppress execution?) and how to pass down
217 * the OID-determining eflags (PortalStart won't handle them in such a
218 * case, and for that matter it's not clear the executor will either).
219 *
220 * For CREATE TABLE ... AS EXECUTE, we also have to ensure that the proper
221 * eflags and fetch count are passed to PortalStart/PortalRun.
222 */
223 if (intoClause)
224 {
225 PlannedStmt *pstmt;
226
227 if (list_length(plan_list) != 1)
228 ereport(ERROR,
229 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
230 errmsg("prepared statement is not a SELECT")));
231 pstmt = linitial_node(PlannedStmt, plan_list);
232 if (pstmt->commandType != CMD_SELECT)
233 ereport(ERROR,
234 (errcode(ERRCODE_WRONG_OBJECT_TYPE),
235 errmsg("prepared statement is not a SELECT")));
236
237 /* Set appropriate eflags */
238 eflags = GetIntoRelEFlags(intoClause);
239
240 /* And tell PortalRun whether to run to completion or not */
241 if (intoClause->skipData)
242 count = 0;
243 else
244 count = FETCH_ALL;
245 }
246 else
247 {
248 /* Plain old EXECUTE */
249 eflags = 0;
250 count = FETCH_ALL;
251 }
252
253 /*
254 * Run the portal as appropriate.
255 */
256 PortalStart(portal, paramLI, eflags, GetActiveSnapshot());
257
258 (void) PortalRun(portal, count, false, dest, dest, qc);
259
260 PortalDrop(portal, false);
261
262 if (estate)
263 FreeExecutorState(estate);
264
265 /* No need to pfree other memory, MemoryContext will be reset */
266}
267
268/*
269 * EvaluateParams: evaluate a list of parameters.
270 *
271 * pstate: parse state
272 * pstmt: statement we are getting parameters for.
273 * params: list of given parameter expressions (raw parser output!)
274 * estate: executor state to use.
275 *
276 * Returns a filled-in ParamListInfo -- this can later be passed to
277 * CreateQueryDesc(), which allows the executor to make use of the parameters
278 * during query execution.
279 */
280static ParamListInfo
281 EvaluateParams(ParseState *pstate, PreparedStatement *pstmt, List *params,
282 EState *estate)
283{
284 Oid *param_types = pstmt->plansource->param_types;
285 int num_params = pstmt->plansource->num_params;
286 int nparams = list_length(params);
287 ParamListInfo paramLI;
288 List *exprstates;
289 ListCell *l;
290 int i;
291
292 if (nparams != num_params)
293 ereport(ERROR,
294 (errcode(ERRCODE_SYNTAX_ERROR),
295 errmsg("wrong number of parameters for prepared statement \"%s\"",
296 pstmt->stmt_name),
297 errdetail("Expected %d parameters but got %d.",
298 num_params, nparams)));
299
300 /* Quick exit if no parameters */
301 if (num_params == 0)
302 return NULL;
303
304 /*
305 * We have to run parse analysis for the expressions. Since the parser is
306 * not cool about scribbling on its input, copy first.
307 */
308 params = copyObject(params);
309
310 i = 0;
311 foreach(l, params)
312 {
313 Node *expr = lfirst(l);
314 Oid expected_type_id = param_types[i];
315 Oid given_type_id;
316
317 expr = transformExpr(pstate, expr, EXPR_KIND_EXECUTE_PARAMETER);
318
319 given_type_id = exprType(expr);
320
321 expr = coerce_to_target_type(pstate, expr, given_type_id,
322 expected_type_id, -1,
323 COERCION_ASSIGNMENT,
324 COERCE_IMPLICIT_CAST,
325 -1);
326
327 if (expr == NULL)
328 ereport(ERROR,
329 (errcode(ERRCODE_DATATYPE_MISMATCH),
330 errmsg("parameter $%d of type %s cannot be coerced to the expected type %s",
331 i + 1,
332 format_type_be(given_type_id),
333 format_type_be(expected_type_id)),
334 errhint("You will need to rewrite or cast the expression."),
335 parser_errposition(pstate, exprLocation(lfirst(l)))));
336
337 /* Take care of collations in the finished expression. */
338 assign_expr_collations(pstate, expr);
339
340 lfirst(l) = expr;
341 i++;
342 }
343
344 /* Prepare the expressions for execution */
345 exprstates = ExecPrepareExprList(params, estate);
346
347 paramLI = makeParamList(num_params);
348
349 i = 0;
350 foreach(l, exprstates)
351 {
352 ExprState *n = (ExprState *) lfirst(l);
353 ParamExternData *prm = &paramLI->params[i];
354
355 prm->ptype = param_types[i];
356 prm->pflags = PARAM_FLAG_CONST;
357 prm->value = ExecEvalExprSwitchContext(n,
358 GetPerTupleExprContext(estate),
359 &prm->isnull);
360
361 i++;
362 }
363
364 return paramLI;
365}
366
367
368/*
369 * Initialize query hash table upon first use.
370 */
371static void
372 InitQueryHashTable(void)
373{
374 HASHCTL hash_ctl;
375
376 hash_ctl.keysize = NAMEDATALEN;
377 hash_ctl.entrysize = sizeof(PreparedStatement);
378
379 prepared_queries = hash_create("Prepared Queries",
380 32,
381 &hash_ctl,
382 HASH_ELEM | HASH_STRINGS);
383}
384
385/*
386 * Store all the data pertaining to a query in the hash table using
387 * the specified key. The passed CachedPlanSource should be "unsaved"
388 * in case we get an error here; we'll save it once we've created the hash
389 * table entry.
390 */
391void
392 StorePreparedStatement(const char *stmt_name,
393 CachedPlanSource *plansource,
394 bool from_sql)
395{
396 PreparedStatement *entry;
397 TimestampTz cur_ts = GetCurrentStatementStartTimestamp();
398 bool found;
399
400 /* Initialize the hash table, if necessary */
401 if (!prepared_queries)
402 InitQueryHashTable();
403
404 /* Add entry to hash table */
405 entry = (PreparedStatement *) hash_search(prepared_queries,
406 stmt_name,
407 HASH_ENTER,
408 &found);
409
410 /* Shouldn't get a duplicate entry */
411 if (found)
412 ereport(ERROR,
413 (errcode(ERRCODE_DUPLICATE_PSTATEMENT),
414 errmsg("prepared statement \"%s\" already exists",
415 stmt_name)));
416
417 /* Fill in the hash table entry */
418 entry->plansource = plansource;
419 entry->from_sql = from_sql;
420 entry->prepare_time = cur_ts;
421
422 /* Now it's safe to move the CachedPlanSource to permanent memory */
423 SaveCachedPlan(plansource);
424}
425
426/*
427 * Lookup an existing query in the hash table. If the query does not
428 * actually exist, throw ereport(ERROR) or return NULL per second parameter.
429 *
430 * Note: this does not force the referenced plancache entry to be valid,
431 * since not all callers care.
432 */
433PreparedStatement *
434 FetchPreparedStatement(const char *stmt_name, bool throwError)
435{
436 PreparedStatement *entry;
437
438 /*
439 * If the hash table hasn't been initialized, it can't be storing
440 * anything, therefore it couldn't possibly store our plan.
441 */
442 if (prepared_queries)
443 entry = (PreparedStatement *) hash_search(prepared_queries,
444 stmt_name,
445 HASH_FIND,
446 NULL);
447 else
448 entry = NULL;
449
450 if (!entry && throwError)
451 ereport(ERROR,
452 (errcode(ERRCODE_UNDEFINED_PSTATEMENT),
453 errmsg("prepared statement \"%s\" does not exist",
454 stmt_name)));
455
456 return entry;
457}
458
459/*
460 * Given a prepared statement, determine the result tupledesc it will
461 * produce. Returns NULL if the execution will not return tuples.
462 *
463 * Note: the result is created or copied into current memory context.
464 */
465TupleDesc
466 FetchPreparedStatementResultDesc(PreparedStatement *stmt)
467{
468 /*
469 * Since we don't allow prepared statements' result tupdescs to change,
470 * there's no need to worry about revalidating the cached plan here.
471 */
472 Assert(stmt->plansource->fixed_result);
473 if (stmt->plansource->resultDesc)
474 return CreateTupleDescCopy(stmt->plansource->resultDesc);
475 else
476 return NULL;
477}
478
479/*
480 * Given a prepared statement that returns tuples, extract the query
481 * targetlist. Returns NIL if the statement doesn't have a determinable
482 * targetlist.
483 *
484 * Note: this is pretty ugly, but since it's only used in corner cases like
485 * Describe Statement on an EXECUTE command, we don't worry too much about
486 * efficiency.
487 */
488List *
489 FetchPreparedStatementTargetList(PreparedStatement *stmt)
490{
491 List *tlist;
492
493 /* Get the plan's primary targetlist */
494 tlist = CachedPlanGetTargetList(stmt->plansource, NULL);
495
496 /* Copy into caller's context in case plan gets invalidated */
497 return copyObject(tlist);
498}
499
500/*
501 * Implements the 'DEALLOCATE' utility statement: deletes the
502 * specified plan from storage.
503 */
504void
505 DeallocateQuery(DeallocateStmt *stmt)
506{
507 if (stmt->name)
508 DropPreparedStatement(stmt->name, true);
509 else
510 DropAllPreparedStatements();
511}
512
513/*
514 * Internal version of DEALLOCATE
515 *
516 * If showError is false, dropping a nonexistent statement is a no-op.
517 */
518void
519 DropPreparedStatement(const char *stmt_name, bool showError)
520{
521 PreparedStatement *entry;
522
523 /* Find the query's hash table entry; raise error if wanted */
524 entry = FetchPreparedStatement(stmt_name, showError);
525
526 if (entry)
527 {
528 /* Release the plancache entry */
529 DropCachedPlan(entry->plansource);
530
531 /* Now we can remove the hash table entry */
532 hash_search(prepared_queries, entry->stmt_name, HASH_REMOVE, NULL);
533 }
534}
535
536/*
537 * Drop all cached statements.
538 */
539void
540 DropAllPreparedStatements(void)
541{
542 HASH_SEQ_STATUS seq;
543 PreparedStatement *entry;
544
545 /* nothing cached */
546 if (!prepared_queries)
547 return;
548
549 /* walk over cache */
550 hash_seq_init(&seq, prepared_queries);
551 while ((entry = hash_seq_search(&seq)) != NULL)
552 {
553 /* Release the plancache entry */
554 DropCachedPlan(entry->plansource);
555
556 /* Now we can remove the hash table entry */
557 hash_search(prepared_queries, entry->stmt_name, HASH_REMOVE, NULL);
558 }
559}
560
561/*
562 * Implements the 'EXPLAIN EXECUTE' utility statement.
563 *
564 * "into" is NULL unless we are doing EXPLAIN CREATE TABLE AS EXECUTE,
565 * in which case executing the query should result in creating that table.
566 *
567 * Note: the passed-in pstate's queryString is that of the EXPLAIN EXECUTE,
568 * not the original PREPARE; we get the latter string from the plancache.
569 */
570void
571 ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es,
572 ParseState *pstate, ParamListInfo params)
573{
574 PreparedStatement *entry;
575 const char *query_string;
576 CachedPlan *cplan;
577 List *plan_list;
578 ListCell *p;
579 ParamListInfo paramLI = NULL;
580 EState *estate = NULL;
581 instr_time planstart;
582 instr_time planduration;
583 BufferUsage bufusage_start,
584 bufusage;
585 MemoryContextCounters mem_counters;
586 MemoryContext planner_ctx = NULL;
587 MemoryContext saved_ctx = NULL;
588
589 if (es->memory)
590 {
591 /* See ExplainOneQuery about this */
592 Assert(IsA(CurrentMemoryContext, AllocSetContext));
593 planner_ctx = AllocSetContextCreate(CurrentMemoryContext,
594 "explain analyze planner context",
595 ALLOCSET_DEFAULT_SIZES);
596 saved_ctx = MemoryContextSwitchTo(planner_ctx);
597 }
598
599 if (es->buffers)
600 bufusage_start = pgBufferUsage;
601 INSTR_TIME_SET_CURRENT(planstart);
602
603 /* Look it up in the hash table */
604 entry = FetchPreparedStatement(execstmt->name, true);
605
606 /* Shouldn't find a non-fixed-result cached plan */
607 if (!entry->plansource->fixed_result)
608 elog(ERROR, "EXPLAIN EXECUTE does not support variable-result cached plans");
609
610 query_string = entry->plansource->query_string;
611
612 /* Evaluate parameters, if any */
613 if (entry->plansource->num_params)
614 {
615 ParseState *pstate_params;
616
617 pstate_params = make_parsestate(NULL);
618 pstate_params->p_sourcetext = pstate->p_sourcetext;
619
620 /*
621 * Need an EState to evaluate parameters; must not delete it till end
622 * of query, in case parameters are pass-by-reference. Note that the
623 * passed-in "params" could possibly be referenced in the parameter
624 * expressions.
625 */
626 estate = CreateExecutorState();
627 estate->es_param_list_info = params;
628
629 paramLI = EvaluateParams(pstate_params, entry, execstmt->params, estate);
630 }
631
632 /* Replan if needed, and acquire a transient refcount */
633 cplan = GetCachedPlan(entry->plansource, paramLI,
634 CurrentResourceOwner, pstate->p_queryEnv);
635
636 INSTR_TIME_SET_CURRENT(planduration);
637 INSTR_TIME_SUBTRACT(planduration, planstart);
638
639 if (es->memory)
640 {
641 MemoryContextSwitchTo(saved_ctx);
642 MemoryContextMemConsumed(planner_ctx, &mem_counters);
643 }
644
645 /* calc differences of buffer counters. */
646 if (es->buffers)
647 {
648 memset(&bufusage, 0, sizeof(BufferUsage));
649 BufferUsageAccumDiff(&bufusage, &pgBufferUsage, &bufusage_start);
650 }
651
652 plan_list = cplan->stmt_list;
653
654 /* Explain each query */
655 foreach(p, plan_list)
656 {
657 PlannedStmt *pstmt = lfirst_node(PlannedStmt, p);
658
659 if (pstmt->commandType != CMD_UTILITY)
660 ExplainOnePlan(pstmt, into, es, query_string, paramLI, pstate->p_queryEnv,
661 &planduration, (es->buffers ? &bufusage : NULL),
662 es->memory ? &mem_counters : NULL);
663 else
664 ExplainOneUtility(pstmt->utilityStmt, into, es, pstate, paramLI);
665
666 /* No need for CommandCounterIncrement, as ExplainOnePlan did it */
667
668 /* Separate plans with an appropriate separator */
669 if (lnext(plan_list, p) != NULL)
670 ExplainSeparatePlans(es);
671 }
672
673 if (estate)
674 FreeExecutorState(estate);
675
676 ReleaseCachedPlan(cplan, CurrentResourceOwner);
677}
678
679/*
680 * This set returning function reads all the prepared statements and
681 * returns a set of (name, statement, prepare_time, param_types, from_sql,
682 * generic_plans, custom_plans).
683 */
684Datum
685 pg_prepared_statement(PG_FUNCTION_ARGS)
686{
687 ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
688
689 /*
690 * We put all the tuples into a tuplestore in one scan of the hashtable.
691 * This avoids any issue of the hashtable possibly changing between calls.
692 */
693 InitMaterializedSRF(fcinfo, 0);
694
695 /* hash table might be uninitialized */
696 if (prepared_queries)
697 {
698 HASH_SEQ_STATUS hash_seq;
699 PreparedStatement *prep_stmt;
700
701 hash_seq_init(&hash_seq, prepared_queries);
702 while ((prep_stmt = hash_seq_search(&hash_seq)) != NULL)
703 {
704 TupleDesc result_desc;
705 Datum values[8];
706 bool nulls[8] = {0};
707
708 result_desc = prep_stmt->plansource->resultDesc;
709
710 values[0] = CStringGetTextDatum(prep_stmt->stmt_name);
711 values[1] = CStringGetTextDatum(prep_stmt->plansource->query_string);
712 values[2] = TimestampTzGetDatum(prep_stmt->prepare_time);
713 values[3] = build_regtype_array(prep_stmt->plansource->param_types,
714 prep_stmt->plansource->num_params);
715 if (result_desc)
716 {
717 Oid *result_types;
718
719 result_types = palloc_array(Oid, result_desc->natts);
720 for (int i = 0; i < result_desc->natts; i++)
721 result_types[i] = TupleDescAttr(result_desc, i)->atttypid;
722 values[4] = build_regtype_array(result_types, result_desc->natts);
723 }
724 else
725 {
726 /* no result descriptor (for example, DML statement) */
727 nulls[4] = true;
728 }
729 values[5] = BoolGetDatum(prep_stmt->from_sql);
730 values[6] = Int64GetDatumFast(prep_stmt->plansource->num_generic_plans);
731 values[7] = Int64GetDatumFast(prep_stmt->plansource->num_custom_plans);
732
733 tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
734 values, nulls);
735 }
736 }
737
738 return (Datum) 0;
739}
740
741/*
742 * This utility function takes a C array of Oids, and returns a Datum
743 * pointing to a one-dimensional Postgres array of regtypes. An empty
744 * array is returned as a zero-element array, not NULL.
745 */
746static Datum
747 build_regtype_array(Oid *param_types, int num_params)
748{
749 Datum *tmp_ary;
750 ArrayType *result;
751 int i;
752
753 tmp_ary = palloc_array(Datum, num_params);
754
755 for (i = 0; i < num_params; i++)
756 tmp_ary[i] = ObjectIdGetDatum(param_types[i]);
757
758 result = construct_array_builtin(tmp_ary, num_params, REGTYPEOID);
759 return PointerGetDatum(result);
760}
ArrayType * construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
Definition: arrayfuncs.c:3382
static HTAB * prepared_queries
Definition: prepare.c:47
void DropPreparedStatement(const char *stmt_name, bool showError)
Definition: prepare.c:519
void PrepareQuery(ParseState *pstate, PrepareStmt *stmt, int stmt_location, int stmt_len)
Definition: prepare.c:59
static void InitQueryHashTable(void)
Definition: prepare.c:372
TupleDesc FetchPreparedStatementResultDesc(PreparedStatement *stmt)
Definition: prepare.c:466
Datum pg_prepared_statement(PG_FUNCTION_ARGS)
Definition: prepare.c:685
PreparedStatement * FetchPreparedStatement(const char *stmt_name, bool throwError)
Definition: prepare.c:434
void ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es, ParseState *pstate, ParamListInfo params)
Definition: prepare.c:571
static ParamListInfo EvaluateParams(ParseState *pstate, PreparedStatement *pstmt, List *params, EState *estate)
Definition: prepare.c:281
void StorePreparedStatement(const char *stmt_name, CachedPlanSource *plansource, bool from_sql)
Definition: prepare.c:392
static Datum build_regtype_array(Oid *param_types, int num_params)
Definition: prepare.c:747
void ExecuteQuery(ParseState *pstate, ExecuteStmt *stmt, IntoClause *intoClause, ParamListInfo params, DestReceiver *dest, QueryCompletion *qc)
Definition: prepare.c:150
void DropAllPreparedStatements(void)
Definition: prepare.c:540
List * FetchPreparedStatementTargetList(PreparedStatement *stmt)
Definition: prepare.c:489
void DeallocateQuery(DeallocateStmt *stmt)
Definition: prepare.c:505
static Datum values[MAXATTR]
Definition: bootstrap.c:153
#define CStringGetTextDatum(s)
Definition: builtins.h:97
int GetIntoRelEFlags(IntoClause *intoClause)
Definition: createas.c:375
int64 TimestampTz
Definition: timestamp.h:39
void * hash_search(HTAB *hashp, const void *keyPtr, HASHACTION action, bool *foundPtr)
Definition: dynahash.c:952
HTAB * hash_create(const char *tabname, int64 nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:358
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1415
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1380
int errdetail(const char *fmt,...)
Definition: elog.c:1207
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 ereport(elevel,...)
Definition: elog.h:150
List * ExecPrepareExprList(List *nodes, EState *estate)
Definition: execExpr.c:839
void FreeExecutorState(EState *estate)
Definition: execUtils.c:192
EState * CreateExecutorState(void)
Definition: execUtils.c:88
#define GetPerTupleExprContext(estate)
Definition: executor.h:653
static Datum ExecEvalExprSwitchContext(ExprState *state, ExprContext *econtext, bool *isNull)
Definition: executor.h:433
void ExplainOnePlan(PlannedStmt *plannedstmt, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv, const instr_time *planduration, const BufferUsage *bufusage, const MemoryContextCounters *mem_counters)
Definition: explain.c:495
void ExplainOneUtility(Node *utilityStmt, IntoClause *into, ExplainState *es, ParseState *pstate, ParamListInfo params)
Definition: explain.c:391
void ExplainSeparatePlans(ExplainState *es)
#define palloc_array(type, count)
Definition: fe_memutils.h:76
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
char * format_type_be(Oid type_oid)
Definition: format_type.c:343
void InitMaterializedSRF(FunctionCallInfo fcinfo, bits32 flags)
Definition: funcapi.c:76
Assert(PointerIsAligned(start, uint64))
#define HASH_STRINGS
Definition: hsearch.h:96
@ HASH_FIND
Definition: hsearch.h:113
@ HASH_REMOVE
Definition: hsearch.h:115
@ HASH_ENTER
Definition: hsearch.h:114
#define HASH_ELEM
Definition: hsearch.h:95
#define stmt
Definition: indent_codes.h:59
#define INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:122
#define INSTR_TIME_SUBTRACT(x, y)
Definition: instr_time.h:181
BufferUsage pgBufferUsage
Definition: instrument.c:20
void BufferUsageAccumDiff(BufferUsage *dst, const BufferUsage *add, const BufferUsage *sub)
Definition: instrument.c:248
i
int i
Definition: isn.c:77
char * MemoryContextStrdup(MemoryContext context, const char *string)
Definition: mcxt.c:1746
void MemoryContextMemConsumed(MemoryContext context, MemoryContextCounters *consumed)
Definition: mcxt.c:832
MemoryContext CurrentMemoryContext
Definition: mcxt.c:160
#define AllocSetContextCreate
Definition: memutils.h:129
#define ALLOCSET_DEFAULT_SIZES
Definition: memutils.h:160
dest
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:42
int exprLocation(const Node *expr)
Definition: nodeFuncs.c:1388
#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
static MemoryContext MemoryContextSwitchTo(MemoryContext context)
Definition: palloc.h:124
ParamListInfo makeParamList(int numParams)
Definition: params.c:44
#define PARAM_FLAG_CONST
Definition: params.h:87
Node * coerce_to_target_type(ParseState *pstate, Node *expr, Oid exprtype, Oid targettype, int32 targettypmod, CoercionContext ccontext, CoercionForm cformat, int location)
Definition: parse_coerce.c:79
void assign_expr_collations(ParseState *pstate, Node *expr)
Definition: parse_collate.c:177
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
Definition: parse_expr.c:118
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:106
ParseState * make_parsestate(ParseState *parentParseState)
Definition: parse_node.c:39
@ EXPR_KIND_EXECUTE_PARAMETER
Definition: parse_node.h:76
Oid typenameTypeId(ParseState *pstate, const TypeName *typeName)
Definition: parse_type.c:291
#define FETCH_ALL
Definition: parsenodes.h:3447
#define CURSOR_OPT_PARALLEL_OK
Definition: parsenodes.h:3396
#define NAMEDATALEN
#define lfirst(lc)
Definition: pg_list.h:172
#define lfirst_node(type, lc)
Definition: pg_list.h:176
static int list_length(const List *l)
Definition: pg_list.h:152
#define linitial_node(type, l)
Definition: pg_list.h:181
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:343
void DropCachedPlan(CachedPlanSource *plansource)
Definition: plancache.c:589
void SaveCachedPlan(CachedPlanSource *plansource)
Definition: plancache.c:545
void CompleteCachedPlan(CachedPlanSource *plansource, List *querytree_list, MemoryContext querytree_context, Oid *param_types, int num_params, ParserSetupHook parserSetup, void *parserSetupArg, int cursor_options, bool fixed_result)
Definition: plancache.c:391
CachedPlan * GetCachedPlan(CachedPlanSource *plansource, ParamListInfo boundParams, ResourceOwner owner, QueryEnvironment *queryEnv)
Definition: plancache.c:1295
CachedPlanSource * CreateCachedPlan(RawStmt *raw_parse_tree, const char *query_string, CommandTag commandTag)
Definition: plancache.c:183
List * CachedPlanGetTargetList(CachedPlanSource *plansource, QueryEnvironment *queryEnv)
Definition: plancache.c:1778
void ReleaseCachedPlan(CachedPlan *plan, ResourceOwner owner)
Definition: plancache.c:1426
Portal CreateNewPortal(void)
Definition: portalmem.c:235
void PortalDrop(Portal portal, bool isTopCommit)
Definition: portalmem.c:468
void PortalDefineQuery(Portal portal, const char *prepStmtName, const char *sourceText, CommandTag commandTag, List *stmts, CachedPlan *cplan)
Definition: portalmem.c:282
List * pg_analyze_and_rewrite_varparams(RawStmt *parsetree, const char *query_string, Oid **paramTypes, int *numParams, QueryEnvironment *queryEnv)
Definition: postgres.c:708
#define Int64GetDatumFast(X)
Definition: postgres.h:515
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:332
static Datum BoolGetDatum(bool X)
Definition: postgres.h:112
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:262
uint64_t Datum
Definition: postgres.h:70
unsigned int Oid
Definition: postgres_ext.h:32
void PortalStart(Portal portal, ParamListInfo params, int eflags, Snapshot snapshot)
Definition: pquery.c:434
bool PortalRun(Portal portal, long count, bool isTopLevel, DestReceiver *dest, DestReceiver *altdest, QueryCompletion *qc)
Definition: pquery.c:685
@ COERCE_IMPLICIT_CAST
Definition: primnodes.h:768
@ COERCION_ASSIGNMENT
Definition: primnodes.h:747
ResourceOwner CurrentResourceOwner
Definition: resowner.c:173
Snapshot GetActiveSnapshot(void)
Definition: snapmgr.c:798
Definition: array.h:93
Oid * param_types
Definition: plancache.h:112
bool fixed_result
Definition: plancache.h:119
CommandTag commandTag
Definition: plancache.h:111
const char * query_string
Definition: plancache.h:110
TupleDesc resultDesc
Definition: plancache.h:120
int64 num_custom_plans
Definition: plancache.h:145
int64 num_generic_plans
Definition: plancache.h:146
List * stmt_list
Definition: plancache.h:162
Definition: execnodes.h:655
ParamListInfo es_param_list_info
Definition: execnodes.h:704
List * params
Definition: parsenodes.h:4185
char * name
Definition: parsenodes.h:4184
bool buffers
Definition: explain_state.h:51
Definition: hsearch.h:66
Size keysize
Definition: hsearch.h:75
Size entrysize
Definition: hsearch.h:76
Definition: hsearch.h:121
Definition: dynahash.c:222
bool skipData
Definition: primnodes.h:171
Definition: pg_list.h:54
Definition: nodes.h:135
bool isnull
Definition: params.h:92
uint16 pflags
Definition: params.h:93
Oid ptype
Definition: params.h:94
Datum value
Definition: params.h:91
ParamExternData params[FLEXIBLE_ARRAY_MEMBER]
Definition: params.h:124
QueryEnvironment * p_queryEnv
Definition: parse_node.h:223
const char * p_sourcetext
Definition: parse_node.h:195
CmdType commandType
Definition: plannodes.h:68
Node * utilityStmt
Definition: plannodes.h:150
MemoryContext portalContext
Definition: portal.h:120
bool visible
Definition: portal.h:204
char stmt_name[NAMEDATALEN]
Definition: prepare.h:31
TimestampTz prepare_time
Definition: prepare.h:34
bool from_sql
Definition: prepare.h:33
CachedPlanSource * plansource
Definition: prepare.h:32
ParseLoc stmt_location
Definition: parsenodes.h:2089
ParseLoc stmt_len
Definition: parsenodes.h:2090
Node * stmt
Definition: parsenodes.h:2088
TupleDesc setDesc
Definition: execnodes.h:364
Tuplestorestate * setResult
Definition: execnodes.h:363
int natts
Definition: tupdesc.h:137
Definition: dest.h:116
Definition: instr_time.h:70
TupleDesc CreateTupleDescCopy(TupleDesc tupdesc)
Definition: tupdesc.c:252
static FormData_pg_attribute * TupleDescAttr(TupleDesc tupdesc, int i)
Definition: tupdesc.h:160
void tuplestore_putvalues(Tuplestorestate *state, TupleDesc tdesc, const Datum *values, const bool *isnull)
Definition: tuplestore.c:784
Definition: pg_list.h:46
CommandTag CreateCommandTag(Node *parsetree)
Definition: utility.c:2354
static Datum TimestampTzGetDatum(TimestampTz X)
Definition: timestamp.h:52
TimestampTz GetCurrentStatementStartTimestamp(void)
Definition: xact.c:879

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