pdf viewer dll for c# : Adding an image to a pdf form software control project winforms web page html UWP postgresql-9.4-A4102-part2727

Chapter 35. Extending SQL
Currently, this facility is not exposed to users at the SQL level because of security concerns, so it is
only practical to use for optimizing built-in functions.
35.9.12. Shared Memory and LWLocks
Add-ins can reserve LWLocks and an allocation of shared memory on server startup. The add-in’s
shared library must be preloaded by specifying it in shared_preload_libraries. Shared memory is re-
served by calling:
void RequestAddinShmemSpace(int size)
from your
_PG_init
function.
LWLocks are reserved by calling:
void RequestAddinLWLocks(int n)
from
_PG_init
.
To avoid possible race-conditions, each backend should use the LWLock
AddinShmemInitLock
whenconnecting to and initializing its allocation of shared memory, as shown here:
static mystruct
*
ptr = NULL;
if (!ptr)
{
bool
found;
LWLockAcquire(AddinShmemInitLock, LW_EXCLUSIVE);
ptr = ShmemInitStruct("my struct name", size, &found);
if (!found)
{
initialize contents of shmem area;
acquire any requested LWLocks using:
ptr->mylockid = LWLockAssign();
}
LWLockRelease(AddinShmemInitLock);
}
35.9.13. Using C++ for Extensibility
Although the PostgreSQL backend is written in C, it is possible to write extensions in C++ if these
guidelines are followed:
All functions accessed bythe backend must present a C interface to the backend; these C functions
can then call C++ functions. For example,
extern C
linkage is required for backend-accessed
functions. This is also necessary for any functions that are passed as pointers between the backend
and C++ code.
Free memory using the appropriate deallocation method. For example, most backend memory is
allocated using
palloc()
,so use
pfree()
to free it. UsingC++
delete
in such cases will fail.
948
Adding an image to a pdf form - 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 signature image to pdf; add image pdf document
Adding an image to a pdf form - 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 a jpeg to a pdf; add picture to pdf file
Chapter 35. Extending SQL
Prevent exceptions from propagating into the C code (use a catch-all block at the top level of
all
extern C
functions). This is necessary even if the C++ code does not explicitly throw any
exceptions, because events like out-of-memory can still throw exceptions. Any exceptions must
be caught and appropriate errors passed back to the C interface. If possible, compile C++ with
-fno-exceptions
to eliminate exceptions entirely; in such cases, you must check for failures in
your C++ code, e.g. check for NULL returned by
new()
.
If calling backend functions from C++ code, be sure that the C++ call stackcontains onlyplain old
data structures (POD). This is necessary because backend errors generate adistant
longjmp()
that
does not properly unroll a C++ call stack withnon-POD objects.
In summary, it is best to place C++ code behind a wall of
extern C
functions that interface to the
backend, and avoid exception, memory, and call stack leakage.
35.10. User-defined Aggregates
Aggregate functions inPostgreSQL are defined interms of state values andstate transition functions.
That is, an aggregate operates using a state value that is updated as each successive input row is
processed. To define a new aggregate function, one selects a data type for the state value, an initial
value for the state, and a state transition function. The state transition function takes the previous
state value and the aggregate’s input value(s) for the current row, and returns a new state value. A
final function can also be specified, in case the desired result of the aggregate is different from the
data that needs to be kept in the running state value. The final function takes the last state value and
returns whatever is wanted as the aggregate result. In principle, the transition and final functions are
just ordinary functions that could also be used outside the context of the aggregate. (In practice, it’s
often helpful for performance reasons to create specialized transition functions that can only work
whencalled as part of an aggregate.)
Thus, in addition to the argument and result data types seen by a user of the aggregate, there is an
internal state-value data type that might be different from both the argument and result types.
If we define an aggregate that does not use a final function, we have an aggregate that computes a
running function of the column values from each row.
sum
is an example of this kind of aggregate.
sum
starts at zero and always adds the current row’s value to its running total. For example, if we
want tomake a
sum
aggregate to workona data type for complexnumbers, we onlyneedthe addition
function for that data type. The aggregate definition would be:
CREATE AGGREGATE sum (complex)
(
sfunc = complex_add,
stype = complex,
initcond = ’(0,0)’
);
which we might use like this:
SELECT sum(a) FROM test_complex;
sum
-----------
(34,53.9)
949
VB.NET PDF Page Insert Library: insert pages into PDF file in vb.
Support adding PDF page number. Offer PDF page break inserting function. DLLs for Adding Page into PDF Document in VB.NET Class. Add necessary references:
adding image to pdf form; add an image to a pdf in preview
VB.NET PDF Library SDK to view, edit, convert, process PDF file
PDF document to/from supported document and image forms. to define text or images on PDF document and Capable of adding PDF file navigation features to your VB
how to add an image to a pdf in preview; add jpg to pdf preview
Chapter 35. Extending SQL
(Notice thatwe are relying onfunction overloading:there is more thanone aggregate named
sum
,but
PostgreSQL can figure out which kind of sum applies to a column of type
complex
.)
The above definition of
sum
will return zero (the initial state value) if there are no nonnull input
values. Perhaps we want to return nullin thatcase instead — theSQL standardexpects
sum
to behave
that way. We can do this simply by omitting the
initcond
phrase, so that the initial state value is
null. Ordinarily this would mean that the
sfunc
would need to check for a null state-value input. But
for
sum
and some other simple aggregates like
max
and
min
,it is sufficient to insert the first nonnull
input value intothe state variable and thenstartapplying the transition function at the second nonnull
input value. PostgreSQL will do that automatically if the initial state value is null and the transition
function is marked “strict” (i.e., not to be called for null inputs).
Another bit of default behavior for a “strict” transition function is that the previous state value is
retained unchanged whenever a null input value is encountered. Thus, null values are ignored. If you
needsome other behavior for nullinputs, donot declare your transitionfunctionas strict; insteadcode
it to test for null inputs and do whatever is needed.
avg
(average) is a more complex example of an aggregate. It requires two pieces of running state: the
sum of the inputs and the count of the number of inputs. The final result is obtained by dividing these
quantities. Average is typically implemented by using an array as the state value. For example, the
built-in implementation of
avg(float8)
looks like:
CREATE AGGREGATE avg (float8)
(
sfunc = float8_accum,
stype = float8[],
finalfunc = float8_avg,
initcond = ’{0,0,0}’
);
Note:
float8_accum
requires a three-element array, not just two elements, because it accumu-
lates the sum of squares as well as the sum and count of the inputs. This is sothat it can be used
for some other aggregates as well as
avg
.
Aggregate function calls in SQL allow
DISTINCT
and
ORDER BY
options that control whichrows are
fed to the aggregate’s transition function and in what order. These options are implemented behind
the scenes and are not the concern of the aggregate’s support functions.
For further details see the CREATE AGGREGATE command.
35.10.1. Moving-Aggregate Mode
Aggregatefunctions can optionallysupport moving-aggregate mode, which allows substantially faster
execution of aggregate functions within windows withmoving frame starting points. (See Section3.5
and Section 4.2.8 for information about use of aggregate functions as window functions.) The basic
idea is that in addition to a normal “forward” transition function, the aggregate provides an inverse
transition function, which allows rows to be removed from the aggregate’s running state value when
they exit the window frame. For example a
sum
aggregate, which uses addition as the forward tran-
sition function, woulduse subtraction as the inverse transition function. Without an inverse transition
function, the window function mechanism must recalculate the aggregate from scratch each time the
frame starting point moves, resulting in run time proportional to the number of input rows times the
950
C# PDF Page Insert Library: insert pages into PDF file in C#.net
By using reliable APIs, C# programmers are capable of adding and inserting (empty) PDF page or pages from various file formats, such as PDF, Tiff, Word, Excel
add an image to a pdf form; add image to pdf reader
C# PDF insert text Library: insert text into PDF content in C#.net
Supports adding text to PDF in preview without adobe reader installed in ASP.NET. Powerful .NET PDF edit control allows modify existing scanned PDF text.
add jpeg to pdf; adding image to pdf in preview
Chapter 35. Extending SQL
average frame length. With an inverse transition function, the run time is only proportional to the
number of input rows.
The inverse transition function is passed the current state value and the aggregate input value(s) for
the earliest row includedin the current state. It must reconstruct what the state value wouldhave been
if the given input row had never been aggregated, but only the rows following it. This sometimes
requires that the forward transition function keep more state than is needed for plain aggregation
mode. Therefore, the moving-aggregate mode uses a completely separate implementation from the
plain mode: it has its own state data type, its own forward transition function, and its own final
function if needed. These can be the same as the plain mode’s data type and functions, if there is
no need for extra state.
As an example, we could extend the
sum
aggregate given above to support moving-aggregate mode
like this:
CREATE AGGREGATE sum (complex)
(
sfunc = complex_add,
stype = complex,
initcond = ’(0,0)’,
msfunc = complex_add,
minvfunc = complex_sub,
mstype = complex,
minitcond = ’(0,0)’
);
The parameters whose names begin with
m
define the moving-aggregate implementation. Except for
the inverse transition function
minvfunc
,they correspond to the plain-aggregate parameters without
m
.
The forward transition function for moving-aggregate mode is not allowed to return null as the new
state value. If the inverse transition function returns null, this is taken as an indication that the inverse
function cannot reverse the state calculation for this particular input, andso the aggregate calculation
will be redone from scratch for the current frame starting position. This convention allows moving-
aggregate mode to be used in situations where there are some infrequent cases that are impractical to
reverse out of the running state value. The inverse transition function can “punt” on these cases, and
yet still come out ahead so long as it can work for most cases. As an example, an aggregate working
with floating-pointnumbers might choose to puntwhena
NaN
(not a number) input has to be removed
from the running state value.
When writing moving-aggregate support functions, it is important to be sure that the inverse tran-
sition function can reconstruct the correct state value exactly. Otherwise there might be user-visible
differences in results depending on whether the moving-aggregate mode is used. An example of an
aggregate for which adding an inverse transition function seems easy at first, yet where this require-
ment cannot be met is
sum
over
float4
or
float8
inputs. A naive declaration of
sum(
float8
)
could be
CREATE AGGREGATE unsafe_sum (float8)
(
stype = float8,
sfunc = float8pl,
mstype = float8,
msfunc = float8pl,
minvfunc = float8mi
);
951
C# PDF Library SDK to view, edit, convert, process PDF file for C#
Capable of adding PDF file navigation features to your C# program. You may easily generate thumbnail image from PDF. C#.NET: PDF Form Field Edit.
add photo to pdf reader; how to add an image to a pdf file in acrobat
VB.NET Image: How to Draw Annotation on Doc Images with Image SDK
multi-page TIFF, Microsoft Office Word and PDF file programmer, you might need some other image annotating tutorials besides adding annotation using VB
how to add an image to a pdf in reader; how to add a photo to a pdf document
Chapter 35. Extending SQL
This aggregate, however, can give wildly different results than it would have without the inverse
transition function. For example, consider
SELECT
unsafe_sum(x) OVER (ORDER BY n ROWS BETWEEN CURRENT ROW AND 1 FOLLOWING)
FROM (VALUES (1, 1.0e20::float8),
(2, 1.0::float8)) AS v (n,x);
This queryreturns
0
as its secondresult, rather than the expected answer of
1
.The cause is thelimited
precision of floating-point values: adding
1
to
1e20
results in
1e20
again, and so subtracting
1e20
from that yields
0
,not
1
.Note that this is a limitation of floating-point arithmetic in general, not a
limitation of PostgreSQL.
35.10.2. Polymorphic and Variadic Aggregates
Aggregate functions can use polymorphic state transition functions or final functions, so that the
same functions can be used to implement multiple aggregates. See Section 35.2.5 for an explanation
of polymorphic functions. Going a step further, the aggregate function itself can be specified with
polymorphic input type(s) and state type, allowing a single aggregate definition to serve for multiple
input data types. Here is an example of a polymorphic aggregate:
CREATE AGGREGATE array_accum (anyelement)
(
sfunc = array_append,
stype = anyarray,
initcond = ’{}’
);
Here, the actual state type for any given aggregate call is the array type having the actual input type
as elements. The behavior of the aggregate is to concatenate all the inputs into an array of that type.
(Note:the built-in aggregate
array_agg
provides similar functionality, with better performance than
this definition would have.)
Here’s the output using two different actual data types as arguments:
SELECT attrelid::regclass, array_accum(attname)
FROM pg_attribute
WHERE attnum > 0 AND attrelid = ’pg_tablespace’::regclass
GROUP BY attrelid;
attrelid
|
array_accum
---------------+---------------------------------------
pg_tablespace | {spcname,spcowner,spcacl,spcoptions}
(1 row)
SELECT attrelid::regclass, array_accum(atttypid::regtype)
FROM pg_attribute
WHERE attnum > 0 AND attrelid = ’pg_tablespace’::regclass
GROUP BY attrelid;
attrelid
|
array_accum
---------------+---------------------------
pg_tablespace | {name,oid,aclitem[],text[]}
(1 row)
952
C# PDF Password Library: add, remove, edit PDF file password in C#
Following are examples for adding password to a plain PDF passwordSetting.IsAnnot = true; // Allow to fill form. IsAssemble = true; // Add password to PDF file
add picture to pdf preview; add image to pdf form
VB.NET PDF File & Page Process Library SDK for vb.net, ASP.NET
merge and splitting PDF pages and Files, adding a page is the programmatic representation of a PDF document. of newly created blank pages or image-only pages
how to add image to pdf in preview; add image to pdf in preview
Chapter 35. Extending SQL
Ordinarily, an aggregate function with a polymorphic result type has a polymorphic state type, as in
theaboveexample. This is necessarybecauseotherwise thefinal function cannotbedeclaredsensibly:
it would need to have a polymorphic result type but no polymorphic argument type, which
CREATE
FUNCTION
will rejectonthe grounds that the result typecannotbededucedfrom acall. Butsometimes
it is inconvenient to use a polymorphic state type. The most common case is where the aggregate
support functions are to be written in C and the state type should be declared as
internal
because
there is no SQL-level equivalent for it. To address this case, it is possible to declare the final function
as taking extra “dummy” arguments that match the input arguments of the aggregate. Such dummy
arguments are always passed as null values since no specificvalue is available when the final function
is called. Their only use is to allow a polymorphic final function’s result type to be connected to
the aggregate’s input type(s). For example, the definition of the built-in aggregate
array_agg
is
equivalent to
CREATE FUNCTION array_agg_transfn(internal, anyelement)
RETURNS internal ...;
CREATE FUNCTION array_agg_finalfn(internal, anyelement)
RETURNS anyarray ...;
CREATE AGGREGATE array_agg (anyelement)
(
sfunc = array_agg_transfn,
stype = internal,
finalfunc = array_agg_finalfn,
finalfunc_extra
);
Here, the
finalfunc_extra
option specifies that the final function receives, in addition to the
state value, extra dummy argument(s) corresponding to the aggregate’s input argument(s). The ex-
tra
anyelement
argument allows the declaration of
array_agg_finalfn
to be valid.
An aggregate function can be made to accept a varying number of arguments by declaring its last
argumentas a
VARIADIC
array, in much the same fashionas for regular functions; see Section 35.4.5.
The aggregate’s transition function(s) must have the same array type as their last argument. The
transition function(s) typically would also be marked
VARIADIC
,but this is not strictly required.
Note: Variadic aggregates are easily misused in connection with the
ORDER BY
option (see Sec-
tion4.2.7), since theparser cannot tellwhether thewrong number of actual arguments have been
given in such a combination. Keep in mind that everything to the right of
ORDER BY
is a sort key,
not an argument to the aggregate. For example, in
SELECT myaggregate(a ORDER BY a, b, c) FROM ...
the parser will seethis as a single aggregate function argument and three sort keys. However, the
user might have intended
SELECT myaggregate(a, b, c ORDER BY a) FROM ...
If
myaggregate
is variadic, both these calls could be perfectly valid.
For the same reason, it’s wise to think twice before creating aggregate functions with the same
names and different numbers of regular arguments.
953
Chapter 35. Extending SQL
35.10.3. Ordered-Set Aggregates
The aggregates we have been describing so far are “normal” aggregates. PostgreSQL also supports
ordered-set aggregates, which differ from normal aggregates in two key ways. First, in addition to
ordinary aggregated arguments that are evaluated once per input row, an ordered-set aggregate can
have “direct” arguments that are evaluated only once per aggregation operation. Second, the syntax
for the ordinary aggregated arguments specifies a sort ordering for them explicitly. An ordered-set
aggregate is usually used to implement a computation that depends on a specific row ordering, for
instance rank or percentile, so that the sort ordering is a required aspect of any call. For example, the
built-in definition of
percentile_disc
is equivalent to:
CREATE FUNCTION ordered_set_transition(internal, anyelement)
RETURNS internal ...;
CREATE FUNCTION percentile_disc_final(internal, float8, anyelement)
RETURNS anyelement ...;
CREATE AGGREGATE percentile_disc (float8 ORDER BY anyelement)
(
sfunc = ordered_set_transition,
stype = internal,
finalfunc = percentile_disc_final,
finalfunc_extra
);
This aggregate takes a
float8
direct argument (the percentile fraction) and an aggregated input that
can be of any sortable data type. It could be used to obtain a median household income like this:
SELECT percentile_disc(0.5) WITHIN GROUP (ORDER BY income) FROM households;
percentile_disc
-----------------
50489
Here,
0.5
is a direct argument;itwouldmake no sensefor thepercentile fraction to be a value varying
across rows.
Unlike the case for normal aggregates, the sorting of input rows for an ordered-set aggregate is not
done behind the scenes, but is the responsibility of the aggregate’s support functions. The typical
implementation approach is to keep a reference to a “tuplesort” object in the aggregate’s state value,
feed the incoming rows into that object, and then complete the sorting and read out the data in the
final function. This design allows the final function to perform special operations such as injecting
additional“hypothetical” rows intothedatato be sorted. While normalaggregates can oftenbeimple-
mented with support functions written in PL/pgSQL or another PL language, ordered-set aggregates
generally have to be written in C, since their state values aren’t definable as any SQL data type. (In
the above example, notice that the state value is declared as type
internal
—this is typical.)
The state transition function for an ordered-set aggregate receives the current state value plus
the aggregated input values for each row, and returns the updated state value. This is the same
definition as for normal aggregates, but note that the direct arguments (if any) are not provided.
The final function receives the last state value, the values of the direct arguments if any, and (if
finalfunc_extra
is specified) null values corresponding to the aggregated input(s). As with
normal aggregates,
finalfunc_extra
is only really useful if the aggregate is polymorphic; then
the extra dummy argument(s) are needed to connect the final function’s result type to the aggregate’s
input type(s).
Currently, ordered-set aggregates cannot be used as windowfunctions, and therefore there is no need
for them to support moving-aggregate mode.
954
Chapter 35. Extending SQL
35.10.4. Support Functions for Aggregates
Afunction writtenin C candetectthatit is being called as anaggregate transitionor finalfunction by
calling
AggCheckCallContext
,for example:
if (AggCheckCallContext(fcinfo, NULL))
One reason for checking this is that when it is true for a transition function, the first input must be
atemporary state value and can therefore safely be modified in-place rather than allocating a new
copy. See
int8inc()
for an example. (This is the only case where it is safe for a function to modify
apass-by-reference input. In particular, final functions for normal aggregates must not modify their
inputs in any case, because in some cases they will be re-executed on the same final state value.)
Another support routine available to aggregate functions written in C is
AggGetAggref
,which re-
turns the
Aggref
parse node that defines the aggregate call. This is mainly useful for ordered-set
aggregates, which can inspect the substructure of the
Aggref
node to find out what sort ordering
they are supposed to implement. Examples can be found in
orderedsetaggs.c
in the PostgreSQL
source code.
35.11. User-defined Types
As described in Section 35.2, PostgreSQL can be extended to support new data types. This section
describes how to define new base types, which are data types defined below the level of the SQL
language. Creating a new base type requires implementing functions to operate on the type in a low-
level language, usually C.
The examples in this section can be found in
complex.sql
and
complex.c
in the
src/tutorial
directoryof the source distribution. See the
README
file in thatdirectoryfor instructions about running
the examples.
Auser-defined type must always have input and outputfunctions. These functions determine how the
type appears in strings (for input by the user and output to the user) and how the type is organized in
memory. The input function takes a null-terminated character string as its argument and returns the
internal (in memory) representation of the type. The output function takes the internal representation
of the type as argument and returns a null-terminated character string. If we want to do anything
more with the type than merely store it, we must provide additional functions to implement whatever
operations we’d like to have for the type.
Suppose we want to define a type
complex
that represents complex numbers. A natural way to rep-
resent a complex number in memory would be the following C structure:
typedef struct Complex {
double
x;
double
y;
} Complex;
We willneedtomake this apass-by-reference type, since it’s too large to fit intoa single
Datum
value.
As the external string representation of the type, we choose a string of the form
(x,y)
.
The input and output functions are usuallynot hardto write, especially the output function. But when
defining the external string representation of the type, remember that you must eventually write a
complete and robust parser for that representation as your input function. For instance:
PG_FUNCTION_INFO_V1(complex_in);
955
Chapter 35. Extending SQL
Datum
complex_in(PG_FUNCTION_ARGS)
{
char
*
str = PG_GETARG_CSTRING(0);
double
x,
y;
Complex
*
result;
if (sscanf(str, " ( %lf , %lf )", &x, &y) != 2)
ereport(ERROR,
(errcode(ERRCODE_INVALID_TEXT_REPRESENTATION),
errmsg("invalid input syntax for complex: \"%s\"",
str)));
result = (Complex
*
) palloc(sizeof(Complex));
result->x = x;
result->y = y;
PG_RETURN_POINTER(result);
}
The output function can simplybe:
PG_FUNCTION_INFO_V1(complex_out);
Datum
complex_out(PG_FUNCTION_ARGS)
{
Complex
*
complex = (Complex
*
) PG_GETARG_POINTER(0);
char
*
result;
result = psprintf("(%g,%g)", complex->x, complex->y);
PG_RETURN_CSTRING(result);
}
You should be careful to make the input and output functions inverses of each other. If you do not,
you will have severe problems when you need to dump your data into a file and then read it back in.
This is a particularly common problem when floating-point numbers are involved.
Optionally, a user-defined type can provide binary input and output routines. Binary I/O is nor-
mally faster but less portable than textual I/O. As with textual I/O, it is up to you to define exactly
what the external binary representation is. Most of the built-in data types try to provide a machine-
independentbinaryrepresentation. For
complex
,we will piggy-back on the binaryI/O converters for
type
float8
:
PG_FUNCTION_INFO_V1(complex_recv);
Datum
complex_recv(PG_FUNCTION_ARGS)
{
StringInfo
buf = (StringInfo) PG_GETARG_POINTER(0);
Complex
*
result;
result = (Complex
*
) palloc(sizeof(Complex));
result->x = pq_getmsgfloat8(buf);
result->y = pq_getmsgfloat8(buf);
956
Chapter 35. Extending SQL
PG_RETURN_POINTER(result);
}
PG_FUNCTION_INFO_V1(complex_send);
Datum
complex_send(PG_FUNCTION_ARGS)
{
Complex
*
complex = (Complex
*
) PG_GETARG_POINTER(0);
StringInfoData buf;
pq_begintypsend(&buf);
pq_sendfloat8(&buf, complex->x);
pq_sendfloat8(&buf, complex->y);
PG_RETURN_BYTEA_P(pq_endtypsend(&buf));
}
Once we have written the I/O functions and compiled them into a shared library, we can define the
complex
type in SQL. First we declare it as a shell type:
CREATE TYPE complex;
This serves as a placeholder that allows us to reference the type while defining its I/O functions. Now
we can define the I/O functions:
CREATE FUNCTION complex_in(cstring)
RETURNS complex
AS ’
filename
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION complex_out(complex)
RETURNS cstring
AS ’
filename
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION complex_recv(internal)
RETURNS complex
AS ’
filename
LANGUAGE C IMMUTABLE STRICT;
CREATE FUNCTION complex_send(complex)
RETURNS bytea
AS ’
filename
LANGUAGE C IMMUTABLE STRICT;
Finally, we can provide the full definition of the data type:
CREATE TYPE complex (
internallength = 16,
input = complex_in,
output = complex_out,
receive = complex_recv,
send = complex_send,
alignment = double
957
Documents you may be interested
Documents you may be interested