PostgreSQL

+
will set the Tcl variable `+$cnt+` to the number of rows in the `+pg_proc+` system catalog.
+
If the optional _`+loop-body+`_ argument is given, it is a piece of Tcl script that is executed once for each row in the query result. (_`+loop-body+`_ is ignored if the given command is not a `+SELECT+`.) The values of the current row's columns are stored into Tcl variables or array elements before each iteration. For example:
+

  +
  will print a log message for every row of `+pg_class+`. This feature works similarly to other Tcl looping constructs; in particular `+continue+` and `+break+` work in the usual way inside the loop body.
  +
  If a column of a query result is null, the target variable for it is [.quote]#“[.quote]#unset#”# rather than being set.
[.term]#`+spi_prepare+` _`+query+`_ _`+typelist+`_#::
  Prepares and saves a query plan for later execution. The saved plan will be retained for the life of the current session.
  +
  The query can use parameters, that is, placeholders for values to be supplied whenever the plan is actually executed. In the query string, refer to parameters by the symbols `+$1+` ... `+$+`_`+n+`_. If the query uses parameters, the names of the parameter types must be given as a Tcl list. (Write an empty list for _`+typelist+`_ if no parameters are used.)
  +
  The return value from `+spi_prepare+` is a query ID to be used in subsequent calls to `+spi_execp+`. See `+spi_execp+` for an example.
[.term]#`+spi_execp+``+ ?+`[.optional]#`+-count +`_`+n+`_#`+? ?+`[.optional]#`+-array +`_`+name+`_#`+? ?+`[.optional]#`+-nulls +`_`+string+`_#`+? +`_`+queryid+`_`+ ?+`[.optional]#_`+value-list+`_#`+? ?+`[.optional]#_`+loop-body+`_#`+?+`#::
  Executes a query previously prepared with `+spi_prepare+`. _`+queryid+`_ is the ID returned by `+spi_prepare+`. If the query references parameters, a _`+value-list+`_ must be supplied. This is a Tcl list of actual values for the parameters. The list must be the same length as the parameter type list previously given to `+spi_prepare+`. Omit _`+value-list+`_ if the query has no parameters.
  +
  The optional value for `+-nulls+` is a string of spaces and `+'n'+` characters telling `+spi_execp+` which of the parameters are null values. If given, it must have exactly the same length as the _`+value-list+`_. If it is not given, all the parameter values are nonnull.
  +
  Except for the way in which the query and its parameters are specified, `+spi_execp+` works just like `+spi_exec+`. The `+-count+`, `+-array+`, and _`+loop-body+`_ options are the same, and so is the result value.
  +
  Here's an example of a PL/Tcl function using a prepared plan:
  +

  +
  We need backslashes inside the query string given to `+spi_prepare+` to ensure that the `+$+`_`+n+`_ markers will be passed through to `+spi_prepare+` as-is, and not replaced by Tcl variable substitution.
[.term]#`+spi_lastoid+` ::
  Returns the OID of the row inserted by the last `+spi_exec+` or `+spi_execp+`, if the command was a single-row `+INSERT+` and the modified table contained OIDs. (If not, you get zero.)
[.term]#`+subtransaction+` _`+command+`_#::
  The Tcl script contained in _`+command+`_ is executed within a SQL subtransaction. If the script returns an error, that entire subtransaction is rolled back before returning the error out to the surrounding Tcl code. See link:pltcl-subtransactions.html[Section 44.9] for more details and an example.
[.term]#`+quote+` _`+string+`_#::
  Doubles all occurrences of single quote and backslash characters in the given string. This can be used to safely quote strings that are to be inserted into SQL commands given to `+spi_exec+` or `+spi_prepare+`. For example, think about an SQL command string like:
  +

+
where the Tcl variable `+val+` actually contains `+doesn't+`. This would result in the final command string:
+

+
which would cause a parse error during `+spi_exec+` or `+spi_prepare+`. To work properly, the submitted command should contain:
+

+
which can be formed in PL/Tcl using:
+

  +
  One advantage of `+spi_execp+` is that you don't have to quote parameter values like this, since the parameters are never parsed as part of an SQL command string.
[.term]#`+elog+` _`+level+`_ _`+msg+`_ ::
  Emits a log or error message. Possible levels are `+DEBUG+`, `+LOG+`, `+INFO+`, `+NOTICE+`, `+WARNING+`, `+ERROR+`, and `+FATAL+`. `+ERROR+` raises an error condition; if this is not trapped by the surrounding Tcl code, the error propagates out to the calling query, causing the current transaction or subtransaction to be aborted. This is effectively the same as the Tcl `+error+` command. `+FATAL+` aborts the transaction and causes the current session to shut down. (There is probably no good reason to use this error level in PL/Tcl functions, but it's provided for completeness.) The other levels only generate messages of different priority levels. Whether messages of a particular priority are reported to the client, written to the server log, or both is controlled by the link:runtime-config-logging.html#GUC-LOG-MIN-MESSAGES[log_min_messages] and link:runtime-config-client.html#GUC-CLIENT-MIN-MESSAGES[client_min_messages] configuration variables. See link:runtime-config.html[Chapter 19] and link:pltcl-error-handling.html[Section 44.8] for more information.