pdf viewer dll for c# : Add image to pdf file application Library utility html asp.net web page visual studio postgresql-9.4-A4101-part2726

Chapter 35. Extending SQL
Tip: If this is too complicated for you, you should consider using GNU Libtool1, which hides the
platform differences behind a uniform interface.
The resulting shared library file can then be loaded into PostgreSQL. When specifying the file name
to the
CREATE FUNCTION
command, one must give it the name of the shared library file, not the
intermediate object file. Note that the system’s standard shared-library extension (usually
.so
or
.sl
)can be omitted from the
CREATE FUNCTION
command, and normally should be omitted for
best portability.
Refer back to Section 35.9.1 about where the server expects to find the shared library files.
35.9.7. Composite-type Arguments
Composite types do not have a fixed layout like C structures. Instances of a composite type can
contain null fields. In addition, composite types that are part of an inheritance hierarchy can have
differentfields thanother members of thesameinheritance hierarchy. Therefore, PostgreSQL provides
afunction interface for accessing fields of composite types from C.
Suppose we want to write a function to answer the query:
SELECT name, c_overpaid(emp, 1500) AS overpaid
FROM emp
WHERE name = ’Bill’ OR name = ’Sam’;
Using call conventions version 0, we can define
c_overpaid
as:
#include "postgres.h"
#include "executor/executor.h"
/
*
for GetAttributeByName()
*
/
#ifdef PG_MODULE_MAGIC
PG_MODULE_MAGIC;
#endif
bool
c_overpaid(HeapTupleHeader t, /
*
the current row of emp
*
/
int32 limit)
{
bool isnull;
int32 salary;
salary = DatumGetInt32(GetAttributeByName(t, "salary", &isnull));
if (isnull)
return false;
return salary > limit;
}
In version-1 coding, the above wouldlook like this:
#include "postgres.h"
#include "executor/executor.h"
/
*
for GetAttributeByName()
*
/
#ifdef PG_MODULE_MAGIC
PG_MODULE_MAGIC;
1. http://www.gnu.org/software/libtool/
938
Add image to pdf file - 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 a picture to a pdf; attach image to pdf form
Add image to pdf file - 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 image to pdf acrobat reader; add photo to pdf file
Chapter 35. Extending SQL
#endif
PG_FUNCTION_INFO_V1(c_overpaid);
Datum
c_overpaid(PG_FUNCTION_ARGS)
{
HeapTupleHeader
t = PG_GETARG_HEAPTUPLEHEADER(0);
int32
limit = PG_GETARG_INT32(1);
bool isnull;
Datum salary;
salary = GetAttributeByName(t, "salary", &isnull);
if (isnull)
PG_RETURN_BOOL(false);
/
*
Alternatively, we might prefer to do PG_RETURN_NULL() for null salary.
*
/
PG_RETURN_BOOL(DatumGetInt32(salary) > limit);
}
GetAttributeByName
is the PostgreSQL system function that returns attributes out of the spec-
ified row. It has three arguments: the argument of type
HeapTupleHeader
passed into the func-
tion, the name of the desired attribute, and a return parameter that tells whether the attribute is null.
GetAttributeByName
returns a
Datum
value that you can convert to the proper data type by using
the appropriate
DatumGet
XXX
()
macro. Note that the return value is meaningless if the null flag is
set; always check the null flag before trying to do anything with the result.
There is also
GetAttributeByNum
,which selects the target attribute by column number instead of
name.
The following command declares the function
c_overpaid
in SQL:
CREATE FUNCTION c_overpaid(emp, integer) RETURNS boolean
AS ’
DIRECTORY
/funcs’, ’c_overpaid’
LANGUAGE C STRICT;
Notice we have used
STRICT
so that we did not have to check whether the input arguments were
NULL.
35.9.8. Returning Rows (Composite Types)
To return a row or composite-type value from a C-language function, you can use a special API that
provides macros and functions to hide most of the complexity of building composite data types. To
use this API, the source file must include:
#include "funcapi.h"
There are two ways you can build a composite data value (henceforth a “tuple”): you can build it
from an array of Datum values, or from an array of C strings that can be passed to the input con-
version functions of the tuple’s column data types. In either case, you first need to obtain or con-
struct a
TupleDesc
descriptor for the tuple structure. When working with Datums, you pass the
939
VB.NET PDF Password Library: add, remove, edit PDF file password
This VB.NET example shows how to add PDF file password with access permission setting. passwordSetting.IsAssemble = True ' Add password to PDF file.
add picture to pdf reader; add jpg to pdf online
C# PDF Password Library: add, remove, edit PDF file password in C#
This example shows how to add PDF file password with access permission setting. passwordSetting.IsAssemble = true; // Add password to PDF file.
attach image to pdf form; add image to pdf java
Chapter 35. Extending SQL
TupleDesc
to
BlessTupleDesc
, and then call
heap_form_tuple
for each row. When work-
ing with C strings, you pass the
TupleDesc
to
TupleDescGetAttInMetadata
, and then call
BuildTupleFromCStrings
for each row. In the case of a function returning a set of tuples, the
setup steps can all be done once during the first call of the function.
Several helper functions are available for setting up the needed
TupleDesc
.The recommended way
to do this in most functions returning composite values is tocall:
TypeFuncClass get_call_result_type(FunctionCallInfo fcinfo,
Oid
*
resultTypeId,
TupleDesc
*
resultTupleDesc)
passing the same
fcinfo
struct passed to the calling function itself. (This of course requires that
you use the version-1 calling conventions.)
resultTypeId
can be specified as
NULL
or as the ad-
dress of a local variable to receive the function’s result type OID.
resultTupleDesc
should be
the address of a local
TupleDesc
variable. Check that the result is
TYPEFUNC_COMPOSITE
;if so,
resultTupleDesc
has been filled with the needed
TupleDesc
.(If it is not, you can report an error
along the lines of “function returning record called in context that cannot accept type record”.)
Tip:
get_call_result_type
can resolve the actual type of a polymorphic function result; so it is
useful in functions that return scalar polymorphic results, not only functions that return compos-
ites. The
resultTypeId
output is primarily useful for functions returning polymorphic scalars.
Note:
get_call_result_type
has a sibling
get_expr_result_type
, which can be used to
resolve the expected output type for a function call represented by an expression tree. This
can be used when trying to determine the result type from outside the function itself. There is
also
get_func_result_type
, which can be used when only the function’s OID is available.
However these functions are not able to deal with functions declared to return
record
, and
get_func_result_type
cannot resolve polymorphic types, so you should preferentially use
get_call_result_type
.
Older, now-deprecated functions for obtaining
TupleDesc
sare:
TupleDesc RelationNameGetTupleDesc(const char
*
relname)
to get a
TupleDesc
for the row type of a named relation, and:
TupleDesc TypeGetTupleDesc(Oid typeoid, List
*
colaliases)
to get a
TupleDesc
based on a type OID. This can be used to get a
TupleDesc
for a base or com-
posite type. It will not work for a function that returns
record
,however, and it cannot resolve poly-
morphic types.
Once you have a
TupleDesc
,call:
TupleDesc BlessTupleDesc(TupleDesc tupdesc)
if you plan to work with Datums, or:
AttInMetadata
*
TupleDescGetAttInMetadata(TupleDesc tupdesc)
if you plan towork withC strings. If youare writinga function returning set, you can save the results
of these functions in the
FuncCallContext
structure — use the
tuple_desc
or
attinmeta
field
respectively.
940
C# PDF File & Page Process Library SDK for C#.net, ASP.NET, MVC
C# File: Split PDF; C# Page: Insert PDF pages; C# Page: Delete PDF pages; C# Read: PDF Image Extract; C# Write: Insert text into PDF; C# Write: Add Image to PDF;
add jpg to pdf file; add jpeg signature to pdf
VB.NET PDF File Compress Library: Compress reduce PDF size in vb.
Reduce image resources: Since images are usually or large size, images size reducing can help to reduce PDF file size effectively.
how to add a jpg to a pdf; add a jpg to a pdf
Chapter 35. Extending SQL
When working with Datums, use:
HeapTuple heap_form_tuple(TupleDesc tupdesc, Datum
*
values, bool
*
isnull)
to build a
HeapTuple
given user data in Datum form.
When working with C strings, use:
HeapTuple BuildTupleFromCStrings(AttInMetadata
*
attinmeta, char
**
values)
to build a
HeapTuple
given user data in C string form.
values
is an array of C strings, one for each
attribute of the return row. Each C string should be in the form expected by the input function of the
attribute data type. In order to return a null value for one of the attributes, the corresponding pointer
in the
values
array should be set to
NULL
.This function will need to be called again for each row
you return.
Once you have built a tuple to return from your function, it must be converted into a
Datum
.Use:
HeapTupleGetDatum(HeapTuple tuple)
to convert a
HeapTuple
into a valid Datum. This
Datum
can be returned directly if you intend to
return just a single row, or it can be used as the current return value in a set-returningfunction.
An example appears in the next section.
35.9.9. Returning Sets
There is also a special API thatprovides support for returning sets (multiple rows) from a C-language
function. A set-returning function must follow the version-1 calling conventions. Also, source files
must include
funcapi.h
,as above.
A set-returning function (SRF) is called once for each item it returns. The SRF must therefore
save enough state to remember what it was doing and return the next item on each call. The
structure
FuncCallContext
is provided to help control this process. Within a function,
fcinfo->flinfo->fn_extra
is usedto hold a pointer to
FuncCallContext
across calls.
typedef struct
{
/
*
*
Number of times we’ve been called before
*
*
call_cntr is initialized to 0 for you by SRF_FIRSTCALL_INIT(), and
*
incremented for you every time SRF_RETURN_NEXT() is called.
*
/
uint32 call_cntr;
/
*
*
OPTIONAL maximum number of calls
*
*
max_calls is here for convenience only and setting it is optional.
*
If not set, you must provide alternative means to know when the
*
function is done.
*
/
uint32 max_calls;
/
*
*
OPTIONAL pointer to result slot
941
VB.NET PDF File Merge Library: Merge, append PDF files in vb.net
RasterEdge .NET Image SDK has included a variety of image and document Add necessary references In addition, VB.NET users can append a PDF file to the end of a
how to add image to pdf; add image to pdf
C# PDF File Compress Library: Compress reduce PDF size in C#.net
Convert smooth lines to curves. Detect and merge image fragments. Flatten visible layers. C#.NET DLLs: Compress PDF Document. Add necessary references:
add photo pdf; how to add a jpeg to a pdf
Chapter 35. Extending SQL
*
*
This is obsolete and only present for backward compatibility, viz,
*
user-defined SRFs that use the deprecated TupleDescGetSlot().
*
/
TupleTableSlot
*
slot;
/
*
*
OPTIONAL pointer to miscellaneous user-provided context information
*
*
user_fctx is for use as a pointer to your own data to retain
*
arbitrary context information between calls of your function.
*
/
void
*
user_fctx;
/
*
*
OPTIONAL pointer to struct containing attribute type input metadata
*
*
attinmeta is for use when returning tuples (i.e., composite data types)
*
and is not used when returning base data types. It is only needed
*
if you intend to use BuildTupleFromCStrings() to create the return
*
tuple.
*
/
AttInMetadata
*
attinmeta;
/
*
*
memory context used for structures that must live for multiple calls
*
*
multi_call_memory_ctx is set by SRF_FIRSTCALL_INIT() for you, and used
*
by SRF_RETURN_DONE() for cleanup. It is the most appropriate memory
*
context for any memory that is to be reused across multiple calls
*
of the SRF.
*
/
MemoryContext multi_call_memory_ctx;
/
*
*
OPTIONAL pointer to struct containing tuple description
*
*
tuple_desc is for use when returning tuples (i.e., composite data types)
*
and is only needed if you are going to build the tuples with
*
heap_form_tuple() rather than with BuildTupleFromCStrings().
Note that
*
the TupleDesc pointer stored here should usually have been run through
*
BlessTupleDesc() first.
*
/
TupleDesc tuple_desc;
} FuncCallContext;
An SRF uses several functions and macros that automatically manipulate the
FuncCallContext
structure (and expect to find it via
fn_extra
). Use:
SRF_IS_FIRSTCALL()
to determine if your function is being called for the first or a subsequent time. On the first call (only)
use:
SRF_FIRSTCALL_INIT()
942
C# PDF File Merge Library: Merge, append PDF files in C#.net, ASP.
PDF document splitting, PDF page reordering and PDF page image and text Add necessary references: In addition, C# users can append a PDF file to the end of a
add photo to pdf for; adding a jpeg to a pdf
VB.NET PDF File Split Library: Split, seperate PDF into multiple
1). ' Create output PDF file path list Dim outputFilePaths As New List(Of String) Dim i As Integer For i = 0 To splitIndex.Length outputFilePaths.Add(Program
add a picture to a pdf; add jpg signature to pdf
Chapter 35. Extending SQL
to initialize the
FuncCallContext
.On every function call, including the first, use:
SRF_PERCALL_SETUP()
to properly set up for using the
FuncCallContext
and clearing any previously returned data left
over from the previous pass.
If your function has data to return, use:
SRF_RETURN_NEXT(funcctx, result)
to return it to the caller. (
result
must be of type
Datum
,either a single value or a tuple prepared as
described above.) Finally, when your function is finished returning data, use:
SRF_RETURN_DONE(funcctx)
to clean up and end the SRF.
The memorycontextthatis currentwhentheSRF is calledisa transientcontextthatwillbeclearedbe-
tween calls. Thismeans that youdonot needtocall
pfree
on everything youallocatedusing
palloc
;
it will go away anyway. However, if you want to allocate any data structures to live across calls, you
need toput them somewhere else. The memory context referenced by
multi_call_memory_ctx
is
asuitable location for any data that needs to survive until the SRF is finished running. In most cases,
this means that you should switch into
multi_call_memory_ctx
while doing the first-call setup.
Acomplete pseudo-code example looks like the following:
Datum
my_set_returning_function(PG_FUNCTION_ARGS)
{
FuncCallContext
*
funcctx;
Datum
result;
further declarations as needed
if (SRF_IS_FIRSTCALL())
{
MemoryContext oldcontext;
funcctx = SRF_FIRSTCALL_INIT();
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
/
*
One-time setup code appears here:
*
/
user code
if returning composite
build TupleDesc, and perhaps AttInMetadata
endif returning composite
user code
MemoryContextSwitchTo(oldcontext);
}
/
*
Each-time setup code appears here:
*
/
user code
funcctx = SRF_PERCALL_SETUP();
user code
/
*
this is just one way we might test whether we are done:
*
/
if (funcctx->call_cntr < funcctx->max_calls)
{
/
*
Here we want to return another item:
*
/
user code
943
Chapter 35. Extending SQL
obtain result Datum
SRF_RETURN_NEXT(funcctx, result);
}
else
{
/
*
Here we are done returning items and just need to clean up:
*
/
user code
SRF_RETURN_DONE(funcctx);
}
}
Acomplete example of a simple SRF returning a composite type looks like:
PG_FUNCTION_INFO_V1(retcomposite);
Datum
retcomposite(PG_FUNCTION_ARGS)
{
FuncCallContext
*
funcctx;
int
call_cntr;
int
max_calls;
TupleDesc
tupdesc;
AttInMetadata
*
attinmeta;
/
*
stuff done only on the first call of the function
*
/
if (SRF_IS_FIRSTCALL())
{
MemoryContext
oldcontext;
/
*
create a function context for cross-call persistence
*
/
funcctx = SRF_FIRSTCALL_INIT();
/
*
switch to memory context appropriate for multiple function calls
*
/
oldcontext = MemoryContextSwitchTo(funcctx->multi_call_memory_ctx);
/
*
total number of tuples to be returned
*
/
funcctx->max_calls = PG_GETARG_UINT32(0);
/
*
Build a tuple descriptor for our result type
*
/
if (get_call_result_type(fcinfo, NULL, &tupdesc) != TYPEFUNC_COMPOSITE)
ereport(ERROR,
(errcode(ERRCODE_FEATURE_NOT_SUPPORTED),
errmsg("function returning record called in context "
"that cannot accept type record")));
/
*
*
generate attribute metadata needed later to produce tuples from raw
*
C strings
*
/
attinmeta = TupleDescGetAttInMetadata(tupdesc);
funcctx->attinmeta = attinmeta;
MemoryContextSwitchTo(oldcontext);
}
/
*
stuff done on every call of the function
*
/
944
Chapter 35. Extending SQL
funcctx = SRF_PERCALL_SETUP();
call_cntr = funcctx->call_cntr;
max_calls = funcctx->max_calls;
attinmeta = funcctx->attinmeta;
if (call_cntr < max_calls)
/
*
do when there is more left to send
*
/
{
char
**
values;
HeapTuple
tuple;
Datum
result;
/
*
*
Prepare a values array for building the returned tuple.
*
This should be an array of C strings which will
*
be processed later by the type input functions.
*
/
values = (char
**
) palloc(3
*
sizeof(char
*
));
values[0] = (char
*
) palloc(16
*
sizeof(char));
values[1] = (char
*
) palloc(16
*
sizeof(char));
values[2] = (char
*
) palloc(16
*
sizeof(char));
snprintf(values[0], 16, "%d", 1
*
PG_GETARG_INT32(1));
snprintf(values[1], 16, "%d", 2
*
PG_GETARG_INT32(1));
snprintf(values[2], 16, "%d", 3
*
PG_GETARG_INT32(1));
/
*
build a tuple
*
/
tuple = BuildTupleFromCStrings(attinmeta, values);
/
*
make the tuple into a datum
*
/
result = HeapTupleGetDatum(tuple);
/
*
clean up (this is not really necessary)
*
/
pfree(values[0]);
pfree(values[1]);
pfree(values[2]);
pfree(values);
SRF_RETURN_NEXT(funcctx, result);
}
else
/
*
do when there is no more left
*
/
{
SRF_RETURN_DONE(funcctx);
}
}
One way to declare this function in SQL is:
CREATE TYPE __retcomposite AS (f1 integer, f2 integer, f3 integer);
CREATE OR REPLACE FUNCTION retcomposite(integer, integer)
RETURNS SETOF __retcomposite
AS ’
filename
’, ’retcomposite’
LANGUAGE C IMMUTABLE STRICT;
Adifferent way is to use OUT parameters:
CREATE OR REPLACE FUNCTION retcomposite(IN integer, IN integer,
945
Chapter 35. Extending SQL
OUT f1 integer, OUT f2 integer, OUT f3 integer)
RETURNS SETOF record
AS ’
filename
’, ’retcomposite’
LANGUAGE C IMMUTABLE STRICT;
Notice that in this method the output type of the function is formally an anonymous
record
type.
The directory contrib/tablefunc module in the source distribution contains more examples of set-
returning functions.
35.9.10. Polymorphic Arguments and Return Types
C-language 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
explanation of polymorphic functions. When function arguments or return types are defined as
polymorphic types, the function author cannot know in advance what data type it will be called with,
or need to return. There are two routines provided in
fmgr.h
to allow a version-1 C function to
discover the actual data types of its arguments and the type it is expected to return. The routines are
called
get_fn_expr_rettype(FmgrInfo
*
flinfo)
and
get_fn_expr_argtype(FmgrInfo
*
flinfo, int argnum)
. They return the result or argument type OID, or
InvalidOid
if the
information is not available. The structure
flinfo
is normally accessed as
fcinfo->flinfo
.The
parameter
argnum
is zero based.
get_call_result_type
can also be used as an alternative to
get_fn_expr_rettype
.There is also
get_fn_expr_variadic
,which can be used to find out
whether variadic arguments have been merged into an array. This is primarily useful for
VARIADIC
"any"
functions, since such merging will always have occurred for variadic functions taking
ordinary array types.
For example, suppose we want to write a function to accept a single element of any type, and return a
one-dimensional array of that type:
PG_FUNCTION_INFO_V1(make_array);
Datum
make_array(PG_FUNCTION_ARGS)
{
ArrayType
*
result;
Oid
element_type = get_fn_expr_argtype(fcinfo->flinfo, 0);
Datum
element;
bool
isnull;
int16
typlen;
bool
typbyval;
char
typalign;
int
ndims;
int
dims[MAXDIM];
int
lbs[MAXDIM];
if (!OidIsValid(element_type))
elog(ERROR, "could not determine data type of input");
/
*
get the provided element, being careful in case it’s NULL
*
/
isnull = PG_ARGISNULL(0);
if (isnull)
element = (Datum) 0;
else
element = PG_GETARG_DATUM(0);
946
Chapter 35. Extending SQL
/
*
we have one dimension
*
/
ndims = 1;
/
*
and one element
*
/
dims[0] = 1;
/
*
and lower bound is 1
*
/
lbs[0] = 1;
/
*
get required info about the element type
*
/
get_typlenbyvalalign(element_type, &typlen, &typbyval, &typalign);
/
*
now build the array
*
/
result = construct_md_array(&element, &isnull, ndims, dims, lbs,
element_type, typlen, typbyval, typalign);
PG_RETURN_ARRAYTYPE_P(result);
}
The following command declares the function
make_array
in SQL:
CREATE FUNCTION make_array(anyelement) RETURNS anyarray
AS ’
DIRECTORY
/funcs’, ’make_array’
LANGUAGE C IMMUTABLE;
There isa variantof polymorphism thatis onlyavailabletoC-language functions: theycanbedeclared
to take parameters of type
"any"
.(Note that this type name must be double-quoted, since it’s also a
SQL reserved word.) This works like
anyelement
except that it does not constrain different
"any"
arguments to be the same type, nor do they help determine the function’s result type. A C-language
function can alsodeclare its final parameter to be
VARIADIC "any"
.This willmatch one or more ac-
tualarguments of any type (notnecessarilythe same type). These arguments will not be gatheredinto
an arrayas happens withnormal variadic functions; they willjustbe passedtothe function separately.
The
PG_NARGS()
macro and the methods described above must be used to determine the number of
actual arguments and their types when using this feature. Also, users of such a functionmight wish to
use the
VARIADIC
keyword in their function call, with the expectation that the function would treat
the array elements as separate arguments. The function itself mustimplementthatbehavior if wanted,
after using
get_fn_expr_variadic
to detectthattheactual argument was marked with
VARIADIC
.
35.9.11. Transform Functions
Some function calls can be simplified during planning based on properties specific to the function.
For example,
int4mul(n, 1)
could be simplified to just
n
. To define such function-specific
optimizations, write a transform function and place its OID in the
protransform
field of
the primary function’s
pg_proc
entry. The transform function must have the SQL signature
protransform(internal) RETURNS internal
. The argument, actually
FuncExpr
*
, is a
dummy node representing a call to the primary function. If the transform function’s study of the
expression tree proves that a simplified expression tree can substitute for all possible concrete calls
represented thereby, build and return that simplified expression. Otherwise, return a
NULL
pointer
(not a SQL null).
Wemake no guarantee thatPostgreSQL willnever callthe primaryfunctionincases that thetransform
function couldsimplify. Ensure rigorous equivalence between the simplified expressionand anactual
call to the primaryfunction.
947
Documents you may be interested
Documents you may be interested