pdf viewer dll for c# : Adding an image to a pdf in preview application Library utility azure asp.net .net visual studio postgresql-9.4-A4100-part2725

Chapter 35. Extending SQL
35.9.2. Base Types in C-Language Functions
To knowhow to writeC-language functions, youneedto know howPostgreSQL internallyrepresents
base data types and how they can be passed to and from functions. Internally, PostgreSQL regards a
base type as a “blobof memory”. The user-defined functions thatyoudefine over a type inturn define
the way that PostgreSQL can operate on it. That is, PostgreSQL will only store and retrieve the data
from disk and use your user-defined functions to input, process, and output the data.
Base types can have one of three internal formats:
pass byvalue, fixed-length
pass byreference, fixed-length
pass byreference, variable-length
By-value types can only be 1, 2, or 4 bytes in length (also 8 bytes, if
sizeof(Datum)
is 8 on your
machine). You should becarefulto define your types such that theywill bethe same size (inbytes) on
all architectures. For example, the
long
type is dangerous because itis 4 bytes on some machines and
8bytes on others, whereas
int
type is 4 bytes on most Unix machines. A reasonable implementation
of the
int4
type on Unix machines might be:
/
*
4-byte integer, passed by value
*
/
typedef int int4;
(The actual PostgreSQL C code calls this type
int32
,because it is a convention in C that
int
XX
means
XX
bits. Note therefore also that the C type
int8
is 1 byte in size. The SQL type
int8
is called
int64
in C. See also Table 35-1.)
On the other hand, fixed-length types of any size can be passed by-reference. For example, here is a
sample implementation of a PostgreSQL type:
/
*
16-byte structure, passed by reference
*
/
typedef struct
{
double
x, y;
} Point;
Only pointers to such types can be used when passing them in and out of PostgreSQL functions. To
return a value of such a type, allocate the right amount of memory with
palloc
,fill in the allocated
memory, andreturn a pointer toit. (Also, if youjustwant toreturn the same value as one of your input
arguments that’s of the same data type, you can skip the extra
palloc
and just return the pointer to
the input value.)
Finally, all variable-length types must also be passed by reference. All variable-length types must
begin with an opaque length field of exactly 4 bytes, which will be set by
SET_VARSIZE
;never set
this field directly! All data to be stored within that type must be located in the memory immediately
following thatlengthfield. The length fieldcontains the total lengthof the structure, that is, it includes
the size of the length field itself.
Another importantpointis toavoid leavinganyuninitializedbits withindata type values; for example,
take care to zero out any alignment padding bytes that might be present in structs. Without this,
logically-equivalent constants of your data type might be seen as unequal by the planner, leading to
inefficient (though not incorrect) plans.
928
Adding an image to a pdf in preview - 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 photo pdf; add photo to pdf online
Adding an image to a pdf in preview - 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 in preview; how to add image to pdf
Chapter 35. Extending SQL
Warning
Never modify the contents of a pass-by-reference input value. If you do so you
are likely to corrupt on-disk data, since the pointer you are given might point
directly intoa disk buffer. The sole exception to this rule is explained inSection
35.10.
As an example, we can define the type
text
as follows:
typedef struct {
int32 length;
char data[1];
} text;
Obviously, the data field declared here is not long enough to hold all possible strings. Since it’s
impossible to declare a variable-size structure in C, we rely on the knowledge that the C compiler
won’t range-check array subscripts. We just allocate the necessary amount of space and then access
the array as if it were declared the right length. (This is a common trick, which you can read about in
many textbooks about C.)
When manipulating variable-length types, we must be careful to allocate the correct amount of mem-
ory and set the length field correctly. For example, if we wantedto store 40 bytes in a
text
structure,
we might use a code fragment like this:
#include "postgres.h"
...
char buffer[40]; /
*
our source data
*
/
...
text
*
destination = (text
*
) palloc(VARHDRSZ + 40);
SET_VARSIZE(destination, VARHDRSZ + 40);
memcpy(destination->data, buffer, 40);
...
VARHDRSZ
is the sameas
sizeof(int32)
,but it’s consideredgoodstyletouse the macro
VARHDRSZ
to refer to the size of the overhead for a variable-length type. Also, the length field must be set using
the
SET_VARSIZE
macro, not by simple assignment.
Table35-1specifieswhichC typecorresponds towhichSQL typewhen writing aC-language function
that uses a built-in type of PostgreSQL. The “Defined In” column gives the header file that needs to
be included to get the type definition. (The actual definition might be in adifferent file that is included
by the listed file. It is recommended that users stick to the defined interface.) Note that you should
always include
postgres.h
first in any source file, because it declares a number of things that you
will need anyway.
Table 35-1. Equivalent C Types for Built-in SQL Types
SQL Type
CType
Defined In
abstime
AbsoluteTime
utils/nabstime.h
boolean
bool
postgres.h
(maybe compiler
built-in)
box
BOX
*
utils/geo_decls.h
bytea
bytea
*
postgres.h
"char"
char
(compiler built-in)
929
C# PDF Page Insert Library: insert pages into PDF file in C#.net
applications. Support adding and inserting one or multiple pages to existing PDF document. Forms. Ability to add PDF page number in preview. Offer
add an image to a pdf in preview; adding an image to a pdf form
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.
how to add picture to pdf; add an image to a pdf form
Chapter 35. Extending SQL
SQL Type
CType
Defined In
character
BpChar
*
postgres.h
cid
CommandId
postgres.h
date
DateADT
utils/date.h
smallint
(
int2
)
int16
postgres.h
int2vector
int2vector
*
postgres.h
integer
(
int4
)
int32
postgres.h
real
(
float4
)
float4
*
postgres.h
double precision
(
float8
)
float8
*
postgres.h
interval
Interval
*
datatype/timestamp.h
lseg
LSEG
*
utils/geo_decls.h
name
Name
postgres.h
oid
Oid
postgres.h
oidvector
oidvector
*
postgres.h
path
PATH
*
utils/geo_decls.h
point
POINT
*
utils/geo_decls.h
regproc
regproc
postgres.h
reltime
RelativeTime
utils/nabstime.h
text
text
*
postgres.h
tid
ItemPointer
storage/itemptr.h
time
TimeADT
utils/date.h
time with time zone
TimeTzADT
utils/date.h
timestamp
Timestamp
*
datatype/timestamp.h
tinterval
TimeInterval
utils/nabstime.h
varchar
VarChar
*
postgres.h
xid
TransactionId
postgres.h
Now that we’ve gone over all of the possible structures for base types, we can show some examples
of real functions.
35.9.3. Version 0 Calling Conventions
We present the “old style” calling convention first — although this approach is now deprecated, it’s
easier to get a handle on initially. In the version-0 method, the arguments and result of the C function
are just declared in normal C style, but being careful to use the C representation of each SQL data
type as shown above.
Here are some examples:
#include "postgres.h"
#include <string.h>
#include "utils/geo_decls.h"
#ifdef PG_MODULE_MAGIC
PG_MODULE_MAGIC;
#endif
930
VB.NET PDF insert text library: insert text into PDF content in vb
Multifunctional Visual Studio .NET PDF SDK library supports adding text content to adobe PDF document in VB.NET Add text to PDF in preview without adobe
add picture to pdf in preview; add jpg to pdf
C# Create PDF Library SDK to convert PDF from other file formats
Load PDF from existing documents and image in SQL server. Besides, using this PDF document metadata adding control, you can add some additional
add picture to pdf form; add jpg signature to pdf
Chapter 35. Extending SQL
/
*
by value
*
/
int
add_one(int arg)
{
return arg + 1;
}
/
*
by reference, fixed length
*
/
float8
*
add_one_float8(float8
*
arg)
{
float8
*
result = (float8
*
) palloc(sizeof(float8));
*
result =
*
arg + 1.0;
return result;
}
Point
*
makepoint(Point
*
pointx, Point
*
pointy)
{
Point
*
new_point = (Point
*
) palloc(sizeof(Point));
new_point->x = pointx->x;
new_point->y = pointy->y;
return new_point;
}
/
*
by reference, variable length
*
/
text
*
copytext(text
*
t)
{
/
*
*
VARSIZE is the total size of the struct in bytes.
*
/
text
*
new_t = (text
*
) palloc(VARSIZE(t));
SET_VARSIZE(new_t, VARSIZE(t));
/
*
*
VARDATA is a pointer to the data region of the struct.
*
/
memcpy((void
*
) VARDATA(new_t), /
*
destination
*
/
(void
*
) VARDATA(t),
/
*
source
*
/
VARSIZE(t) - VARHDRSZ);
/
*
how many bytes
*
/
return new_t;
}
text
*
concat_text(text
*
arg1, text
*
arg2)
{
int32 new_text_size = VARSIZE(arg1) + VARSIZE(arg2) - VARHDRSZ;
text
*
new_text = (text
*
) palloc(new_text_size);
931
C# Word - Insert Image to Word Page in C#.NET
Preview Document. Conversion. Convert Word to PDF. Convert Word to HTML5. VB.NET How-to, VB.NET PDF, VB.NET Word It's a demo code for adding image to word page using
add jpg to pdf preview; how to add image to pdf reader
C# PowerPoint - Insert Image to PowerPoint File Page in C#.NET
Preview Document. Conversion. Convert PowerPoint to PDF. Convert PowerPoint to Pages. Annotate PowerPoint. Text Search. Insert Image. Thumbnail Create.
add image to pdf file; adding an image to a pdf in acrobat
Chapter 35. Extending SQL
SET_VARSIZE(new_text, new_text_size);
memcpy(VARDATA(new_text), VARDATA(arg1), VARSIZE(arg1) - VARHDRSZ);
memcpy(VARDATA(new_text) + (VARSIZE(arg1) - VARHDRSZ),
VARDATA(arg2), VARSIZE(arg2) - VARHDRSZ);
return new_text;
}
Supposing that the above code has been prepared in file
funcs.c
and compiled into a shared object,
we could define the functions to PostgreSQL with commands like this:
CREATE FUNCTION add_one(integer) RETURNS integer
AS ’
DIRECTORY
/funcs’, ’add_one’
LANGUAGE C STRICT;
-- note overloading of SQL function name "add_one"
CREATE FUNCTION add_one(double precision) RETURNS double precision
AS ’
DIRECTORY
/funcs’, ’add_one_float8’
LANGUAGE C STRICT;
CREATE FUNCTION makepoint(point, point) RETURNS point
AS ’
DIRECTORY
/funcs’, ’makepoint’
LANGUAGE C STRICT;
CREATE FUNCTION copytext(text) RETURNS text
AS ’
DIRECTORY
/funcs’, ’copytext’
LANGUAGE C STRICT;
CREATE FUNCTION concat_text(text, text) RETURNS text
AS ’
DIRECTORY
/funcs’, ’concat_text’
LANGUAGE C STRICT;
Here,
DIRECTORY
stands for the directory of the shared library file (for instance the PostgreSQL
tutorial directory, which contains the code for the examples used in this section). (Better style would
be to use just
’funcs’
in the
AS
clause, after having added
DIRECTORY
to the search path. In any
case, we canomit the system-specific extension for a shared library, commonly
.so
or
.sl
.)
Notice that we have specified the functions as “strict”, meaning that the system should automatically
assume a null result if any input value is null. By doing this, we avoid having to check for null inputs
in the function code. Without this, we’d have to check for null values explicitly, by checking for a
null pointer for each pass-by-reference argument. (For pass-by-value arguments, we don’t even have
away to check!)
Although this calling convention is simple to use, it is not very portable; on some architectures there
are problems withpassing data types that are smaller than
int
this way. Also, there is nosimple way
to return a null result, nor to cope with null arguments in any way other than making the function
strict. The version-1 convention, presented next, overcomes these objections.
35.9.4. Version 1 Calling Conventions
The version-1 calling convention relies on macros to suppress most of the complexity of passing
arguments and results. The C declaration of a version-1 function is always:
Datum funcname(PG_FUNCTION_ARGS)
932
C# TIFF: TIFF Editor SDK to Read & Manipulate TIFF File Using C#.
Easy to generate image thumbnail or preview for Tiff to Tiff, like Word, Excel, PowerPoint, PDF, and images. assemblies into your C# project by adding reference
adding image to pdf in preview; adding images to a pdf document
VB.NET PDF copy, paste image library: copy, paste, cut PDF images
Free Visual Studio .NET PDF library, easy to be integrated in .NET WinForms and ASP.NET. Besides image extracting, adding, and removing, RasterEdge
add a jpeg to a pdf; pdf insert image
Chapter 35. Extending SQL
In addition, the macro call:
PG_FUNCTION_INFO_V1(funcname);
must appear in the same source file. (Conventionally, it’s written just before the function itself.) This
macro call is not needed for
internal
-language functions, since PostgreSQL assumes that all inter-
nal functions use the version-1 convention. It is, however, required for dynamically-loaded functions.
In a version-1 function, each actual argument is fetched using a
PG_GETARG_
xxx
()
macro that cor-
responds to the argument’s data type, and the result is returned using a
PG_RETURN_
xxx
()
macro
for the return type.
PG_GETARG_
xxx
()
takes as its argument the number of the function argument to
fetch, where the count starts at0.
PG_RETURN_
xxx
()
takes as its argumentthe actual value to return.
Here we show the same functions as above, coded in version-1 style:
#include "postgres.h"
#include <string.h>
#include "fmgr.h"
#include "utils/geo_decls.h"
#ifdef PG_MODULE_MAGIC
PG_MODULE_MAGIC;
#endif
/
*
by value
*
/
PG_FUNCTION_INFO_V1(add_one);
Datum
add_one(PG_FUNCTION_ARGS)
{
int32
arg = PG_GETARG_INT32(0);
PG_RETURN_INT32(arg + 1);
}
/
*
by reference, fixed length
*
/
PG_FUNCTION_INFO_V1(add_one_float8);
Datum
add_one_float8(PG_FUNCTION_ARGS)
{
/
*
The macros for FLOAT8 hide its pass-by-reference nature.
*
/
float8
arg = PG_GETARG_FLOAT8(0);
PG_RETURN_FLOAT8(arg + 1.0);
}
PG_FUNCTION_INFO_V1(makepoint);
Datum
makepoint(PG_FUNCTION_ARGS)
{
/
*
Here, the pass-by-reference nature of Point is not hidden.
*
/
Point
*
pointx = PG_GETARG_POINT_P(0);
Point
*
pointy = PG_GETARG_POINT_P(1);
Point
*
new_point = (Point
*
) palloc(sizeof(Point));
933
Chapter 35. Extending SQL
new_point->x = pointx->x;
new_point->y = pointy->y;
PG_RETURN_POINT_P(new_point);
}
/
*
by reference, variable length
*
/
PG_FUNCTION_INFO_V1(copytext);
Datum
copytext(PG_FUNCTION_ARGS)
{
text
*
t = PG_GETARG_TEXT_P(0);
/
*
*
VARSIZE is the total size of the struct in bytes.
*
/
text
*
new_t = (text
*
) palloc(VARSIZE(t));
SET_VARSIZE(new_t, VARSIZE(t));
/
*
*
VARDATA is a pointer to the data region of the struct.
*
/
memcpy((void
*
) VARDATA(new_t), /
*
destination
*
/
(void
*
) VARDATA(t),
/
*
source
*
/
VARSIZE(t) - VARHDRSZ);
/
*
how many bytes
*
/
PG_RETURN_TEXT_P(new_t);
}
PG_FUNCTION_INFO_V1(concat_text);
Datum
concat_text(PG_FUNCTION_ARGS)
{
text
*
arg1 = PG_GETARG_TEXT_P(0);
text
*
arg2 = PG_GETARG_TEXT_P(1);
int32 new_text_size = VARSIZE(arg1) + VARSIZE(arg2) - VARHDRSZ;
text
*
new_text = (text
*
) palloc(new_text_size);
SET_VARSIZE(new_text, new_text_size);
memcpy(VARDATA(new_text), VARDATA(arg1), VARSIZE(arg1) - VARHDRSZ);
memcpy(VARDATA(new_text) + (VARSIZE(arg1) - VARHDRSZ),
VARDATA(arg2), VARSIZE(arg2) - VARHDRSZ);
PG_RETURN_TEXT_P(new_text);
}
The
CREATE FUNCTION
commands are the same as for the version-0 equivalents.
At firstglance, the version-1codingconventions might appear tobe just pointless obscurantism. They
do, however, offer a number of improvements, because the macros can hide unnecessary detail. An
example is that in coding
add_one_float8
,we no longer need to be aware that
float8
is a pass-
by-reference type. Another example is that the
GETARG
macros for variable-length types allow for
more efficient fetching of “toasted” (compressed or out-of-line) values.
One big improvement in version-1 functions is better handling of null inputs and results. The macro
PG_ARGISNULL(
n
)
allows a function to test whether each input is null. (Of course, doing this is
934
Chapter 35. Extending SQL
only necessary in functions not declared “strict”.) As with the
PG_GETARG_
xxx
()
macros, the
input arguments are counted beginning at zero. Note that one should refrain from executing
PG_GETARG_
xxx
()
until one has verified that the argument isn’t null. To return a null result, execute
PG_RETURN_NULL()
;this works in both strict and nonstrict functions.
Other options provided in the new-style interface are two variants of the
PG_GETARG_
xxx
()
macros.
The first of these,
PG_GETARG_
xxx
_COPY()
,guarantees to return a copy of the specified argument
that is safe for writing into. (The normal macros will sometimes return a pointer to a value that
is physically stored in a table, which must not be written to. Using the
PG_GETARG_
xxx
_COPY()
macros guarantees a writable result.) The second variant consists of the
PG_GETARG_
xxx
_SLICE()
macros which take three arguments. The first is the number of the function argument (as above). The
second and third are the offset and length of the segment to be returned. Offsets are counted from
zero, and a negative length requests thatthe remainder of the value be returned. Thesemacros provide
more efficient access to parts of large values in the case where they have storage type “external”.
(The storage type of a column can be specified using
ALTER TABLE
tablename
ALTER COLUMN
colname
SET STORAGE
storagetype
.
storagetype
is one of
plain
,
external
,
extended
,or
main
.)
Finally, the version-1 function call conventions make it possible to return set results (Section 35.9.9)
and implement trigger functions (Chapter 36) and procedural-language call handlers (Chapter 52).
Version-1 code is alsomore portable than version-0, because it does not break restrictions on function
call protocol in the C standard. For more details see
src/backend/utils/fmgr/README
in the
source distribution.
35.9.5. Writing Code
Before we turn to the more advanced topics, we should discuss some coding rules for PostgreSQL
C-language functions. While it might be possible to load functions written in languages other than
Cinto PostgreSQL, this is usually difficult (when it is possible at all) because other languages, such
as C++, FORTRAN, or Pascal often do not follow the same calling convention as C. That is, other
languages do not pass argumentand returnvalues between functions in the same way. For this reason,
we will assume that your C-language functions are actually written in C.
The basic rules for writing and buildingC functions are as follows:
Use
pg_config --includedir-server
to find out where the PostgreSQL server header files
are installed on your system (or the system that your users will be running on).
Compiling and linking your code so that it can be dynamically loaded into PostgreSQL always re-
quires special flags. See Section 35.9.6 for adetailed explanationof how todo itfor your particular
operating system.
Remember to define a “magic block” for your shared library, as described in Section35.9.1.
When allocating memory, use the PostgreSQL functions
palloc
and
pfree
instead of the corre-
sponding C library functions
malloc
and
free
.The memory allocated by
palloc
will be freed
automatically at the end of each transaction, preventing memory leaks.
Always zero the bytes of your structures using
memset
(or allocate them with
palloc0
in the first
place). Even if you assign to each field of your structure, there might be alignment padding (holes
in the structure) that contain garbage values. Without this, it’s difficult to support hash indexes or
hash joins, as you must pick out only the significant bits of your data structure to compute a hash.
The planner also sometimes relies on comparing constants via bitwise equality, so you can get
undesirable planning results if logically-equivalent values aren’t bitwise equal.
935
Chapter 35. Extending SQL
Most of the internal PostgreSQL types are declared in
postgres.h
,while the function manager
interfaces (
PG_FUNCTION_ARGS
,etc.) are in
fmgr.h
,soyouwill need toinclude at least these two
files. For portability reasons it’s best to include
postgres.h
first, before any other system or user
header files. Including
postgres.h
will also include
elog.h
and
palloc.h
for you.
Symbol names defined within object files must not conflictwith eachother or with symbols defined
in the PostgreSQL server executable. You will have to rename your functions or variables if you
get error messages to this effect.
35.9.6. Compiling and Linking Dynamically-loaded
Functions
Before you are able to use your PostgreSQL extension functions writtenin C, they must be compiled
and linked in a special way to produce a file that can be dynamically loaded by the server. To be
precise, a shared library needs to be created.
For information beyond what is contained in this section you should read the documentation of your
operating system, in particular the manual pages for the C compiler,
cc
,and the link editor,
ld
.In
addition, the PostgreSQL source code contains several working examples in the
contrib
directory.
If you rely on these examples you will make your modules dependent on the availability of the Post-
greSQL source code, however.
Creating shared libraries is generally analogous to linking executables: first the source files are com-
piled into object files, then the object files are linked together. The object files need to be created as
position-independent code (PIC), which conceptually means that they can be placed at an arbitrary
location in memory when they are loaded by the executable. (Object files intended for executables
are usually not compiled that way.) The command to link a shared library contains special flags to
distinguish it from linking an executable (at least in theory — on some systems the practice is much
uglier).
In the following examples we assume that your source code is in a file
foo.c
and we will create a
shared library
foo.so
.The intermediate object file will be called
foo.o
unless otherwise noted. A
shared library can contain more than one object file, but we only use one here.
FreeBSD
Thecompiler flagtocreate PIC is
-fpic
.Tocreate sharedlibraries the compiler flagis
-shared
.
gcc -fpic -c foo.c
gcc -shared -o foo.so foo.o
This is applicable as of version 3.0 of FreeBSD.
HP-UX
The compiler flag of the system compiler to create PIC is
+z
.When using GCC it’s
-fpic
.The
linker flag for shared libraries is
-b
.So:
cc +z -c foo.c
or:
gcc -fpic -c foo.c
andthen:
ld -b -o foo.sl foo.o
HP-UX uses the extension
.sl
for shared libraries, unlike most other systems.
936
Chapter 35. Extending SQL
Linux
The compiler flagto create PIC is
-fpic
.On some platforms in some situations
-fPIC
must be
usedif
-fpic
does not work. Refer to the GCC manual for more information. The compiler flag
to create a shared library is
-shared
.A complete example looks like this:
cc -fpic -c foo.c
cc -shared -o foo.so foo.o
OS X
Here is an example. It assumes the developer tools are installed.
cc -c foo.c
cc -bundle -flat_namespace -undefined suppress -o foo.so foo.o
NetBSD
The compiler flag to create PIC is
-fpic
.For ELF systems, the compiler withthe flag
-shared
is used tolinkshared libraries. On the older non-ELF systems,
ld -Bshareable
is used.
gcc -fpic -c foo.c
gcc -shared -o foo.so foo.o
OpenBSD
The compiler flag to create PIC is
-fpic
.
ld -Bshareable
is used to link shared libraries.
gcc -fpic -c foo.c
ld -Bshareable -o foo.so foo.o
Solaris
The compiler flag to create PIC is
-KPIC
with the Sun compiler and
-fpic
with GCC. To link
shared libraries, the compiler option is
-G
with either compiler or alternatively
-shared
with
GCC.
cc -KPIC -c foo.c
cc -G -o foo.so foo.o
or
gcc -fpic -c foo.c
gcc -G -o foo.so foo.o
Tru64 UNIX
PIC is the default, so the compilation command is the usual one.
ld
with special options is used
to do the linking.
cc -c foo.c
ld -shared -expect_unresolved ’
*
’ -o foo.so foo.o
The same procedure is used with GCC instead of the system compiler; no special options are
required.
UnixWare
The compiler flag to create PIC is
-K PIC
with the SCO compiler and
-fpic
withGCC. Tolink
shared libraries, the compiler option is
-G
with the SCO compiler and
-shared
with GCC.
cc -K PIC -c foo.c
cc -G -o foo.so foo.o
or
gcc -fpic -c foo.c
gcc -shared -o foo.so foo.o
937
Documents you may be interested
Documents you may be interested