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-2022, 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/prepare.h"
25 #include "funcapi.h"
26 #include "miscadmin.h"
27 #include "nodes/nodeFuncs.h"
28 #include "parser/analyze.h"
29 #include "parser/parse_coerce.h"
30 #include "parser/parse_collate.h"
31 #include "parser/parse_expr.h"
32 #include "parser/parse_type.h"
33 #include "rewrite/rewriteHandler.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 
49 static void InitQueryHashTable(void);
51  PreparedStatement *pstmt, List *params,
52  EState *estate);
53 static Datum build_regtype_array(Oid *param_types, int num_params);
54 
55 /*
56  * Implements the 'PREPARE' utility statement.
57  */
58 void
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  */
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  */
149 void
151  ExecuteStmt *stmt, IntoClause *intoClause,
152  ParamListInfo params,
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, true, 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  */
280 static ParamListInfo
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,
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;
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  */
371 static 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,
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  */
391 void
392 StorePreparedStatement(const char *stmt_name,
393  CachedPlanSource *plansource,
394  bool from_sql)
395 {
396  PreparedStatement *entry;
398  bool found;
399 
400  /* Initialize the hash table, if necessary */
401  if (!prepared_queries)
403 
404  /* Add entry to hash table */
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  */
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)
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  */
465 TupleDesc
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  */
473  if (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  */
488 List *
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  */
504 void
506 {
507  if (stmt->name)
508  DropPreparedStatement(stmt->name, true);
509  else
511 }
512 
513 /*
514  * Internal version of DEALLOCATE
515  *
516  * If showError is false, dropping a nonexistent statement is a no-op.
517  */
518 void
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 */
533  }
534 }
535 
536 /*
537  * Drop all cached statements.
538  */
539 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 */
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 */
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 queryString is that of the EXPLAIN EXECUTE,
568  * not the original PREPARE; we get the latter string from the plancache.
569  */
570 void
572  const char *queryString, ParamListInfo params,
573  QueryEnvironment *queryEnv)
574 {
575  PreparedStatement *entry;
576  const char *query_string;
577  CachedPlan *cplan;
578  List *plan_list;
579  ListCell *p;
580  ParamListInfo paramLI = NULL;
581  EState *estate = NULL;
582  instr_time planstart;
583  instr_time planduration;
584  BufferUsage bufusage_start,
585  bufusage;
586 
587  if (es->buffers)
588  bufusage_start = pgBufferUsage;
589  INSTR_TIME_SET_CURRENT(planstart);
590 
591  /* Look it up in the hash table */
592  entry = FetchPreparedStatement(execstmt->name, true);
593 
594  /* Shouldn't find a non-fixed-result cached plan */
595  if (!entry->plansource->fixed_result)
596  elog(ERROR, "EXPLAIN EXECUTE does not support variable-result cached plans");
597 
598  query_string = entry->plansource->query_string;
599 
600  /* Evaluate parameters, if any */
601  if (entry->plansource->num_params)
602  {
603  ParseState *pstate;
604 
605  pstate = make_parsestate(NULL);
606  pstate->p_sourcetext = queryString;
607 
608  /*
609  * Need an EState to evaluate parameters; must not delete it till end
610  * of query, in case parameters are pass-by-reference. Note that the
611  * passed-in "params" could possibly be referenced in the parameter
612  * expressions.
613  */
614  estate = CreateExecutorState();
615  estate->es_param_list_info = params;
616 
617  paramLI = EvaluateParams(pstate, entry, execstmt->params, estate);
618  }
619 
620  /* Replan if needed, and acquire a transient refcount */
621  cplan = GetCachedPlan(entry->plansource, paramLI,
622  CurrentResourceOwner, queryEnv);
623 
624  INSTR_TIME_SET_CURRENT(planduration);
625  INSTR_TIME_SUBTRACT(planduration, planstart);
626 
627  /* calc differences of buffer counters. */
628  if (es->buffers)
629  {
630  memset(&bufusage, 0, sizeof(BufferUsage));
631  BufferUsageAccumDiff(&bufusage, &pgBufferUsage, &bufusage_start);
632  }
633 
634  plan_list = cplan->stmt_list;
635 
636  /* Explain each query */
637  foreach(p, plan_list)
638  {
639  PlannedStmt *pstmt = lfirst_node(PlannedStmt, p);
640 
641  if (pstmt->commandType != CMD_UTILITY)
642  ExplainOnePlan(pstmt, into, es, query_string, paramLI, queryEnv,
643  &planduration, (es->buffers ? &bufusage : NULL));
644  else
645  ExplainOneUtility(pstmt->utilityStmt, into, es, query_string,
646  paramLI, queryEnv);
647 
648  /* No need for CommandCounterIncrement, as ExplainOnePlan did it */
649 
650  /* Separate plans with an appropriate separator */
651  if (lnext(plan_list, p) != NULL)
653  }
654 
655  if (estate)
656  FreeExecutorState(estate);
657 
659 }
660 
661 /*
662  * This set returning function reads all the prepared statements and
663  * returns a set of (name, statement, prepare_time, param_types, from_sql,
664  * generic_plans, custom_plans).
665  */
666 Datum
668 {
669  ReturnSetInfo *rsinfo = (ReturnSetInfo *) fcinfo->resultinfo;
670 
671  /*
672  * We put all the tuples into a tuplestore in one scan of the hashtable.
673  * This avoids any issue of the hashtable possibly changing between calls.
674  */
675  InitMaterializedSRF(fcinfo, 0);
676 
677  /* hash table might be uninitialized */
678  if (prepared_queries)
679  {
680  HASH_SEQ_STATUS hash_seq;
681  PreparedStatement *prep_stmt;
682 
683  hash_seq_init(&hash_seq, prepared_queries);
684  while ((prep_stmt = hash_seq_search(&hash_seq)) != NULL)
685  {
686  TupleDesc result_desc;
687  Datum values[8];
688  bool nulls[8] = {0};
689 
690  result_desc = prep_stmt->plansource->resultDesc;
691 
692  values[0] = CStringGetTextDatum(prep_stmt->stmt_name);
694  values[2] = TimestampTzGetDatum(prep_stmt->prepare_time);
696  prep_stmt->plansource->num_params);
697  if (result_desc)
698  {
699  Oid *result_types;
700 
701  result_types = palloc_array(Oid, result_desc->natts);
702  for (int i = 0; i < result_desc->natts; i++)
703  result_types[i] = result_desc->attrs[i].atttypid;
704  values[4] = build_regtype_array(result_types, result_desc->natts);
705  }
706  else
707  {
708  /* no result descriptor (for example, DML statement) */
709  nulls[4] = true;
710  }
711  values[5] = BoolGetDatum(prep_stmt->from_sql);
714 
715  tuplestore_putvalues(rsinfo->setResult, rsinfo->setDesc,
716  values, nulls);
717  }
718  }
719 
720  return (Datum) 0;
721 }
722 
723 /*
724  * This utility function takes a C array of Oids, and returns a Datum
725  * pointing to a one-dimensional Postgres array of regtypes. An empty
726  * array is returned as a zero-element array, not NULL.
727  */
728 static Datum
729 build_regtype_array(Oid *param_types, int num_params)
730 {
731  Datum *tmp_ary;
732  ArrayType *result;
733  int i;
734 
735  tmp_ary = palloc_array(Datum, num_params);
736 
737  for (i = 0; i < num_params; i++)
738  tmp_ary[i] = ObjectIdGetDatum(param_types[i]);
739 
740  result = construct_array_builtin(tmp_ary, num_params, REGTYPEOID);
741  return PointerGetDatum(result);
742 }
ArrayType * construct_array_builtin(Datum *elems, int nelems, Oid elmtype)
Definition: arrayfuncs.c:3338
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
PreparedStatement * FetchPreparedStatement(const char *stmt_name, bool throwError)
Definition: prepare.c:434
TupleDesc FetchPreparedStatementResultDesc(PreparedStatement *stmt)
Definition: prepare.c:466
Datum pg_prepared_statement(PG_FUNCTION_ARGS)
Definition: prepare.c:667
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:729
void ExecuteQuery(ParseState *pstate, ExecuteStmt *stmt, IntoClause *intoClause, ParamListInfo params, DestReceiver *dest, QueryCompletion *qc)
Definition: prepare.c:150
void ExplainExecuteQuery(ExecuteStmt *execstmt, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv)
Definition: prepare.c:571
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:156
#define CStringGetTextDatum(s)
Definition: builtins.h:85
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:953
HTAB * hash_create(const char *tabname, long nelem, const HASHCTL *info, int flags)
Definition: dynahash.c:350
void * hash_seq_search(HASH_SEQ_STATUS *status)
Definition: dynahash.c:1431
void hash_seq_init(HASH_SEQ_STATUS *status, HTAB *hashp)
Definition: dynahash.c:1421
int errdetail(const char *fmt,...)
Definition: elog.c:1039
int errhint(const char *fmt,...)
Definition: elog.c:1153
int errcode(int sqlerrcode)
Definition: elog.c:695
int errmsg(const char *fmt,...)
Definition: elog.c:906
#define ERROR
Definition: elog.h:35
#define ereport(elevel,...)
Definition: elog.h:145
List * ExecPrepareExprList(List *nodes, EState *estate)
Definition: execExpr.c:821
EState * CreateExecutorState(void)
Definition: execUtils.c:90
void FreeExecutorState(EState *estate)
Definition: execUtils.c:188
#define GetPerTupleExprContext(estate)
Definition: executor.h:535
static Datum ExecEvalExprSwitchContext(ExprState *state, ExprContext *econtext, bool *isNull)
Definition: executor.h:333
void ExplainOnePlan(PlannedStmt *plannedstmt, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv, const instr_time *planduration, const BufferUsage *bufusage)
Definition: explain.c:518
void ExplainSeparatePlans(ExplainState *es)
Definition: explain.c:4924
void ExplainOneUtility(Node *utilityStmt, IntoClause *into, ExplainState *es, const char *queryString, ParamListInfo params, QueryEnvironment *queryEnv)
Definition: explain.c:428
#define palloc_array(type, count)
Definition: fe_memutils.h:64
#define PG_FUNCTION_ARGS
Definition: fmgr.h:193
char * format_type_be(Oid type_oid)
Definition: format_type.c:339
void InitMaterializedSRF(FunctionCallInfo fcinfo, bits32 flags)
Definition: funcapi.c:76
#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 INSTR_TIME_SET_CURRENT(t)
Definition: instr_time.h:89
#define INSTR_TIME_SUBTRACT(x, y)
Definition: instr_time.h:103
struct timespec instr_time
Definition: instr_time.h:83
BufferUsage pgBufferUsage
Definition: instrument.c:20
void BufferUsageAccumDiff(BufferUsage *dst, const BufferUsage *add, const BufferUsage *sub)
Definition: instrument.c:246
int i
Definition: isn.c:73
Assert(fmt[strlen(fmt) - 1] !='\n')
char * MemoryContextStrdup(MemoryContext context, const char *string)
Definition: mcxt.c:1470
Oid exprType(const Node *expr)
Definition: nodeFuncs.c:43
int exprLocation(const Node *expr)
Definition: nodeFuncs.c:1243
#define copyObject(obj)
Definition: nodes.h:233
@ CMD_UTILITY
Definition: nodes.h:270
@ CMD_SELECT
Definition: nodes.h:265
#define makeNode(_type_)
Definition: nodes.h:165
ParamListInfo makeParamList(int numParams)
Definition: params.c:44
#define PARAM_FLAG_CONST
Definition: params.h:88
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:78
void assign_expr_collations(ParseState *pstate, Node *expr)
Node * transformExpr(ParseState *pstate, Node *expr, ParseExprKind exprKind)
Definition: parse_expr.c:92
int parser_errposition(ParseState *pstate, int location)
Definition: parse_node.c:110
ParseState * make_parsestate(ParseState *parentParseState)
Definition: parse_node.c:43
@ EXPR_KIND_EXECUTE_PARAMETER
Definition: parse_node.h:75
Oid typenameTypeId(ParseState *pstate, const TypeName *typeName)
Definition: parse_type.c:291
#define FETCH_ALL
Definition: parsenodes.h:2943
#define CURSOR_OPT_PARALLEL_OK
Definition: parsenodes.h:2908
#define NAMEDATALEN
#define lfirst(lc)
Definition: pg_list.h:170
#define lfirst_node(type, lc)
Definition: pg_list.h:174
static int list_length(const List *l)
Definition: pg_list.h:150
#define linitial_node(type, l)
Definition: pg_list.h:179
static ListCell * lnext(const List *l, const ListCell *c)
Definition: pg_list.h:341
void DropCachedPlan(CachedPlanSource *plansource)
Definition: plancache.c:498
List * CachedPlanGetTargetList(CachedPlanSource *plansource, QueryEnvironment *queryEnv)
Definition: plancache.c:1611
void SaveCachedPlan(CachedPlanSource *plansource)
Definition: plancache.c:454
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:338
CachedPlanSource * CreateCachedPlan(RawStmt *raw_parse_tree, const char *query_string, CommandTag commandTag)
Definition: plancache.c:164
CachedPlan * GetCachedPlan(CachedPlanSource *plansource, ParamListInfo boundParams, ResourceOwner owner, QueryEnvironment *queryEnv)
Definition: plancache.c:1141
void ReleaseCachedPlan(CachedPlan *plan, ResourceOwner owner)
Definition: plancache.c:1264
Portal CreateNewPortal(void)
Definition: portalmem.c:236
void PortalDrop(Portal portal, bool isTopCommit)
Definition: portalmem.c:469
void PortalDefineQuery(Portal portal, const char *prepStmtName, const char *sourceText, CommandTag commandTag, List *stmts, CachedPlan *cplan)
Definition: portalmem.c:283
List * pg_analyze_and_rewrite_varparams(RawStmt *parsetree, const char *query_string, Oid **paramTypes, int *numParams, QueryEnvironment *queryEnv)
Definition: postgres.c:677
#define Int64GetDatumFast(X)
Definition: postgres.h:902
static Datum PointerGetDatum(const void *X)
Definition: postgres.h:670
uintptr_t Datum
Definition: postgres.h:412
static Datum BoolGetDatum(bool X)
Definition: postgres.h:450
static Datum ObjectIdGetDatum(Oid X)
Definition: postgres.h:600
unsigned int Oid
Definition: postgres_ext.h:31
void PortalStart(Portal portal, ParamListInfo params, int eflags, Snapshot snapshot)
Definition: pquery.c:433
bool PortalRun(Portal portal, long count, bool isTopLevel, bool run_once, DestReceiver *dest, DestReceiver *altdest, QueryCompletion *qc)
Definition: pquery.c:684
@ COERCE_IMPLICIT_CAST
Definition: primnodes.h:588
@ COERCION_ASSIGNMENT
Definition: primnodes.h:567
ResourceOwner CurrentResourceOwner
Definition: resowner.c:146
Snapshot GetActiveSnapshot(void)
Definition: snapmgr.c:805
CommandTag commandTag
Definition: plancache.h:101
const char * query_string
Definition: plancache.h:100
TupleDesc resultDesc
Definition: plancache.h:108
int64 num_custom_plans
Definition: plancache.h:133
int64 num_generic_plans
Definition: plancache.h:134
List * stmt_list
Definition: plancache.h:150
ParamListInfo es_param_list_info
Definition: execnodes.h:649
List * params
Definition: parsenodes.h:3656
char * name
Definition: parsenodes.h:3655
bool buffers
Definition: explain.h:44
Size keysize
Definition: hsearch.h:75
Size entrysize
Definition: hsearch.h:76
Definition: dynahash.c:220
bool skipData
Definition: primnodes.h:135
Definition: pg_list.h:52
Definition: nodes.h:118
bool isnull
Definition: params.h:93
uint16 pflags
Definition: params.h:94
Datum value
Definition: params.h:92
ParamExternData params[FLEXIBLE_ARRAY_MEMBER]
Definition: params.h:125
const char * p_sourcetext
Definition: parse_node.h:182
CmdType commandType
Definition: plannodes.h:53
Node * utilityStmt
Definition: plannodes.h:96
MemoryContext portalContext
Definition: portal.h:120
bool visible
Definition: portal.h:205
List * argtypes
Definition: parsenodes.h:3642
char * name
Definition: parsenodes.h:3641
Node * query
Definition: parsenodes.h:3643
char stmt_name[NAMEDATALEN]
Definition: prepare.h:30
TimestampTz prepare_time
Definition: prepare.h:33
CachedPlanSource * plansource
Definition: prepare.h:31
int stmt_len
Definition: parsenodes.h:1633
Node * stmt
Definition: parsenodes.h:1631
int stmt_location
Definition: parsenodes.h:1632
TupleDesc setDesc
Definition: execnodes.h:332
Tuplestorestate * setResult
Definition: execnodes.h:331
FormData_pg_attribute attrs[FLEXIBLE_ARRAY_MEMBER]
Definition: tupdesc.h:87
TupleDesc CreateTupleDescCopy(TupleDesc tupdesc)
Definition: tupdesc.c:111
void tuplestore_putvalues(Tuplestorestate *state, TupleDesc tdesc, Datum *values, bool *isnull)
Definition: tuplestore.c:750
CommandTag CreateCommandTag(Node *parsetree)
Definition: utility.c:2353
static Datum TimestampTzGetDatum(TimestampTz X)
Definition: timestamp.h:52
TimestampTz GetCurrentStatementStartTimestamp(void)
Definition: xact.c:863