pdf viewer dll for c# : Add image to pdf file acrobat application Library tool html asp.net .net online postgresql-9.4-A4111-part2737

Chapter 40. PL/pgSQL - SQL Procedural Language
SELECT less_than(text_field_1, text_field_2 COLLATE "C") FROM table1;
The first use of
less_than
will use the common collation of
text_field_1
and
text_field_2
for the comparison, while the second use will use
C
collation.
Furthermore, the identified collation is also assumed as the collation of any local variables that are of
collatable types. Thus this function would not work any differently if it were written as
CREATE FUNCTION less_than(a text, b text) RETURNS boolean AS $$
DECLARE
local_a text := a;
local_b text := b;
BEGIN
RETURN local_a < local_b;
END;
$$ LANGUAGE plpgsql;
If there are no parameters of collatable data types, or no common collation can be identified for them,
then parameters and local variables use the default collation of their data type (which is usually the
database’s default collation, but could be different for variables of domain types).
Alocal variable of a collatable data type can have a different collation associated with itby including
the
COLLATE
option in its declaration, for example
DECLARE
local_a text COLLATE "en_US";
This option overrides the collationthat would otherwise be given tothe variable according tothe rules
above.
Also, of course explicit
COLLATE
clauses can be written inside a function if it is desired to force a
particular collation to be used in a particular operation. For example,
CREATE FUNCTION less_than_c(a text, b text) RETURNS boolean AS $$
BEGIN
RETURN a < b COLLATE "C";
END;
$$ LANGUAGE plpgsql;
This overrides the collations associated with the table columns, parameters, or local variables used in
the expression, just as would happen in a plain SQL command.
40.4. Expressions
All expressions used in PL/pgSQL statements are processed using the server’s main SQL executor.
For example, when you write a PL/pgSQL statement like
IF
expression
THEN ...
PL/pgSQL will evaluate the expression by feeding a query like
SELECT
expression
1038
Add image to pdf file acrobat - insert images into PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sample C# code to add image, picture, logo or digital photo into PDF document page using PDF page editor control
how to add a jpeg to a pdf; add jpg to pdf form
Add image to pdf file acrobat - VB.NET PDF insert image library: insert images into PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide VB.NET Programmers How to Add Images in PDF Document
adding an image to a pdf form; adding an image to a pdf
Chapter 40. PL/pgSQL - SQL Procedural Language
to the main SQL engine. While forming the
SELECT
command, any occurrences of PL/pgSQL vari-
able names are replaced by parameters, as discussed in detail in Section 40.10.1. This allows the
query plan for the
SELECT
to be prepared just once and then reused for subsequent evaluations with
different values of the variables. Thus, what really happens on first use of an expression is essentially
a
PREPARE
command. For example, if we have declared two integer variables
x
and
y
,and we write
IF x < y THEN ...
what happens behind the scenes is equivalent to
PREPARE
statement_name
(integer, integer) AS SELECT $1 < $2;
and then this prepared statement is
EXECUTE
dfor each execution of the
IF
statement, with the cur-
rent values of the PL/pgSQL variables supplied as parameter values. Normally these details are not
important to a PL/pgSQL user, but they are useful to know when trying to diagnose a problem. More
information appears in Section 40.10.2.
40.5. Basic Statements
In this section and the following ones, we describe all the statement types that are explicitly under-
stood by PL/pgSQL. Anything not recognized as one of these statement types is presumed to be an
SQL commandand is sent tothe main database engine to execute, as described in Section 40.5.2 and
Section 40.5.3.
40.5.1. Assignment
An assignment of a value to a PL/pgSQL variable is written as:
variable
{ := | = }
expression
;
As explained previously, the expression insuch a statement is evaluated bymeans of an SQL
SELECT
command sent to the main database engine. The expression must yield a single value (possibly a
row value, if the variable is a row or record variable). The target variable can be a simple variable
(optionally qualified witha block name), a field of a row or recordvariable, or anelement of an array
that is a simple variable or field. Equal (
=
)can be used instead of PL/SQL-compliant
:=
.
If the expression’s result data type doesn’t match the variable’s data type, or the variable has a spe-
cific size/precision (like
char(20)
), the result value will be implicitly converted by the PL/pgSQL
interpreter usingtheresult type’s output-function andthe variable type’s input-function. Note that this
could potentially result in run-time errors generated by the input function, if the string form of the
result value is not acceptable to the input function.
Examples:
tax := subtotal
*
0.06;
my_record.user_id := 20;
1039
.NET PDF Document Viewing, Annotation, Conversion & Processing
Convert image files to PDF. File & Page Process. Add, insert PDF native annotations to PDF file. Edit, update, delete PDF annotations from PDF file. Print.
how to add photo to pdf in preview; add image to pdf in preview
C# PDF Converter Library SDK to convert PDF to other file formats
professional PDF document conversion library toolkit in C#, you can easily perform file conversion from PDF document to image or document
add jpg to pdf document; adding an image to a pdf in preview
Chapter 40. PL/pgSQL - SQL Procedural Language
40.5.2. Executing a Command With No Result
For any SQL command that does not return rows, for example
INSERT
without a
RETURNING
clause,
you can execute the command within a PL/pgSQL function just by writing the command.
Any PL/pgSQL variable name appearing in the command text is treated as a parameter, and then the
current value of the variable is provided as the parameter value at run time. This is exactly like the
processing described earlier for expressions; for details see Section 40.10.1.
When executing a SQL command in this way, PL/pgSQL may cache and re-use the execution plan
for the command, as discussed in Section 40.10.2.
Sometimes it is useful to evaluate an expression or
SELECT
query but discard the result, for example
when calling a function that has side-effects but no useful result value. To do this in PL/pgSQL, use
the
PERFORM
statement:
PERFORM
query
;
This executes
query
anddiscards the result. Write the
query
the same way you would writean SQL
SELECT
command, but replace the initial keyword
SELECT
with
PERFORM
.For
WITH
queries, use
PERFORM
and then place the query in parentheses. (In this case, the query can only return one row.)
PL/pgSQL variables will be substituted into the query just as for commands that return no result,
and the plan is cached in the same way. Also, the special variable
FOUND
is set to true if the query
produced at least one row, or false if it produced norows (see Section 40.5.5).
Note: One might expect that writing
SELECT
directly would accomplish this result, but at present
theonly accepted way todoit is
PERFORM
.A SQL command that can returnrows, such as
SELECT
,
will be rejected as an error unless it has an
INTO
clause as discussed in the next section.
An example:
PERFORM create_mv(’cs_session_page_requests_mv’, my_query);
40.5.3. Executing a Query with a Single-row Result
The resultof a SQL commandyielding a single row(possibly of multiple columns) can be assigned to
arecord variable, row-type variable, or list of scalar variables. This is done by writing the base SQL
command and adding an
INTO
clause. For example,
SELECT
select_expressions
INTO [STRICT]
target
FROM ...;
INSERT ... RETURNING
expressions
INTO [STRICT]
target
;
UPDATE ... RETURNING
expressions
INTO [STRICT]
target
;
DELETE ... RETURNING
expressions
INTO [STRICT]
target
;
where
target
can be a record variable, a row variable, or a comma-separated list of simple variables
and record/row fields. PL/pgSQL variables will be substituted into the rest of the query, and the plan
is cached, just as described above for commands that do not return rows. This works for
SELECT
,
INSERT
/
UPDATE
/
DELETE
with
RETURNING
,and utility commands that return row-setresults (such as
EXPLAIN
). Except for the
INTO
clause, the SQL command is the same as it would be written outside
PL/pgSQL.
1040
C# Windows Viewer - Image and Document Conversion & Rendering in
conversion library toolkit in C#, you can easily perform file conversion from Image and Document Conversion Supported by Windows Viewer. Convert to PDF.
add png to pdf acrobat; add picture to pdf in preview
C# powerpoint - PowerPoint Conversion & Rendering in C#.NET
may easily achieve the following PowerPoint file conversions SDK to convert PowerPoint document to PDF document demo code for PowerPoint to TIFF image conversion
add an image to a pdf in preview; add image pdf acrobat
Chapter 40. PL/pgSQL - SQL Procedural Language
Tip: Note that this interpretation of
SELECT
with
INTO
is quite different from PostgreSQL’s regular
SELECT INTO
command, wherein the
INTO
target is a newly created table. If you want to create
atable from a
SELECT
result inside a PL/pgSQL function, use the syntax
CREATE TABLE ... AS
SELECT
.
If a row or a variable list is used as target, the query’s result columns must exactly matchthe structure
of the target as to number and data types, or else a run-time error occurs. When a record variable is
the target, it automatically configures itself to the row type of the query result columns.
The
INTO
clause can appear almost anywhere in the SQL command. Customarily it is written either
just before or justafter the list of
select_expressions
in a
SELECT
command, or at the end of the
command for other command types. It is recommended that you follow this convention in case the
PL/pgSQL parser becomes stricter in future versions.
If
STRICT
is not specified in the
INTO
clause, then
target
will be set to the firstrow returnedby the
query, or to nulls if the query returned no rows. (Note that “the first row” is not well-defined unless
you’ve used
ORDER BY
.) Any result rows after the first row are discarded. You can check the special
FOUND
variable (see Section 40.5.5) to determine whether a row was returned:
SELECT
*
INTO myrec FROM emp WHERE empname = myname;
IF NOT FOUND THEN
RAISE EXCEPTION ’employee % not found’, myname;
END IF;
If the
STRICT
option is specified, the query must return exactly one row or a run-time error will be
reported, either
NO_DATA_FOUND
(no rows) or
TOO_MANY_ROWS
(more than one row). You can use
an exception block if you wish to catch the error, for example:
BEGIN
SELECT
*
INTO STRICT myrec FROM emp WHERE empname = myname;
EXCEPTION
WHEN NO_DATA_FOUND THEN
RAISE EXCEPTION ’employee % not found’, myname;
WHEN TOO_MANY_ROWS THEN
RAISE EXCEPTION ’employee % not unique’, myname;
END;
Successful execution of a command with
STRICT
always sets
FOUND
to true.
For
INSERT
/
UPDATE
/
DELETE
with
RETURNING
,PL/pgSQL reports an error for more than one re-
turned row, even when
STRICT
is not specified. This is because there is no option such as
ORDER BY
with which to determine which affected rowshould be returned.
If
print_strict_params
is enabled for the function, then when an error is thrown because the
requirements of
STRICT
are not met, the
DETAIL
part of the error message will include information
about the parameters passed tothe query. You canchange the
print_strict_params
settingfor all
functions by setting
plpgsql.print_strict_params
,though only subsequent function compila-
tions will be affected. You can also enable it on a per-function basis by using a compiler option, for
example:
CREATE FUNCTION get_userid(username text) RETURNS int
AS $$
#print_strict_params on
DECLARE
userid int;
BEGIN
1041
C# Word - Word Conversion in C#.NET
you may easily achieve the following Word file conversions. XDoc.Word SDK to convert Word document to PDF document C# demo code for Word to TIFF image conversion
add jpg to pdf file; adding images to pdf forms
VB.NET PDF: How to Create Watermark on PDF Document within
Using this VB.NET Imaging PDF Watermark Add-on, you can a watermark that consists of text or image (such as And with our PDF Watermark Creator, users need no
acrobat insert image in pdf; add jpg to pdf acrobat
Chapter 40. PL/pgSQL - SQL Procedural Language
SELECT users.userid INTO STRICT userid
FROM users WHERE users.username = get_userid.username;
RETURN userid;
END
$$ LANGUAGE plpgsql;
On failure, this function might produce an error message such as
ERROR:
query returned no rows
DETAIL:
parameters: $1 = ’nosuchuser’
CONTEXT:
PL/pgSQL function get_userid(text) line 6 at SQL statement
Note: The
STRICT
option matches the behavior of Oracle PL/SQL’s
SELECT INTO
and related
statements.
To handle cases whereyouneedtoprocess multipleresult rows from aSQL query, see Section 40.6.4.
40.5.4. Executing Dynamic Commands
Oftentimes you will want to generate dynamic commands inside your PL/pgSQL functions, that
is, commands that will involve different tables or different data types each time they are executed.
PL/pgSQL’s normal attempts to cache plans for commands (as discussed in Section 40.10.2) will not
work in such scenarios. To handle this sort of problem, the
EXECUTE
statement is provided:
EXECUTE
command-string
[ INTO [STRICT]
target
] [ USING
expression
[, ... ] ];
where
command-string
is an expression yielding a string (of type
text
)containing the command
to be executed. The optional
target
is a record variable, a row variable, or a comma-separated list
of simple variables and record/row fields, into which the results of the command will be stored. The
optional
USING
expressions supply values to be inserted into the command.
No substitution of PL/pgSQL variables is done on the computed command string. Any required vari-
able values must be inserted in the command string as it is constructed; or you can use parameters as
described below.
Also, there is no plan caching for commands executed via
EXECUTE
.Instead, the command is always
planned each time the statement is run. Thus the command string can be dynamically created within
the function to perform actions on different tables and columns.
The
INTO
clause specifies where the results of a SQL command returning rows should be assigned.
If a row or variable list is provided, it must exactly match the structure of the query’s results (when a
record variable is used, it will configure itself to match the result structure automatically). If multiple
rows are returned, onlythe first will be assigned to the
INTO
variable. If no rows are returned, NULL
is assigned to the
INTO
variable(s). If no
INTO
clause is specified, the query results are discarded.
If the
STRICT
option is given, an error is reported unless the query produces exactly one row.
The command string can use parameter values, which are referenced in the command as
$1
,
$2
,
etc. These symbols refer to values supplied in the
USING
clause. This method is often preferable to
inserting data values into the command string as text: it avoids run-time overhead of converting the
values to text and back, and it is much less prone to SQL-injection attacks since there is no need for
quoting or escaping. An example is:
1042
VB.NET PowerPoint: VB Code to Draw and Create Annotation on PPT
as a kind of compensation for limitations (other documents are compatible, including PDF, TIFF, MS VB.NET PPT: VB Code to Add Embedded Image Object to
adding jpg to pdf; adding image to pdf file
BMP to PDF Converter | Convert Bitmap to PDF, Convert PDF to BMP
Also designed to be used add-on for .NET Image Powerful image converter for Bitmap and PDF files; No Support conversion of Bitmap - PDF files in both single &
add image pdf document; add photo to pdf reader
Chapter 40. PL/pgSQL - SQL Procedural Language
EXECUTE ’SELECT count(
*
) FROM mytable WHERE inserted_by = $1 AND inserted <= $2’
INTO c
USING checked_user, checked_date;
Note that parameter symbols can only be used for data values — if you want to use dynamically
determined table or column names, you must insert them into the command string textually. For
example, if the preceding query needed to be done against a dynamically selected table, you could do
this:
EXECUTE ’SELECT count(
*
) FROM ’
|| tabname::regclass
|| ’ WHERE inserted_by = $1 AND inserted <= $2’
INTO c
USING checked_user, checked_date;
Another restriction on parameter symbols is that they only work in
SELECT
,
INSERT
,
UPDATE
,and
DELETE
commands. In other statement types (generically called utility statements), you must insert
values textually even if they are just data values.
An
EXECUTE
with a simple constant command string and some
USING
parameters, as in the first
example above, is functionally equivalent to just writing the command directly in PL/pgSQL and
allowing replacement of PL/pgSQL variables to happen automatically. The important difference is
that
EXECUTE
will re-plan the command on each execution, generating a plan that is specific to the
current parameter values; whereas PL/pgSQL may otherwise create a generic plan and cache it for
re-use. In situations where the best plan depends strongly on the parameter values, it can be helpful
to use
EXECUTE
to positivelyensure that a generic plan is not selected.
SELECT INTO
is not currentlysupported within
EXECUTE
;instead, execute aplain
SELECT
command
and specify
INTO
as part of the
EXECUTE
itself.
Note: The PL/pgSQL
EXECUTE
statement is not related to the EXECUTE SQL statement sup-
ported by the PostgreSQL server. The server’s
EXECUTE
statement cannot be useddirectly within
PL/pgSQL functions (and is not needed).
Example 40-1. Quoting Values In Dynamic Queries
When workingwith dynamic commands you will often have to handle escapingof single quotes. The
recommended method for quoting fixed text in your function body is dollar quoting. (If you have
legacy code that does not use dollar quoting, please refer to the overview in Section 40.11.1, which
can save you some effort when translating said code to a more reasonable scheme.)
Dynamic values that are to be inserted into the constructed query require careful handling since they
might themselves contain quote characters. An example (this assumes that you are using dollar quot-
ing for the function as a whole, sothe quote marks need not be doubled):
EXECUTE ’UPDATE tbl SET ’
|| quote_ident(colname)
|| ’ = ’
|| quote_literal(newvalue)
|| ’ WHERE key = ’
|| quote_literal(keyvalue);
This example demonstrates the use of the
quote_ident
and
quote_literal
functions (see Sec-
tion 9.4). For safety, expressions containing column or table identifiers should be passed through
1043
PDF to WORD Converter | Convert PDF to Word, Convert Word to PDF
If you want to convert document file PDF formats to out transformation between different kinds of image files and Converter has accurate output, and PDF to Word
add a picture to a pdf file; add signature image to pdf
JPEG to PDF Converter | Convert JPEG to PDF, Convert PDF to JPEG
No need for Adobe Acrobat Reader; Seamlessly integrated into RasterEdge .NET Image SDK; high speed; Get a compressed PDF file after conversion;
attach image to pdf form; add image to pdf java
Chapter 40. PL/pgSQL - SQL Procedural Language
quote_ident
before insertion in a dynamic query. Expressions containing values that should be lit-
eralstrings in the constructed command shouldbe passed through
quote_literal
.These functions
take the appropriate steps to return the input text enclosed in double or single quotes respectively,
with any embedded special characters properly escaped.
Because
quote_literal
is labeled
STRICT
,it will always return null when called with a null ar-
gument. In the above example, if
newvalue
or
keyvalue
were null, the entire dynamic query string
would become null, leading to an error from
EXECUTE
. You can avoid this problem by using the
quote_nullable
function, which works the same as
quote_literal
except that when calledwith
anull argument it returns the string
NULL
.For example,
EXECUTE ’UPDATE tbl SET ’
|| quote_ident(colname)
|| ’ = ’
|| quote_nullable(newvalue)
|| ’ WHERE key = ’
|| quote_nullable(keyvalue);
If you are dealing with values that might be null, you should usually use
quote_nullable
in place
of
quote_literal
.
As always, care must be taken to ensure that null values in a query do not deliver unintended results.
For example the
WHERE
clause
’WHERE key = ’ || quote_nullable(keyvalue)
will never succeed if
keyvalue
is null, because the result of using the equality operator
=
witha null
operandis always null. If you wish null to work like an ordinary keyvalue, youwouldneedto rewrite
the above as
’WHERE key IS NOT DISTINCT FROM ’ || quote_nullable(keyvalue)
(At present,
IS NOT DISTINCT FROM
is handled much less efficientlythan
=
,so don’t do this unless
you must. See Section 9.2 for more information on nulls and
IS DISTINCT
.)
Note that dollar quotingis only useful for quoting fixedtext. It would bea very bad idea to try to write
this example as:
EXECUTE ’UPDATE tbl SET ’
|| quote_ident(colname)
|| ’ = $$’
|| newvalue
|| ’$$ WHERE key = ’
|| quote_literal(keyvalue);
because it would break if the contents of
newvalue
happened to contain
$$
.The same objection
would apply to any other dollar-quoting delimiter you might pick. So, to safely quote text that is
not known in advance, you must use
quote_literal
,
quote_nullable
, or
quote_ident
, as
appropriate.
Dynamic SQL statements can alsobe safely constructed using the
format
function(see Section 9.4).
For example:
EXECUTE format(’UPDATE tbl SET %I = %L WHERE key = %L’, colname, newvalue, keyvalue);
The
format
function can be used in conjunction with the
USING
clause:
EXECUTE format(’UPDATE tbl SET %I = $1 WHERE key = $2’, colname)
USING newvalue, keyvalue;
This form is more efficient, because the parameters
newvalue
and
keyvalue
are not converted to
text.
Amuch larger example of a dynamic command and
EXECUTE
can be seen in Example 40-9, which
builds and executes a
CREATE FUNCTION
command to define a new function.
1044
Chapter 40. PL/pgSQL - SQL Procedural Language
40.5.5. Obtaining the Result Status
There are several ways to determine the effect of a command. The first method is to use the
GET
DIAGNOSTICS
command, which has the form:
GET [ CURRENT ] DIAGNOSTICS
variable
{ = | := }
item
[ , ... ];
This command allows retrieval of system status indicators. Each
item
is a key word identifying a
status value to be assigned to the specified variable (which should be of the right data type to receive
it). The currently available status items are
ROW_COUNT
,the number of rows processed by the last
SQL commandsenttotheSQL engine, and
RESULT_OID
,theOID of thelastrow insertedbythemost
recent SQL command. Note that
RESULT_OID
is only useful after an
INSERT
command into a table
containing OIDs. Colon-equal (
:=
)canbe used instead of SQL-standard
=
for
GET DIAGNOSTICS
.
An example:
GET DIAGNOSTICS integer_var = ROW_COUNT;
The second method to determine the effects of a command is to check the special variable named
FOUND
,which is of type
boolean
.
FOUND
starts out false within each PL/pgSQL function call. It is
set by each of the following types of statements:
A
SELECT INTO
statement sets
FOUND
true if a row is assigned, false if no row is returned.
A
PERFORM
statement sets
FOUND
true if it produces (and discards) one or more rows, false if no
row is produced.
UPDATE
,
INSERT
,and
DELETE
statements set
FOUND
true if at least one row is affected, false if no
row is affected.
A
FETCH
statement sets
FOUND
true if it returns a row, false if no row is returned.
A
MOVE
statement sets
FOUND
true if it successfully repositions the cursor, false otherwise.
A
FOR
or
FOREACH
statement sets
FOUND
true if it iterates one or more times, else false.
FOUND
is
set this way when the loop exits; inside the execution of the loop,
FOUND
is not modified by the
loop statement, although it might be changed by the execution of other statements within the loop
body.
RETURN QUERY
and
RETURN QUERY EXECUTE
statements set
FOUND
true if the query returns at
least one row, false if no row is returned.
Other PL/pgSQL statements do not change the state of
FOUND
. Note in particular that
EXECUTE
changes the output of
GET DIAGNOSTICS
,but does not change
FOUND
.
FOUND
is a local variable within each PL/pgSQL function; any changes to it affect only the current
function.
40.5.6. Doing Nothing At All
Sometimes a placeholder statement that does nothing is useful. For example, it can indicate that one
arm of an if/then/else chain is deliberately empty. For this purpose, use the
NULL
statement:
NULL;
1045
Chapter 40. PL/pgSQL - SQL Procedural Language
For example, the following two fragments of code are equivalent:
BEGIN
y := x / 0;
EXCEPTION
WHEN division_by_zero THEN
NULL;
-- ignore the error
END;
BEGIN
y := x / 0;
EXCEPTION
WHEN division_by_zero THEN
-- ignore the error
END;
Which is preferable is a matter of taste.
Note: In Oracle’s PL/SQL, empty statement lists are not allowed, and so
NULL
statements are
required for situations such as this. PL/pgSQL allows you to just write nothing, instead.
40.6. Control Structures
Control structures are probably the most useful (and important) part of PL/pgSQL. With PL/pgSQL’s
control structures, you can manipulate PostgreSQL data in a very flexible and powerful way.
40.6.1. Returning From a Function
There aretwo commands available thatallowyoutoreturn data from afunction:
RETURN
and
RETURN
NEXT
.
40.6.1.1.
RETURN
RETURN
expression
;
RETURN
with anexpressionterminatesthe function and returns thevalueof
expression
tothe caller.
This form is used for PL/pgSQL functions that do not return a set.
In a function that returns a scalar type, the expression’s result will automatically be cast into the
function’s return type as described for assignments. But to return a composite (row) value, you must
write an expression delivering exactly the requested column set. This may require use of explicit
casting.
If you declared the function with output parameters, write just
RETURN
with no expression. The cur-
rent values of the output parameter variables will be returned.
If you declared the function toreturn
void
,a
RETURN
statement canbe used toexit the function early;
but do not write an expression following
RETURN
.
The return value of a function cannot be left undefined. If control reaches the end of the top-level
block of the functionwithout hitting a
RETURN
statement, a run-time error will occur. This restriction
1046
Chapter 40. PL/pgSQL - SQL Procedural Language
does not apply to functions with output parameters and functions returning
void
,however. In those
cases a
RETURN
statement is automatically executed if the top-level block finishes.
Some examples:
-- functions returning a scalar type
RETURN 1 + 2;
RETURN scalar_var;
-- functions returning a composite type
RETURN composite_type_var;
RETURN (1, 2, ’three’::text);
-- must cast columns to correct types
40.6.1.2.
RETURN NEXT
and
RETURN QUERY
RETURN NEXT
expression
;
RETURN QUERY
query
;
RETURN QUERY EXECUTE
command-string
[ USING
expression
[, ... ] ];
When a PL/pgSQL functionis declared to return
SETOF
sometype
,theprocedure tofollow is slightly
different. In that case, the individual items to return are specified by a sequence of
RETURN NEXT
or
RETURN QUERY
commands, and then a final
RETURN
command with no argument is used to indicate
that the function has finished executing.
RETURN NEXT
can be used with both scalar and composite
data types; with a composite result type, an entire “table” of results will be returned.
RETURN QUERY
appends the results of executing a query to the function’s result set.
RETURN NEXT
and
RETURN
QUERY
can be freely intermixed in a single set-returning function, in which case their results will be
concatenated.
RETURN NEXT
and
RETURN QUERY
do not actually return from the function — they simply append
zero or more rows to the function’s result set. Execution then continues with the next statement in
the PL/pgSQL function. As successive
RETURN NEXT
or
RETURN QUERY
commands are executed,
the result set is built up. A final
RETURN
,which should have no argument, causes control to exit the
function (or you can just let control reach the end of the function).
RETURN QUERY
has a variant
RETURN QUERY EXECUTE
,which specifies the query to be executed
dynamically. Parameter expressions can be inserted into the computed query string via
USING
,in just
the same way as in the
EXECUTE
command.
If youdeclared the functionwith output parameters, write just
RETURN NEXT
withno expression. On
each execution, the current values of the outputparameter variable(s) willbe saved for eventualreturn
as a row of the result. Note that you must declare the function as returning
SETOF record
when
there are multiple output parameters, or
SETOF
sometype
when there is just one output parameter of
type
sometype
,in order to create a set-returning function with output parameters.
Here is an example of a function using
RETURN NEXT
:
CREATE TABLE foo (fooid INT, foosubid INT, fooname TEXT);
INSERT INTO foo VALUES (1, 2, ’three’);
INSERT INTO foo VALUES (4, 5, ’six’);
CREATE OR REPLACE FUNCTION get_all_foo() RETURNS SETOF foo AS
$BODY$
DECLARE
r foo%rowtype;
BEGIN
1047
Documents you may be interested
Documents you may be interested