pdf viewer in asp net c# : How to add an image to a pdf file in acrobat control software platform web page windows azure web browser postgresql-9.4-A498-part3025

Chapter 35. Extending SQL
When the return value of a function is declared as a polymorphic type, there must be at least one
argument position that is also polymorphic, and the actual data type supplied as the argument deter-
mines the actual result type for that call. For example, if there were not already an array subscripting
mechanism, one could define a function that implements subscripting as
subscript(anyarray,
integer) returns anyelement
.This declaration constrains the actual first argument to be an
array type, and allows the parser to infer the correct result type from the actual first argument’s type.
Another example is that a function declared as
f(anyarray) returns anyenum
will only accept
arrays of enum types.
Note that
anynonarray
and
anyenum
do not represent separate type variables; they are the same
type as
anyelement
, just with an additional constraint. For example, declaring a function as
f(anyelement, anyenum)
is equivalent to declaring it as
f(anyenum, anyenum)
:both actual
arguments have to be the same enum type.
Avariadic function (one taking a variable number of arguments, as in Section 35.4.5) can be poly-
morphic: this is accomplished by declaring its last parameter as
VARIADIC anyarray
.For purposes
of argument matching and determining the actual result type, such a function behaves the same as if
you had written the appropriate number of
anynonarray
parameters.
35.3. User-defined Functions
PostgreSQL provides four kinds of functions:
query language functions (functions written in SQL) (Section 35.4)
procedural language functions (functions written in, for example, PL/pgSQL or PL/Tcl) (Section
35.7)
internal functions (Section 35.8)
C-language functions (Section 35.9)
Every kind of function can take base types, composite types, or combinations of these as arguments
(parameters). In addition, everykind of functioncanreturna basetype or a composite type. Functions
can also be defined to return sets of base or composite values.
Many kinds of functions cantake or return certain pseudo-types (such as polymorphic types), but the
available facilities vary. Consult the description of each kind of function for more details.
It’s easiest todefine SQL functions, so we’ll start by discussingthose. Mostof the concepts presented
for SQL functions will carry over to the other types of functions.
Throughout this chapter, it can be useful to look at the reference page of the CREATE FUNC-
TIONcommand tounderstand the examples better. Some examples from this chapter can be found in
funcs.sql
and
funcs.c
in the
src/tutorial
directory in the PostgreSQL source distribution.
35.4. Query Language (SQL) Functions
SQL functions execute an arbitrary list of SQL statements, returning the result of the last query in
the list. In the simple (non-set) case, the first row of the last query’s result will be returned. (Bear in
908
How to add an image to a pdf file in 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
add png to pdf preview; how to add an image to a pdf in acrobat
How to add an image to a pdf file in 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
add jpg to pdf; add signature image to pdf
Chapter 35. Extending SQL
mind that “the first row” of a multirow result is not well-defined unless you use
ORDER BY
.) If the
last query happens to return no rows at all, the null value will be returned.
Alternatively, an SQL function can be declared to return a set (that is, multiple rows) by speci-
fying the function’s return type as
SETOF
sometype
, or equivalently by declaring it as
RETURNS
TABLE(
columns
)
.In this case all rows of the last query’s result are returned. Further details appear
below.
The body of anSQL function must be a list of SQL statements separatedby semicolons. Asemicolon
after the last statement is optional. Unless the function is declared to return
void
,the last statement
must be a
SELECT
,or an
INSERT
,
UPDATE
,or
DELETE
that has a
RETURNING
clause.
Any collectionof commands intheSQL language canbe packaged together anddefined as a function.
Besides
SELECT
queries, the commands can include data modification queries (
INSERT
,
UPDATE
,
and
DELETE
), as well as other SQL commands. (You cannot use transaction control commands, e.g.
COMMIT
,
SAVEPOINT
,and some utility commands, e.g.
VACUUM
,in SQL functions.) However, the
final command must be a
SELECT
or have a
RETURNING
clause that returns whatever is specified as
the function’s return type. Alternatively, if you want to define a SQL function that performs actions
but has no useful value to return, you can define it as returning
void
.For example, this function
removes rows with negative salaries from the
emp
table:
CREATE FUNCTION clean_emp() RETURNS void AS ’
DELETE FROM emp
WHERE salary < 0;
’ LANGUAGE SQL;
SELECT clean_emp();
clean_emp
-----------
(1 row)
Note: The entire body of a SQL function is parsed before any of it is executed. While a SQL
function can contain commands that alter the system catalogs (e.g.,
CREATE TABLE
), the effects
of such commands will not be visible during parse analysis of later commands in the function.
Thus, for example,
CREATE TABLE foo (...); INSERT INTO foo VALUES(...);
will not work
as desired if packaged up into a single SQL function, since
foo
won’t exist yet when the
INSERT
command is parsed. It’s recommended to use PL/PgSQL insteadof a SQLfunctionin this type of
situation.
The syntax of the
CREATE FUNCTION
command requires the function body to be written as a string
constant. It is usually most convenient to use dollar quoting (see Section 4.1.2.4) for the string con-
stant. If you choose to use regular single-quoted stringconstant syntax, you must double single quote
marks (
)andbackslashes (
\
)(assumingescape stringsyntax) inthe bodyof the function(seeSection
4.1.2.1).
35.4.1. Arguments for SQL Functions
Arguments of a SQL function can be referenced in the function body using either names or numbers.
Examples of both methods appear below.
909
.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 an image to a pdf file in acrobat; add picture to pdf online
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
how to add image to pdf file; adding images to a pdf document
Chapter 35. Extending SQL
To use a name, declare the function argument as having a name, and then just write that name in the
function body. If the argument name is the same as any column name in the current SQL command
within the function, the column name will take precedence. To override this, qualify the argument
name with the name of the function itself, that is
function_name
.
argument_name
. (If this would
conflict with a qualified column name, again the column name wins. You can avoid the ambiguity by
choosing a different alias for the table within the SQL command.)
In the older numeric approach, arguments are referenced using the syntax
$
n
:
$1
refers to the first
input argument,
$2
to the second, and so on. This will work whether or not the particular argument
was declared witha name.
If an argument is of a composite type, then the dot notation, e.g.,
argname.fieldname
or
$1.fieldname
,can be used to access attributes of the argument. Again, you might need to qualify
the argument’s name with the function name to make the form with an argument name unambiguous.
SQL function arguments can only be used as data values, not as identifiers. Thus for example this is
reasonable:
INSERT INTO mytable VALUES ($1);
but this will not work:
INSERT INTO $1 VALUES (42);
Note: The ability to use names to reference SQL function arguments was added in PostgreSQL
9.2. Functions to be used in older servers must use the
$
n
notation.
35.4.2. SQL Functions on Base Types
The simplest possible SQL function has no arguments and simply returns a base type, such as
integer
:
CREATE FUNCTION one() RETURNS integer AS $$
SELECT 1 AS result;
$$ LANGUAGE SQL;
-- Alternative syntax for string literal:
CREATE FUNCTION one() RETURNS integer AS ’
SELECT 1 AS result;
’ LANGUAGE SQL;
SELECT one();
one
-----
1
Notice that we defined a column alias within the function body for the resultof the function (with the
name
result
), but this column alias is not visible outside the function. Hence, the result is labeled
one
instead of
result
.
910
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.
how to add jpg to pdf file; add signature image to pdf acrobat
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 a jpg to a pdf; add jpg to pdf preview
Chapter 35. Extending SQL
It is almost as easy to define SQL functions that take base types as arguments:
CREATE FUNCTION add_em(x integer, y integer) RETURNS integer AS $$
SELECT x + y;
$$ LANGUAGE SQL;
SELECT add_em(1, 2) AS answer;
answer
--------
3
Alternatively, we could dispense with names for the arguments and use numbers:
CREATE FUNCTION add_em(integer, integer) RETURNS integer AS $$
SELECT $1 + $2;
$$ LANGUAGE SQL;
SELECT add_em(1, 2) AS answer;
answer
--------
3
Here is a more useful function, which might be used to debit a bank account:
CREATE FUNCTION tf1 (accountno integer, debit numeric) RETURNS integer AS $$
UPDATE bank
SET balance = balance - debit
WHERE accountno = tf1.accountno;
SELECT 1;
$$ LANGUAGE SQL;
Auser could execute this function to debit account 17 by $100.00 as follows:
SELECT tf1(17, 100.0);
In this example, we chose the name
accountno
for the first argument, but this is the same as the
name of a column in the
bank
table. Within the
UPDATE
command,
accountno
refers to the column
bank.accountno
,so
tf1.accountno
must be used to refer to the argument. We could of course
avoid this by using a different name for the argument.
In practice one would probably like a more useful result from the function than a constant 1, so a
more likelydefinition is:
CREATE FUNCTION tf1 (accountno integer, debit numeric) RETURNS integer AS $$
UPDATE bank
SET balance = balance - debit
WHERE accountno = tf1.accountno;
SELECT balance FROM bank WHERE accountno = tf1.accountno;
$$ LANGUAGE SQL;
911
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
how to add an image to a pdf in reader; how to add an image to a pdf
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
add image field to pdf form; add photo to pdf form
Chapter 35. Extending SQL
which adjusts thebalance andreturns the new balance. The same thing couldbedone in one command
using
RETURNING
:
CREATE FUNCTION tf1 (accountno integer, debit numeric) RETURNS integer AS $$
UPDATE bank
SET balance = balance - debit
WHERE accountno = tf1.accountno
RETURNING balance;
$$ LANGUAGE SQL;
35.4.3. SQL Functions on Composite Types
When writingfunctions witharguments of compositetypes, wemustnot onlyspecifywhichargument
we wantbut also the desired attribute (field) of thatargument. For example, suppose that
emp
is atable
containing employee data, and therefore alsothe name of the composite type of each row of the table.
Here isa function
double_salary
thatcomputes whatsomeone’s salarywouldbeif itwere doubled:
CREATE TABLE emp (
name
text,
salary
numeric,
age
integer,
cubicle
point
);
INSERT INTO emp VALUES (’Bill’, 4200, 45, ’(2,1)’);
CREATE FUNCTION double_salary(emp) RETURNS numeric AS $$
SELECT $1.salary
*
2 AS salary;
$$ LANGUAGE SQL;
SELECT name, double_salary(emp.
*
) AS dream
FROM emp
WHERE emp.cubicle ~= point ’(2,1)’;
name | dream
------+-------
Bill |
8400
Notice the use of the syntax
$1.salary
to select one field of the argument row value. Also notice
how the calling
SELECT
command uses
*
to select the entire current row of a table as a composite
value. The table row can alternatively be referenced using just the table name, like this:
SELECT name, double_salary(emp) AS dream
FROM emp
WHERE emp.cubicle ~= point ’(2,1)’;
but this usage is deprecated since it’s easy to get confused.
Sometimes it is handy to construct a composite argument value on-the-fly. This can be done with the
ROW
construct. For example, we could adjust the data being passed to the function:
SELECT name, double_salary(ROW(name, salary
*
1.1, age, cubicle)) AS dream
FROM emp;
912
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 picture to pdf reader; adding an image to a pdf form
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;
how to add a photo to a pdf document; how to add a jpg to a pdf
Chapter 35. Extending SQL
It is also possible to build a function that returns a composite type. This is an example of a function
that returns a single
emp
row:
CREATE FUNCTION new_emp() RETURNS emp AS $$
SELECT text ’None’ AS name,
1000.0 AS salary,
25 AS age,
point ’(2,2)’ AS cubicle;
$$ LANGUAGE SQL;
In this example we have specified each of the attributes with a constant value, but any computation
could have been substitutedfor these constants.
Note two important things about defining the function:
The select list order in the query must be exactly the same as that in which the columns appear in
the table associated with the composite type. (Naming the columns, as we did above, is irrelevant
to the system.)
You must typecast the expressions to match the definition of the composite type, or you will get
errors like this:
ERROR:
function declared to return emp returns varchar instead of text at column 1
Adifferent way to define the same function is:
CREATE FUNCTION new_emp() RETURNS emp AS $$
SELECT ROW(’None’, 1000.0, 25, ’(2,2)’)::emp;
$$ LANGUAGE SQL;
Here we wrote a
SELECT
that returns just a single column of the correct composite type. This isn’t
really better in this situation, but it is a handy alternative in some cases — for example, if we need to
compute the result bycalling another function that returns the desired composite value.
We could call this function directly in either of two ways:
SELECT new_emp();
new_emp
--------------------------
(None,1000.0,25,"(2,2)")
SELECT
*
FROM new_emp();
name | salary | age | cubicle
------+--------+-----+---------
None | 1000.0 |
25 | (2,2)
The second way is described more fully in Section 35.4.7.
When you use a function that returns a composite type, youmightwant only one field(attribute) from
its result. You can do that with syntax like this:
SELECT (new_emp()).name;
name
913
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 picture to pdf in preview; how to add a jpeg to a pdf file
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
how to add a jpeg to a pdf; add jpg to pdf online
Chapter 35. Extending SQL
------
None
The extra parentheses are needed tokeep the parser from getting confused. If you try to do it without
them, you get something like this:
SELECT new_emp().name;
ERROR:
syntax error at or near "."
LINE 1: SELECT new_emp().name;
^
Another option is touse functional notation for extractingan attribute. The simple way to explain this
is that we can use the notations
attribute(table)
and
table.attribute
interchangeably.
SELECT name(new_emp());
name
------
None
-- This is the same as:
-- SELECT emp.name AS youngster FROM emp WHERE emp.age < 30;
SELECT name(emp) AS youngster FROM emp WHERE age(emp) < 30;
youngster
-----------
Sam
Andy
Tip: The equivalence between functional notation and attribute notation makes it possible to use
functions on composite types to emulate “computed fields”. For example, using the previous
definition for
double_salary(emp)
,we can write
SELECT emp.name, emp.double_salary FROM emp;
An application using this wouldn’t need to be directly aware that
double_salary
isn’t a real col-
umn of the table. (You can also emulate computed fields with views.)
Because of this behavior, it’s unwise to give a function that takes a single composite-type argu-
ment the same name as any of the fields of that composite type.
Another way to use a functionreturning a composite type is to pass the result to another function that
accepts the correct row type as input:
CREATE FUNCTION getname(emp) RETURNS text AS $$
SELECT $1.name;
$$ LANGUAGE SQL;
SELECT getname(new_emp());
getname
---------
None
914
Chapter 35. Extending SQL
(1 row)
Still another way to use a function that returns a composite type is to call it as a table function, as
described in Section 35.4.7.
35.4.4. SQL Functions with Output Parameters
An alternative way of describing a function’s results is to define it with output parameters, as in this
example:
CREATE FUNCTION add_em (IN x int, IN y int, OUT sum int)
AS ’SELECT x + y’
LANGUAGE SQL;
SELECT add_em(3,7);
add_em
--------
10
(1 row)
This is not essentially different from the version of
add_em
shown in Section 35.4.2. The real value
of output parameters is that they provide a convenient way of defining functions that return several
columns. For example,
CREATE FUNCTION sum_n_product (x int, y int, OUT sum int, OUT product int)
AS ’SELECT x + y, x
*
y’
LANGUAGE SQL;
SELECT
*
FROM sum_n_product(11,42);
sum | product
-----+---------
53 |
462
(1 row)
What has essentially happened here is that we have created an anonymous composite type for the
result of the function. The above example has the same end result as
CREATE TYPE sum_prod AS (sum int, product int);
CREATE FUNCTION sum_n_product (int, int) RETURNS sum_prod
AS ’SELECT $1 + $2, $1
*
$2’
LANGUAGE SQL;
but not having to bother with the separate composite type definition is often handy. Notice that the
names attached to the output parameters are not just decoration, but determine the column names of
the anonymous composite type. (If you omit a name for an output parameter, the system will choose
aname on its own.)
Notice that output parameters are not included in the calling argument list when invoking such a
function from SQL. This is because PostgreSQL considers only the input parameters to define the
function’s calling signature. That means also that only the input parameters matter when referencing
the function for purposes such as dropping it. We could dropthe above function with either of
DROP FUNCTION sum_n_product (x int, y int, OUT sum int, OUT product int);
915
Chapter 35. Extending SQL
DROP FUNCTION sum_n_product (int, int);
Parameters canbe markedas
IN
(thedefault),
OUT
,
INOUT
,or
VARIADIC
.An
INOUT
parameter serves
as bothan input parameter (partof the calling argumentlist) and an outputparameter (partof the result
record type).
VARIADIC
parameters are input parameters, but are treated specially as described next.
35.4.5. SQL Functions with Variable Numbers of
Arguments
SQL functions can be declared to accept variable numbers of arguments, so longas all the “optional”
arguments are of the same data type. The optional arguments will be passed to the function as an
array. The function is declared by marking the last parameter as
VARIADIC
;this parameter must be
declared as being of an array type. For example:
CREATE FUNCTION mleast(VARIADIC arr numeric[]) RETURNS numeric AS $$
SELECT min($1[i]) FROM generate_subscripts($1, 1) g(i);
$$ LANGUAGE SQL;
SELECT mleast(10, -1, 5, 4.4);
mleast
--------
-1
(1 row)
Effectively, all the actual arguments at or beyond the
VARIADIC
position are gathered up into a one-
dimensional array, as if you had written
SELECT mleast(ARRAY[10, -1, 5, 4.4]);
-- doesn’t work
You can’t actuallywrite that, though — or at least, it will not match this function definition. Aparam-
eter marked
VARIADIC
matches one or more occurrences of its element type, not of its own type.
Sometimes it is useful to be able to pass an already-constructed array to a variadic function; this is
particularly handy when one variadic function wants to pass on its array parameter to another one.
You can dothat by specifying
VARIADIC
in the call:
SELECT mleast(VARIADIC ARRAY[10, -1, 5, 4.4]);
This prevents expansion of the function’s variadic parameter into its element type, thereby allow-
ing the array argument value to match normally.
VARIADIC
can only be attached to the last actual
argument of a function call.
Specifying
VARIADIC
in the call is also the only way to pass an empty array to a variadic function,
for example:
SELECT mleast(VARIADIC ARRAY[]::numeric[]);
Simply writing
SELECT mleast()
does not work because a variadic parameter must match at least
one actual argument. (You could define a second function also named
mleast
,with no parameters, if
you wanted to allow such calls.)
The array elementparameters generatedfrom avariadicparameter are treatedasnothaving anynames
of their own. This means it is not possible to call a variadic function using named arguments (Section
4.3), except when you specify
VARIADIC
.For example, this will work:
916
Chapter 35. Extending SQL
SELECT mleast(VARIADIC arr := ARRAY[10, -1, 5, 4.4]);
but not these:
SELECT mleast(arr := 10);
SELECT mleast(arr := ARRAY[10, -1, 5, 4.4]);
35.4.6. SQL Functions with Default Values for Arguments
Functions can be declared with default values for some or all input arguments. The default values are
inserted whenever the function is called with insufficiently many actual arguments. Since arguments
can only be omitted from the end of the actual argument list, all parameters after a parameter with
adefault value have to have default values as well. (Although the use of named argument notation
could allowthis restrictionto be relaxed, it’s still enforced so that positional argument notation works
sensibly.)
For example:
CREATE FUNCTION foo(a int, b int DEFAULT 2, c int DEFAULT 3)
RETURNS int
LANGUAGE SQL
AS $$
SELECT $1 + $2 + $3;
$$;
SELECT foo(10, 20, 30);
foo
-----
60
(1 row)
SELECT foo(10, 20);
foo
-----
33
(1 row)
SELECT foo(10);
foo
-----
15
(1 row)
SELECT foo();
-- fails since there is no default for the first argument
ERROR:
function foo() does not exist
The
=
sign can also be used in place of the key word
DEFAULT
.
917
Documents you may be interested
Documents you may be interested