pdf viewer in asp net c# : Add image pdf document SDK control project winforms web page .net UWP postgresql-9.4-A499-part3026

Chapter 35. Extending SQL
35.4.7. SQL Functions as Table Sources
AllSQL functions can be used inthe
FROM
clause of a query, but it is particularlyuseful for functions
returning composite types. If the function is defined to return a base type, the table function produces
aone-column table. If the function is defined to return a composite type, the table function produces
acolumn for each attribute of the composite type.
Here is an example:
CREATE TABLE foo (fooid int, foosubid int, fooname text);
INSERT INTO foo VALUES (1, 1, ’Joe’);
INSERT INTO foo VALUES (1, 2, ’Ed’);
INSERT INTO foo VALUES (2, 1, ’Mary’);
CREATE FUNCTION getfoo(int) RETURNS foo AS $$
SELECT
*
FROM foo WHERE fooid = $1;
$$ LANGUAGE SQL;
SELECT
*
, upper(fooname) FROM getfoo(1) AS t1;
fooid | foosubid | fooname | upper
-------+----------+---------+-------
1 |
1 | Joe
| JOE
(1 row)
As the example shows, we can work with the columns of the function’s result just the same as if they
were columns of a regular table.
Note that we only got one row out of the function. This is because we did not use
SETOF
.That is
described in the next section.
35.4.8. SQL Functions Returning Sets
When an SQL function is declared as returning
SETOF
sometype
,the function’s final query is exe-
cutedto completion, and each row it outputs is returned as an element of the result set.
This feature is normally used when calling the function in the
FROM
clause. In this case each row
returned by the function becomes a rowof the table seenby the query. For example, assume thattable
foo
has the same contents as above, and we say:
CREATE FUNCTION getfoo(int) RETURNS SETOF foo AS $$
SELECT
*
FROM foo WHERE fooid = $1;
$$ LANGUAGE SQL;
SELECT
*
FROM getfoo(1) AS t1;
Then we would get:
fooid | foosubid | fooname
-------+----------+---------
1 |
1 | Joe
1 |
2 | Ed
(2 rows)
It is also possible to return multiple rows with the columns defined by output parameters, like this:
918
Add image pdf document - 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 jpg to pdf form; add image to pdf
Add image pdf document - 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 in preview; add an image to a pdf
Chapter 35. Extending SQL
CREATE TABLE tab (y int, z int);
INSERT INTO tab VALUES (1, 2), (3, 4), (5, 6), (7, 8);
CREATE FUNCTION sum_n_product_with_tab (x int, OUT sum int, OUT product int)
RETURNS SETOF record
AS $$
SELECT $1 + tab.y, $1
*
tab.y FROM tab;
$$ LANGUAGE SQL;
SELECT
*
FROM sum_n_product_with_tab(10);
sum | product
-----+---------
11 |
10
13 |
30
15 |
50
17 |
70
(4 rows)
The key point here is that you must write
RETURNS SETOF record
to indicate that the function
returns multiple rows instead of just one. If there is onlyone output parameter, write that parameter’s
type instead of
record
.
Itis frequently usefultoconstruct a query’s resultby invoking a set-returning function multiple times,
with the parameters for each invocation coming from successive rows of a table or subquery. The
preferred way to do this is to use the
LATERAL
key word, which is described in Section 7.2.1.5. Here
is an example using a set-returning function to enumerate elements of a tree structure:
SELECT
*
FROM nodes;
name
| parent
-----------+--------
Top
|
Child1
| Top
Child2
| Top
Child3
| Top
SubChild1 | Child1
SubChild2 | Child1
(6 rows)
CREATE FUNCTION listchildren(text) RETURNS SETOF text AS $$
SELECT name FROM nodes WHERE parent = $1
$$ LANGUAGE SQL STABLE;
SELECT
*
FROM listchildren(’Top’);
listchildren
--------------
Child1
Child2
Child3
(3 rows)
SELECT name, child FROM nodes, LATERAL listchildren(name) AS child;
name
|
child
--------+-----------
Top
| Child1
Top
| Child2
Top
| Child3
Child1 | SubChild1
919
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
Get image information, such as its location, zonal information, metadata, and so on. Able to edit, add, delete, move, and output PDF document image.
add jpg to pdf file; add picture to pdf document
VB.NET PDF Image Extract Library: Select, copy, paste PDF images
More detailed functions are listed below. DLLs for PDF Image Extraction in VB.NET. Add necessary references: VB.NET: Extract All Images from PDF Document.
how to add an image to a pdf file; adding images to pdf
Chapter 35. Extending SQL
Child1 | SubChild2
(5 rows)
This exampledoes not do anything thatwecouldn’thavedone witha simple join, but in more complex
calculations the option to put some of the work into a function can be quite convenient.
Currently, functions returning sets can also be called in the select list of a query. For each row that
the querygenerates byitself, the function returning set is invoked, and an output row is generated for
each element of the function’s result set. Note, however, that this capability is deprecated and might
be removed in future releases. The previous example could also be done with queries like these:
SELECT listchildren(’Top’);
listchildren
--------------
Child1
Child2
Child3
(3 rows)
SELECT name, listchildren(name) FROM nodes;
name
| listchildren
--------+--------------
Top
| Child1
Top
| Child2
Top
| Child3
Child1 | SubChild1
Child1 | SubChild2
(5 rows)
Inthe last
SELECT
,notice thatno output row appears for
Child2
,
Child3
,etc. This happens because
listchildren
returns anempty set for those arguments, so noresult rows are generated. This is the
same behavior as we got from an inner join to the functionresult when usingthe
LATERAL
syntax.
Note: If a function’s last command is
INSERT
,
UPDATE
,or
DELETE
with
RETURNING
,that command
will always be executed to completion, even if the function is not declared with
SETOF
or the
calling query does not fetchall the result rows. Any extra rows producedby the
RETURNING
clause
are silently dropped, but the commanded table modifications still happen (and are all completed
before returning from the function).
Note: The key problem with using set-returning functions in the select list, rather than the
FROM
clause, is that puttingmorethan oneset-returning functioninthe same select list does not behave
very sensibly. (What you actually get if you do so is a number of output rows equal to the least
common multiple of the numbers of rows produced by each set-returning function.) The
LATERAL
syntax produces less surprising results when calling multiple set-returning functions, and should
usually be used instead.
35.4.9. SQL Functions Returning
TABLE
There is another way to declare a function as returning a set, which is to use the syntax
RETURNS
TABLE(
columns
)
.This is equivalent to using one or more
OUT
parameters plus marking the function
920
C# PDF Password Library: add, remove, edit PDF file password in C#
in C#.NET framework. Support to add password to PDF document online or in C#.NET WinForms for PDF file protection. Able to create a
acrobat insert image in pdf; add image in pdf using java
VB.NET PDF Password Library: add, remove, edit PDF file password
allowed. passwordSetting.IsCopy = True ' Allow to assemble document. passwordSetting.IsAssemble = True ' Add password to PDF file.
add photo to pdf reader; adding a png to a pdf
Chapter 35. Extending SQL
as returning
SETOF record
(or
SETOF
asingle output parameter’s type, as appropriate). This nota-
tion is specified in recent versions of the SQL standard, and thus may be more portable than using
SETOF
.
For example, the preceding sum-and-product example could also be done this way:
CREATE FUNCTION sum_n_product_with_tab (x int)
RETURNS TABLE(sum int, product int) AS $$
SELECT $1 + tab.y, $1
*
tab.y FROM tab;
$$ LANGUAGE SQL;
It is not allowed to use explicit
OUT
or
INOUT
parameters with the
RETURNS TABLE
notation — you
must put all the output columns in the
TABLE
list.
35.4.10. Polymorphic SQL Functions
SQL functions can be declared to accept and return the polymorphic types
anyelement
,
anyarray
,
anynonarray
,
anyenum
,and
anyrange
.See Section 35.2.5 for a more detailed explanationof poly-
morphic functions. Here is a polymorphic function
make_array
that builds up an array from two
arbitrary data type elements:
CREATE FUNCTION make_array(anyelement, anyelement) RETURNS anyarray AS $$
SELECT ARRAY[$1, $2];
$$ LANGUAGE SQL;
SELECT make_array(1, 2) AS intarray, make_array(’a’::text, ’b’) AS textarray;
intarray | textarray
----------+-----------
{1,2}
| {a,b}
(1 row)
Notice the use of the typecast
’a’::text
to specify that the argument is of type
text
.This is
required if the argument is just a string literal, since otherwise it would be treated as type
unknown
,
and array of
unknown
is not a valid type. Without the typecast, you will get errors like this:
ERROR:
could not determine polymorphic type because input has type "unknown"
It is permitted to have polymorphic arguments with a fixed return type, but the converse is not. For
example:
CREATE FUNCTION is_greater(anyelement, anyelement) RETURNS boolean AS $$
SELECT $1 > $2;
$$ LANGUAGE SQL;
SELECT is_greater(1, 2);
is_greater
------------
f
(1 row)
CREATE FUNCTION invalid_func() RETURNS anyelement AS $$
SELECT 1;
$$ LANGUAGE SQL;
921
C# Create PDF from images Library to convert Jpeg, png images to
List<Bitmap> images = new List<Bitmap>(); images.Add(new Bitmap(Program.RootPath + "\\" 1.gif")); / Build a PDF document with GIF image.
adding a jpg to a pdf; add a jpeg to a pdf
C# PDF: How to Create PDF Document Viewer in C#.NET with
The PDF document manipulating add-on from RasterEdge DocImage SDK Support thumbnail image and outline preview for quick PDF document page navigation;
how to add an image to a pdf in preview; acrobat insert image into pdf
Chapter 35. Extending SQL
ERROR:
cannot determine result data type
DETAIL:
A function returning a polymorphic type must have at least one polymorphic argument.
Polymorphism can be used with functions that have output arguments. For example:
CREATE FUNCTION dup (f1 anyelement, OUT f2 anyelement, OUT f3 anyarray)
AS ’select $1, array[$1,$1]’ LANGUAGE SQL;
SELECT
*
FROM dup(22);
f2 |
f3
----+---------
22 | {22,22}
(1 row)
Polymorphism can also be used with variadic functions. For example:
CREATE FUNCTION anyleast (VARIADIC anyarray) RETURNS anyelement AS $$
SELECT min($1[i]) FROM generate_subscripts($1, 1) g(i);
$$ LANGUAGE SQL;
SELECT anyleast(10, -1, 5, 4);
anyleast
----------
-1
(1 row)
SELECT anyleast(’abc’::text, ’def’);
anyleast
----------
abc
(1 row)
CREATE FUNCTION concat_values(text, VARIADIC anyarray) RETURNS text AS $$
SELECT array_to_string($2, $1);
$$ LANGUAGE SQL;
SELECT concat_values(’|’, 1, 4, 2);
concat_values
---------------
1|4|2
(1 row)
35.4.11. SQL Functions with Collations
When a SQL function has one or more parameters of collatable data types, a collation is identified
for each function call depending on the collations assigned to the actual arguments, as described in
Section 22.2. If a collation is successfully identified (i.e., there are no conflicts of implicit collations
among the arguments) then allthe collatable parameters are treated as having that collation implicitly.
922
DocImage SDK for .NET: Web Document Image Viewer Online Demo
on the client side without additional add-ins and Microsoft PowerPoint: PPTX, PPS, PPSX; PDF: Portable Document Format; TIFF: Tagged Image File Format;
pdf insert image; add picture pdf
C# PDF Sticky Note Library: add, delete, update PDF note in C#.net
PDF document processing tool, which can perform various PDF annotation works in easy ways. Using this .NET PDF annotation control, C# developers can add a
add an image to a pdf with acrobat; add photo pdf
Chapter 35. Extending SQL
This will affect the behavior of collation-sensitive operations within the function. For example, using
the
anyleast
function describedabove, the result of
SELECT anyleast(’abc’::text, ’ABC’);
will depend on the database’s default collation. In
C
locale the result will be
ABC
,but in many other
locales it will be
abc
.The collation to use can be forced by adding a
COLLATE
clause to any of the
arguments, for example
SELECT anyleast(’abc’::text, ’ABC’ COLLATE "C");
Alternatively, if you wish a function to operate with a particular collation regardless of what it is
called with, insert
COLLATE
clauses as needed in the function definition. This version of
anyleast
would always use
en_US
locale to compare strings:
CREATE FUNCTION anyleast (VARIADIC anyarray) RETURNS anyelement AS $$
SELECT min($1[i] COLLATE "en_US") FROM generate_subscripts($1, 1) g(i);
$$ LANGUAGE SQL;
But note that this will throw an error if applied to a non-collatable data type.
If no common collation can be identified among the actual arguments, then a SQL function treats
its parameters as having their data types’ default collation (which is usually the database’s default
collation, but could be different for parameters of domain types).
The behavior of collatableparameters canbethoughtof asa limitedform of polymorphism, applicable
only to textual data types.
35.5. Function Overloading
More than one function can be defined with the same SQL name, so long as the arguments they take
are different. In other words, function names canbe overloaded. When a queryis executed, the server
will determine which function to call from the data types and the number of the provided arguments.
Overloadingcan alsobe used to simulate functions with a variable number of arguments, up to a finite
maximum number.
When creating a family of overloaded functions, one should be careful not to create ambiguities. For
instance, given the functions:
CREATE FUNCTION test(int, real) RETURNS ...
CREATE FUNCTION test(smallint, double precision) RETURNS ...
it is not immediately clear which function would be called with some trivial input like
test(1,
1.5)
.The currently implemented resolution rules are described in Chapter 10, but it is unwise to
design a system that subtly relies on this behavior.
Afunction that takes a single argument of a composite type should generally not have the same
name as any attribute (field) of that type. Recall that
attribute(table)
is considered equivalent
to
table.attribute
.Inthe case that there is an ambiguity between a function on a composite type
and an attribute of the composite type, the attribute will always be used. It is possible to override that
choice by schema-qualifying the function name (that is,
schema.func(table)
)but it’s better to
avoid the problem by not choosing conflicting names.
Another possible conflict is between variadic and non-variadic functions. For instance, it is possible
to create both
foo(numeric)
and
foo(VARIADIC numeric[])
.In this case it is unclear which
923
Chapter 35. Extending SQL
one should be matched to a call providing a single numeric argument, such as
foo(10.1)
.The rule
is that the function appearingearlier in the search path is used, or if the twofunctions are in the same
schema, the non-variadic one is preferred.
When overloading C-language functions, there is an additional constraint: The C name of each func-
tion in the family of overloaded functions must be different from the C names of all other functions,
either internal or dynamically loaded. If this rule is violated, the behavior is not portable. You might
get a run-time linker error, or one of the functions will get called (usually the internal one). The alter-
native form of the
AS
clause for the SQL
CREATE FUNCTION
command decouples the SQL function
name from the function name in the C source code. For instance:
CREATE FUNCTION test(int) RETURNS int
AS ’
filename
’, ’test_1arg’
LANGUAGE C;
CREATE FUNCTION test(int, int) RETURNS int
AS ’
filename
’, ’test_2arg’
LANGUAGE C;
The names of the C functions here reflect one of many possible conventions.
35.6. Function Volatility Categories
Every function has a volatility classification, with the possibilities being
VOLATILE
,
STABLE
, or
IMMUTABLE
.
VOLATILE
is the default if the CREATE FUNCTION command does not specify a
category. The volatility category is a promise to the optimizer about the behavior of the function:
A
VOLATILE
function can do anything, including modifying the database. It can return different
results on successive calls with the same arguments. The optimizer makes no assumptions about
the behavior of such functions. A query using a volatile function will re-evaluate the function at
every row where its value is needed.
A
STABLE
function cannot modify the database and is guaranteed to return the same results given
the same arguments for all rows within a single statement. This category allows the optimizer to
optimize multiple calls of the function to a single call. In particular, it is safe to use an expression
containing such a function in an index scan condition. (Since an index scan will evaluate the com-
parison value onlyonce, notonceat each row, it is notvalidto use a
VOLATILE
functioninan index
scan condition.)
An
IMMUTABLE
function cannot modify the database and is guaranteed to return the same results
given the same arguments forever. This category allows the optimizer to pre-evaluate the function
whena querycallsitwithconstantarguments. For example, aquerylike
SELECT ... WHERE x =
2 + 2
can be simplifiedonsightto
SELECT ... WHERE x = 4
,because thefunction underlying
the integer addition operator is marked
IMMUTABLE
.
For best optimizationresults, you shouldlabelyour functions withthe strictest volatility categorythat
is valid for them.
Any function with side-effects must be labeled
VOLATILE
,so that calls to it cannot be optimized
away. Even a function with no side-effects needs to be labeled
VOLATILE
if its value can change
within a single query; some examples are
random()
,
currval()
,
timeofday()
.
924
Chapter 35. Extending SQL
Another important example is that the
current_timestamp
family of functions qualifyas
STABLE
,
since their values do not change within a transaction.
There is relatively little difference between
STABLE
and
IMMUTABLE
categories when considering
simple interactive queries that are planned and immediately executed: it doesn’t matter a lot whether
afunction is executed once during planning or once during query execution startup. But there is a big
difference if the plan is saved and reused later. Labeling a function
IMMUTABLE
when it really isn’t
might allow it to be prematurely folded to a constant during planning, resulting in a stale value being
re-used during subsequent uses of the plan. This is a hazard when using prepared statements or when
using function languages that cache plans (such as PL/pgSQL).
For functions written in SQL or in any of the standard procedural languages, there is a second im-
portant property determined by the volatility category, namely the visibility of any data changes that
have been made by the SQL command that is calling the function. A
VOLATILE
function will see
such changes, a
STABLE
or
IMMUTABLE
function will not. This behavior is implemented using the
snapshotting behavior of MVCC (see Chapter 13):
STABLE
and
IMMUTABLE
functions use a snapshot
established as of the start of the calling query, whereas
VOLATILE
functions obtain a fresh snapshot
at the start of each query they execute.
Note: Functions written in C can manage snapshots however they want, but it’s usually a good
idea to makeC functions work this way too.
Because of this snapshotting behavior, a function containing only
SELECT
commands can safely be
marked
STABLE
,even if it selects from tables that might be undergoing modifications by concurrent
queries. PostgreSQL will execute all commands of a
STABLE
function using the snapshot established
for the calling query, and so it will see a fixed view of the database throughout that query.
The same snapshotting behavior is used for
SELECT
commands within
IMMUTABLE
functions. It is
generally unwise to select from database tables within an
IMMUTABLE
function at all, since the im-
mutability will be broken if the table contents ever change. However, PostgreSQL does not enforce
that you donot do that.
Acommon error is to label a function
IMMUTABLE
when its results depend on a configurationparam-
eter. For example, a function that manipulates timestamps might well have results that depend on the
TimeZone setting. For safety, such functions should be labeled
STABLE
instead.
Note: PostgreSQL requires that
STABLE
and
IMMUTABLE
functions contain no SQL commands
other than
SELECT
to prevent data modification. (This is not a completely bulletproof test, since
suchfunctions could still call
VOLATILE
functions that modify the database. If youdo that, youwill
find that the
STABLE
or
IMMUTABLE
function does not notice the database changes applied by the
called function, since they are hidden from its snapshot.)
35.7. Procedural Language Functions
PostgreSQL allows user-definedfunctions tobe written in other languages besides SQL and C. These
other languages are generically called procedural languages (PLs). Procedural languages aren’t built
into the PostgreSQL server; they are offered by loadable modules. See Chapter 39 and following
chapters for more information.
925
Chapter 35. Extending SQL
35.8. Internal Functions
Internal functions are functions written in C that have been statically linked into the PostgreSQL
server. The “body” of the function definition specifies the C-language name of the function, which
neednotbethesameas thename beingdeclared for SQL use. (For reasons of backward compatibility,
an empty body is accepted as meaning that the C-language function name is the same as the SQL
name.)
Normally, all internal functions present in the server are declared during the initialization of the
database cluster (see Section 17.2), but a user could use
CREATE FUNCTION
to create additional alias
names for an internal function. Internal functions are declared in
CREATE FUNCTION
with language
name
internal
.For instance, to create an alias for the
sqrt
function:
CREATE FUNCTION square_root(double precision) RETURNS double precision
AS ’dsqrt’
LANGUAGE internal
STRICT;
(Most internal functions expect to be declared “strict”.)
Note: Not all “predefined” functions are “internal” inthe above sense. Some predefined functions
are written in SQL.
35.9. C-Language Functions
User-defined functions canbewritten inC (or a language thatcan be made compatiblewith C, suchas
C++). Suchfunctions are compiledintodynamicallyloadable objects (also calledsharedlibraries) and
are loadedby the server on demand. The dynamic loading feature is what distinguishes “C language”
functions from “internal” functions — the actualcodingconventions are essentially the same for both.
(Hence, the standard internal function library is a rich source of coding examples for user-defined C
functions.)
Two different calling conventions are currently used for C functions. The newer “version 1” calling
convention is indicated by writing a
PG_FUNCTION_INFO_V1()
macro call for the function, as illus-
trated below. Lack of such a macro indicates an old-style (“version 0”) function. The language name
specified in
CREATE FUNCTION
is
C
in either case. Old-style functions are now deprecated because
of portabilityproblems and lack of functionality, butthey are still supported for compatibility reasons.
35.9.1. Dynamic Loading
The first time a user-defined function in a particular loadable object file is called in a session, the
dynamic loader loads that object file into memory so that the function can be called. The
CREATE
FUNCTION
for a user-defined C function must therefore specify two pieces of information for the
function:the name of the loadable object file, andthe Cname (linksymbol) of the specific function to
call within that object file. If the C name is not explicitly specified then it is assumed to be the same
as the SQL function name.
The following algorithm is usedtolocatetheshared objectfile based on the namegiveninthe
CREATE
FUNCTION
command:
926
Chapter 35. Extending SQL
1. If the name is an absolute path, the given file is loaded.
2. If the name starts with the string
$libdir
,that part is replaced by the PostgreSQL package
library directory name, which is determined at build time.
3. If the name does not contain a directory part, the file is searched for in the path specified by the
configurationvariable dynamic_library_path.
4. Otherwise (the file was not found in the path, or it contains a non-absolute directory part), the
dynamic loader will try to take the name as given, which will most likely fail. (It is unreliable to
depend on the current working directory.)
If this sequence does not work, the platform-specific shared libraryfile name extension(often
.so
)is
appended to the given name and this sequence is tried again. If that fails as well, the load will fail.
Itis recommendedto locate shared libraries either relativeto
$libdir
or through the dynamic library
path. This simplifies version upgrades if the new installation is at a different location. The actual
directory that
$libdir
stands for can be found out with the command
pg_config --pkglibdir
.
The user ID the PostgreSQL server runs as must be able to traverse the path to the file you intend to
load. Making the file or a higher-level directory not readable and/or not executable by the postgres
user is a common mistake.
In any case, the file name that is given in the
CREATE FUNCTION
command is recorded literally in
the system catalogs, soif the file needs to be loaded again the same procedure is applied.
Note: PostgreSQL will not compile a C function automatically. The object file must be compiled
before it is referenced in a
CREATE FUNCTION
command. See Section 35.9.6 for additional infor-
mation.
To ensure that a dynamically loaded object file is notloaded into anincompatible server, PostgreSQL
checks that the file contains a “magic block” with the appropriate contents. This allows the server to
detect obvious incompatibilities, such as code compiled for a different major version of PostgreSQL.
Amagicblock is required as of PostgreSQL 8.2. To include a magic block, write this in one (andonly
one) of the module source files, after having included the header
fmgr.h
:
#ifdef PG_MODULE_MAGIC
PG_MODULE_MAGIC;
#endif
The
#ifdef
test can be omitted if the code doesn’t need to compile against pre-8.2 PostgreSQL
releases.
After it is used for the first time, a dynamically loaded object file is retained in memory. Future calls
in the same session to the function(s) in that file will only incur the small overhead of a symbol table
lookup. If you need to force a reload of an object file, for example after recompiling it, begin a fresh
session.
Optionally, a dynamically loaded file can contain initialization and finalization functions. If the file
includes a function named
_PG_init
,that function will be called immediately after loading the file.
The function receives no parameters and should return void. If the file includes a function named
_PG_fini
,that function will be called immediately before unloading the file. Likewise, the function
receives no parameters and should return void. Note that
_PG_fini
will only be called during an
unload of the file, not during process termination. (Presently, unloads are disabled and will never
occur, but this may change in the future.)
927
Documents you may be interested
Documents you may be interested