pdf viewer in asp net c# : How to add image to pdf form SDK application API wpf html asp.net sharepoint postgresql-9.4-A480-part3006

Chapter 32. Large Objects
Oid lo_import_with_oid(PGconn
*
conn, const char
*
filename, Oid lobjId);
also imports a new large object. The OID to be assigned can be specified by
lobjId
;if so, failure
occurs if that OID is already in use for some large object. If
lobjId
is
InvalidOid
(zero) then
lo_import_with_oid
assigns an unusedOID (this is the same behavior as
lo_import
). Thereturn
value is the OID that was assigned to the new large object, or
InvalidOid
(zero) on failure.
lo_import_with_oid
is new as of PostgreSQL 8.4 and uses
lo_create
internally which is new
in 8.1; if this function is run against 8.0 or before, it will fail and return
InvalidOid
.
32.3.3. Exporting a Large Object
To export a large object into an operating system file, call
int lo_export(PGconn
*
conn, Oid lobjId, const char
*
filename);
The
lobjId
argument specifies the OID of the large object to export and the
filename
argument
specifies the operating system name of the file. Note that the file is written by the client interface
library, not bythe server. Returns 1 on success, -1 on failure.
32.3.4. Opening an Existing Large Object
To open an existing large object for reading or writing, call
int lo_open(PGconn
*
conn, Oid lobjId, int mode);
The
lobjId
argumentspecifies theOID of thelargeobject to open. The
mode
bits controlwhether the
object is opened for reading (
INV_READ
), writing (
INV_WRITE
), or both. (These symbolic constants
are defined in the header file
libpq/libpq-fs.h
.)
lo_open
returns a (non-negative) large object
descriptor for later use in
lo_read
,
lo_write
,
lo_lseek
,
lo_lseek64
,
lo_tell
,
lo_tell64
,
lo_truncate
,
lo_truncate64
,and
lo_close
.The descriptor is only valid for the duration of the
current transaction. On failure, -1 is returned.
The server currently does not distinguish between modes
INV_WRITE
and
INV_READ | INV_WRITE
:
youare allowed to read from the descriptor ineither case. However thereis a significant difference be-
tween these modes and
INV_READ
alone: with
INV_READ
you cannot write on the descriptor, and the
datareadfrom itwill reflect the contents of the large objectat the timeof the transaction snapshotthat
was active when
lo_open
was executed, regardless of later writes bythis or other transactions. Read-
ing from a descriptor opened with
INV_WRITE
returns data that reflects all writes of other committed
transactions as wellas writes of the current transaction. This is similar to the behavior of
REPEATABLE
READ
versus
READ COMMITTED
transaction modes for ordinary SQL
SELECT
commands.
An example:
inv_fd = lo_open(conn, inv_oid, INV_READ|INV_WRITE);
32.3.5. Writing Data to a Large Object
The function
int lo_write(PGconn
*
conn, int fd, const char
*
buf, size_t len);
728
How to add image to 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 jpg signature to pdf; add a jpeg to a pdf
How to add image to 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 picture to pdf form; add photo pdf
Chapter 32. Large Objects
writes
len
bytes from
buf
(whichmustbe of size
len
)tolargeobject descriptor
fd
.The
fd
argument
must have been returned by a previous
lo_open
.The number of bytes actually written is returned
(inthe current implementation, this will always equal
len
unless there is an error). In the event of an
error, the return value is -1.
Although the
len
parameter is declared as
size_t
,this function will reject length values larger than
INT_MAX
.In practice, it’s best to transfer data in chunks of at most a few megabytes anyway.
32.3.6. Reading Data from a Large Object
The function
int lo_read(PGconn
*
conn, int fd, char
*
buf, size_t len);
reads up to
len
bytes from large object descriptor
fd
into
buf
(which must be of size
len
). The
fd
argument must have been returned by a previous
lo_open
.The number of bytes actually read is
returned; this will be less than
len
if the end of the large object is reached first. In the event of an
error, the return value is -1.
Although the
len
parameter is declared as
size_t
,this function will reject length values larger than
INT_MAX
.In practice, it’s best to transfer data in chunks of at most a few megabytes anyway.
32.3.7. Seeking in a Large Object
To change the current read or write location associated with a large object descriptor, call
int lo_lseek(PGconn
*
conn, int fd, int offset, int whence);
This function moves the current location pointer for the large object descriptor identified by
fd
to
the new location specified by
offset
.The valid values for
whence
are
SEEK_SET
(seek from object
start),
SEEK_CUR
(seek from current position), and
SEEK_END
(seek from object end). The return
value is the new location pointer, or -1 on error.
When dealing with large objects that might exceed 2GB in size, instead use
pg_int64 lo_lseek64(PGconn
*
conn, int fd, pg_int64 offset, int whence);
This function has the same behavior as
lo_lseek
,but it can accept an
offset
larger than 2GB
and/or deliver a result larger than 2GB. Note that
lo_lseek
will fail if the new location pointer
would be greater than 2GB.
lo_lseek64
is new as of PostgreSQL 9.3. If this function is run against an older server version, it
will fail and return -1.
32.3.8. Obtaining the Seek Position of a Large Object
To obtain the current read or write location of a large object descriptor, call
int lo_tell(PGconn
*
conn, int fd);
If there is anerror, the return value is -1.
When dealing with large objects that might exceed 2GB in size, instead use
729
VB.NET PDF Form Data Read library: extract form data from PDF in
featured PDF software, it should have functions for processing text, image as well can help you have a quick evaluation of our PDF SDK. Add necessary references
how to add jpg to pdf file; adding image to pdf form
C# PDF Form Data Read Library: extract form data from PDF in C#.
featured PDF software, it should have functions for processing text, image as well can help you have a quick evaluation of our PDF SDK. Add necessary references
how to add an image to a pdf file; add jpg to pdf document
Chapter 32. Large Objects
pg_int64 lo_tell64(PGconn
*
conn, int fd);
This functionhas the samebehavior as
lo_tell
,but itcan deliver a resultlarger than 2GB. Note that
lo_tell
will fail if the current read/write location is greater than 2GB.
lo_tell64
is new as of PostgreSQL 9.3. If this functionis run against an older server version, itwill
fail and return -1.
32.3.9. Truncating a Large Object
To truncate a large object to a given length, call
int lo_truncate(PGcon
*
conn, int fd, size_t len);
This functiontruncates the large objectdescriptor
fd
tolength
len
.The
fd
argumentmusthave been
returned by a previous
lo_open
.If
len
is greater than the large object’s current length, the large
object is extended to the specified length with null bytes (’\0’). On success,
lo_truncate
returns
zero. On error, the return value is -1.
The read/write location associated with the descriptor
fd
is not changed.
Although the
len
parameter is declared as
size_t
,
lo_truncate
will reject length values larger
than
INT_MAX
.
When dealing with large objects that might exceed 2GB in size, instead use
int lo_truncate64(PGcon
*
conn, int fd, pg_int64 len);
This function has the same behavior as
lo_truncate
,but it can accept a
len
value exceeding 2GB.
lo_truncate
is new as of PostgreSQL 8.3; if this function is run against an older server version, it
will fail and return -1.
lo_truncate64
is new as of PostgreSQL 9.3; if this function is run against an older server version,
it will fail andreturn -1.
32.3.10. Closing a Large Object Descriptor
Alarge object descriptor can be closed by calling
int lo_close(PGconn
*
conn, int fd);
where
fd
is a large object descriptor returned by
lo_open
.On success,
lo_close
returns zero. On
error, the return value is -1.
Any large objectdescriptors that remain open at the end of a transaction willbe closed automatically.
32.3.11. Removing a Large Object
To remove a large object from the database, call
int lo_unlink(PGconn
*
conn, Oid lobjId);
The
lobjId
argument specifies the OID of the large object to remove. Returns 1 if successful, -1 on
failure.
730
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
Scan image to PDF, tiff and various image formats. Get image information, such as its location, zonal information Able to edit, add, delete, move, and output PDF
add picture to pdf; adding images to pdf
VB.NET PDF Password Library: add, remove, edit PDF file password
passwordSetting.IsAnnot = True ' Allow to fill form. passwordSetting document. passwordSetting.IsAssemble = True ' Add password to PDF file. PDFDocument
add an image to a pdf acrobat; add image to pdf
Chapter 32. Large Objects
32.4. Server-side Functions
Server-side functions tailored for manipulating large objects from SQL are listed in Table 32-1.
Table 32-1. SQL-oriented Large Object Functions
Function
Return Type
Description
Example
Result
lo_from_bytea(
loid
oid
,
string
bytea
)
oid
Create a large
object and store
data there,
returning its OID.
Pass
0
to have the
system choose an
OID.
lo_from_bytea(0,
E’\\xffffff00’)
24528
lo_put(
loid
oid
,
offset
bigint
,
str
bytea
)
void
Write data at the
given offset.
lo_put(24528,
1, E’\\xaa’)
lo_get(
loid oid
[,
from bigint
,
for int
])
bytea
Extract contents
or a substring
thereof.
lo_get(24528,
0, 3)
\xffaaff
There areadditionalserver-side functions correspondingtoeach of the client-side functions described
earlier; indeed, for the mostparttheclient-sidefunctions are simply interfaces to theequivalent server-
side functions. The ones just as convenient to call via SQL commands are
lo_creat
,
lo_create
,
lo_unlink
,
lo_import
,and
lo_export
.Here are examples of their use:
CREATE TABLE image (
name
text,
raster
oid
);
SELECT lo_creat(-1);
-- returns OID of new, empty large object
SELECT lo_create(43213);
-- attempts to create large object with OID 43213
SELECT lo_unlink(173454);
-- deletes large object with OID 173454
INSERT INTO image (name, raster)
VALUES (’beautiful image’, lo_import(’/etc/motd’));
INSERT INTO image (name, raster)
-- same as above, but specify OID to use
VALUES (’beautiful image’, lo_import(’/etc/motd’, 68583));
SELECT lo_export(image.raster, ’/tmp/motd’) FROM image
WHERE name = ’beautiful image’;
The server-side
lo_import
and
lo_export
functions behave considerably differently from their
client-side analogs. These two functions read and write files in the server’s file system, using the
permissions of the database’s owning user. Therefore, their use is restricted to superusers. In contrast,
the client-side import and export functions read and write files in the client’s file system, using the
permissions of the client program. The client-side functions do not require superuser privilege.
731
VB.NET PDF Image Extract Library: Select, copy, paste PDF images
multiple types of image from PDF file in VB.NET, like XObject Image, XObject Form, Inline Image DLLs for PDF Image Extraction in VB.NET. Add necessary references
adding image to pdf; add multiple jpg to pdf
C# PDF Password Library: add, remove, edit PDF file password in C#
passwordSetting.IsAnnot = true; // Allow to fill form. passwordSetting document. passwordSetting.IsAssemble = true; // Add password to PDF file. PDFDocument
how to add a photo to a pdf document; adding jpg to pdf
Chapter 32. Large Objects
The functionality of
lo_read
and
lo_write
is also available via server-side calls, but the names of
the server-side functions differ from the client side interfaces in that they do not contain underscores.
You must call these functions as
loread
and
lowrite
.
32.5. Example Program
Example 32-1 is a sample program which shows how the large object interface in libpq can be used.
Partsof theprogram are commentedoutbutareleft in the source for the reader’s benefit. This program
can also be found in
src/test/examples/testlo.c
in the source distribution.
Example 32-1. Large Objects with libpq Example Program
/
*
-------------------------------------------------------------------------
*
*
testlo.c
*
test using large objects with libpq
*
*
Portions Copyright (c) 1996-2014, PostgreSQL Global Development Group
*
Portions Copyright (c) 1994, Regents of the University of California
*
*
*
IDENTIFICATION
*
src/test/examples/testlo.c
*
*
-------------------------------------------------------------------------
*
/
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include "libpq-fe.h"
#include "libpq/libpq-fs.h"
#define BUFSIZE
1024
/
*
*
importFile -
*
import file "in_filename" into database as large object "lobjOid"
*
*
/
static Oid
importFile(PGconn
*
conn, char
*
filename)
{
Oid
lobjId;
int
lobj_fd;
char
buf[BUFSIZE];
int
nbytes,
tmp;
int
fd;
732
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.
how to add image to pdf acrobat; adding an image to a pdf in preview
C# PDF Sticky Note Library: add, delete, update PDF note in C#.net
C#.NET PDF SDK - Add Sticky Note to PDF Page in C#.NET. Able to add notes to PDF using C# source code in Visual Studio .NET framework.
adding images to pdf forms; add picture to pdf reader
Chapter 32. Large Objects
/
*
*
open the file to be read in
*
/
fd = open(filename, O_RDONLY, 0666);
if (fd < 0)
{
/
*
error
*
/
fprintf(stderr, "cannot open unix file\"%s\"\n", filename);
}
/
*
*
create the large object
*
/
lobjId = lo_creat(conn, INV_READ | INV_WRITE);
if (lobjId == 0)
fprintf(stderr, "cannot create large object");
lobj_fd = lo_open(conn, lobjId, INV_WRITE);
/
*
*
read in from the Unix file and write to the inversion file
*
/
while ((nbytes = read(fd, buf, BUFSIZE)) > 0)
{
tmp = lo_write(conn, lobj_fd, buf, nbytes);
if (tmp < nbytes)
fprintf(stderr, "error while reading \"%s\"", filename);
}
close(fd);
lo_close(conn, lobj_fd);
return lobjId;
}
static void
pickout(PGconn
*
conn, Oid lobjId, int start, int len)
{
int
lobj_fd;
char
*
buf;
int
nbytes;
int
nread;
lobj_fd = lo_open(conn, lobjId, INV_READ);
if (lobj_fd < 0)
fprintf(stderr, "cannot open large object %u", lobjId);
lo_lseek(conn, lobj_fd, start, SEEK_SET);
buf = malloc(len + 1);
nread = 0;
while (len - nread > 0)
{
nbytes = lo_read(conn, lobj_fd, buf, len - nread);
buf[nbytes] = ’\0’;
fprintf(stderr, ">>> %s", buf);
nread += nbytes;
if (nbytes <= 0)
733
Chapter 32. Large Objects
break;
/
*
no more data?
*
/
}
free(buf);
fprintf(stderr, "\n");
lo_close(conn, lobj_fd);
}
static void
overwrite(PGconn
*
conn, Oid lobjId, int start, int len)
{
int
lobj_fd;
char
*
buf;
int
nbytes;
int
nwritten;
int
i;
lobj_fd = lo_open(conn, lobjId, INV_WRITE);
if (lobj_fd < 0)
fprintf(stderr, "cannot open large object %u", lobjId);
lo_lseek(conn, lobj_fd, start, SEEK_SET);
buf = malloc(len + 1);
for (i = 0; i < len; i++)
buf[i] = ’X’;
buf[i] = ’\0’;
nwritten = 0;
while (len - nwritten > 0)
{
nbytes = lo_write(conn, lobj_fd, buf + nwritten, len - nwritten);
nwritten += nbytes;
if (nbytes <= 0)
{
fprintf(stderr, "\nWRITE FAILED!\n");
break;
}
}
free(buf);
fprintf(stderr, "\n");
lo_close(conn, lobj_fd);
}
/
*
*
exportFile -
*
export large object "lobjOid" to file "out_filename"
*
*
/
static void
exportFile(PGconn
*
conn, Oid lobjId, char
*
filename)
{
int
lobj_fd;
char
buf[BUFSIZE];
int
nbytes,
tmp;
int
fd;
734
Chapter 32. Large Objects
/
*
*
open the large object
*
/
lobj_fd = lo_open(conn, lobjId, INV_READ);
if (lobj_fd < 0)
fprintf(stderr, "cannot open large object %u", lobjId);
/
*
*
open the file to be written to
*
/
fd = open(filename, O_CREAT | O_WRONLY | O_TRUNC, 0666);
if (fd < 0)
{
/
*
error
*
/
fprintf(stderr, "cannot open unix file\"%s\"",
filename);
}
/
*
*
read in from the inversion file and write to the Unix file
*
/
while ((nbytes = lo_read(conn, lobj_fd, buf, BUFSIZE)) > 0)
{
tmp = write(fd, buf, nbytes);
if (tmp < nbytes)
{
fprintf(stderr, "error while writing \"%s\"",
filename);
}
}
lo_close(conn, lobj_fd);
close(fd);
return;
}
static void
exit_nicely(PGconn
*
conn)
{
PQfinish(conn);
exit(1);
}
int
main(int argc, char
**
argv)
{
char
*
in_filename,
*
out_filename;
char
*
database;
Oid
lobjOid;
PGconn
*
conn;
PGresult
*
res;
if (argc != 4)
{
fprintf(stderr, "Usage: %s database_name in_filename out_filename\n",
735
Chapter 32. Large Objects
argv[0]);
exit(1);
}
database = argv[1];
in_filename = argv[2];
out_filename = argv[3];
/
*
*
set up the connection
*
/
conn = PQsetdb(NULL, NULL, NULL, NULL, database);
/
*
check to see that the backend connection was successfully made
*
/
if (PQstatus(conn) != CONNECTION_OK)
{
fprintf(stderr, "Connection to database failed: %s",
PQerrorMessage(conn));
exit_nicely(conn);
}
res = PQexec(conn, "begin");
PQclear(res);
printf("importing file \"%s\" ...\n", in_filename);
/
*
lobjOid = importFile(conn, in_filename);
*
/
lobjOid = lo_import(conn, in_filename);
if (lobjOid == 0)
fprintf(stderr, "%s\n", PQerrorMessage(conn));
else
{
printf("\tas large object %u.\n", lobjOid);
printf("picking out bytes 1000-2000 of the large object\n");
pickout(conn, lobjOid, 1000, 1000);
printf("overwriting bytes 1000-2000 of the large object with X’s\n");
overwrite(conn, lobjOid, 1000, 1000);
printf("exporting large object to file \"%s\" ...\n", out_filename);
/
*
exportFile(conn, lobjOid, out_filename);
*
/
if (lo_export(conn, lobjOid, out_filename) < 0)
fprintf(stderr, "%s\n", PQerrorMessage(conn));
}
res = PQexec(conn, "end");
PQclear(res);
PQfinish(conn);
return 0;
}
736
Chapter 33. ECPG - Embedded SQL in C
This chapter describes the embedded SQL package for PostgreSQL. It was written by Linus Tolke
(<
linus@epact.se
>) andMichael Meskes (<
meskes@postgresql.org
>). Originally itwas writ-
ten to work with C. It also works with C++, but it does not recognize all C++ constructs yet.
This documentation is quite incomplete. But since this interface is standardized, additional informa-
tion can be found in many resources about SQL.
33.1. The Concept
An embedded SQL program consists of code written in an ordinary programming language, in this
case C, mixed with SQL commands in specially marked sections. To build the program, the source
code (
*
.pgc
)is first passed through the embedded SQL preprocessor, which converts it to an ordi-
nary C program (
*
.c
), and afterwards it can be processed by a C compiler. (For details about the
compiling and linking see Section 33.10). Converted ECPG applications call functions in the libpq
library through the embedded SQL library (ecpglib), and communicate with the PostgreSQL server
using the normal frontend-backend protocol.
Embedded SQL has advantages over other methods for handling SQL commands from C code. First,
it takes care of the tedious passing of information to and from variables in your C program. Second,
the SQL code in the program is checked at build time for syntactical correctness. Third, embedded
SQL in C is specified in the SQL standard and supported by many other SQL database systems.
The PostgreSQL implementation is designed to match this standard as much as possible, and it is
usually possible to port embedded SQL programs written for other SQL databases to PostgreSQL
with relative ease.
As already stated, programs written for the embedded SQL interface are normal C programs with
special code inserted to perform database-related actions. This special code always has the form:
EXEC SQL ...;
These statements syntacticallytake theplaceof a C statement. Depending on the particular statement,
they can appear at the global level or within a function. Embedded SQL statements follow the case-
sensitivity rules of normal SQL code, and not those of C. Also they allow nested C-style comments
that are part of the SQL standard. The C part of the program, however, follows the C standard of not
accepting nested comments.
The following sections explain all the embedded SQL statements.
33.2. Managing Database Connections
This section describes how to open, close, andswitchdatabase connections.
33.2.1. Connecting to the Database Server
One connects to a database using the following statement:
EXEC SQL CONNECT TO
target
[AS
connection-name
] [USER
user-name
];
The
target
canbe specified in the following ways:
737
Documents you may be interested
Documents you may be interested