pdf viewer in asp net c# : Add photo to pdf preview application control utility azure html asp.net visual studio postgresql-9.4-A477-part3002

Chapter 31. libpq - C Library
Note: On Windows, if the libpq library and an application are compiled with different
flags, this function call will crash the application because the internal representation of
the
FILE
pointers differ. Specifically, multithreaded/single-threaded, release/debug, and
static/dynamic flags should be the same for the library and all applications using that library.
PQuntrace
Disables tracing started by
PQtrace
.
void PQuntrace(PGconn
*
conn);
31.11. Miscellaneous Functions
As always, there are some functions that just don’t fit anywhere.
PQfreemem
Frees memory allocated by libpq.
void PQfreemem(void
*
ptr);
Frees memory allocated by libpq, particularly
PQescapeByteaConn
,
PQescapeBytea
,
PQunescapeBytea
, and
PQnotifies
. It is particularly important that this function, rather
than
free()
,be used on Microsoft Windows. This is because allocating memory in a DLL and
releasing it in the application works only if multithreaded/single-threaded, release/debug, and
static/dynamic flags are the same for the DLL and the application. On non-Microsoft Windows
platforms, this function is the same as the standard library function
free()
.
PQconninfoFree
Frees the data structures allocated by
PQconndefaults
or
PQconninfoParse
.
void PQconninfoFree(PQconninfoOption
*
connOptions);
Asimple
PQfreemem
will not do for this, since the array contains references to subsidiary
strings.
PQencryptPassword
Prepares the encrypted form of a PostgreSQL password.
char
*
PQencryptPassword(const char
*
passwd, const char
*
user);
This function is intended to be used by client applications that wish to send commands like
ALTER USER joe PASSWORD ’pwd’
.It is good practice nottosendtheoriginal cleartext pass-
word in such a command, because it might be exposed in command logs, activity displays, and
so on. Instead, use this function to convert the password to encrypted form before it is sent. The
arguments are the cleartext password, and the SQL name of the user it is for. The return value is
astring allocated by
malloc
,or
NULL
if out of memory. The caller can assume the stringdoesn’t
contain any special characters that would require escaping. Use
PQfreemem
to free the result
when done with it.
PQmakeEmptyPGresult
Constructs an empty
PGresult
object with the given status.
PGresult
*
PQmakeEmptyPGresult(PGconn
*
conn, ExecStatusType status);
This is libpq’s internal function to allocate and initialize an empty
PGresult
object. This func-
tionreturns
NULL
if memory could not be allocated. Itis exported because someapplications find
it useful to generate result objects (particularly objects with error status) themselves. If
conn
is
698
Add photo to pdf 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 jpeg to pdf; add an image to a pdf form
Add photo to pdf 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
how to add image to pdf in preview; add an image to a pdf with acrobat
Chapter 31. libpq - C Library
not null and
status
indicates an error, the current error message of the specified connection is
copied into the
PGresult
.Also, if
conn
is not null, any event procedures registered in the con-
nection are copied into the
PGresult
.(They do not get
PGEVT_RESULTCREATE
calls, but see
PQfireResultCreateEvents
.) Note that
PQclear
should eventually be called on the object,
just as with a
PGresult
returned by libpq itself.
PQfireResultCreateEvents
Fires a
PGEVT_RESULTCREATE
event (see Section 31.13) for each event procedure registered in
the
PGresult
object. Returns non-zero for success, zero if any event procedure fails.
int PQfireResultCreateEvents(PGconn
*
conn, PGresult
*
res);
The
conn
argument is passed through to event procedures but not used directly. It can be
NULL
if the event procedures won’t use it.
Event procedures that have already received a
PGEVT_RESULTCREATE
or
PGEVT_RESULTCOPY
event for this object are not fired again.
The main reason that this function is separate from
PQmakeEmptyPGresult
is that it is often
appropriate to create a
PGresult
and fill it with data before invoking the event procedures.
PQcopyResult
Makes a copy of a
PGresult
object. The copy is not linked to the source result in any way
and
PQclear
must be called when the copy is no longer needed. If the function fails,
NULL
is
returned.
PGresult
*
PQcopyResult(const PGresult
*
src, int flags);
This is not intended to make an exact copy. The returned result is always put into
PGRES_TUPLES_OK
status, and does not copy any error message in the source. (It does copy the
command status string, however.) The
flags
argument determines what else is copied. It
is a bitwise OR of several flags.
PG_COPYRES_ATTRS
specifies copying the source result’s
attributes (column definitions).
PG_COPYRES_TUPLES
specifies copying the source result’s
tuples. (This implies copying the attributes, too.)
PG_COPYRES_NOTICEHOOKS
specifies
copying the source result’s notify hooks.
PG_COPYRES_EVENTS
specifies copying the source
result’s events. (But any instance data associated with the source is not copied.)
PQsetResultAttrs
Sets the attributes of a
PGresult
object.
int PQsetResultAttrs(PGresult
*
res, int numAttributes, PGresAttDesc
*
attDescs);
The provided
attDescs
are copied into the result. If the
attDescs
pointer is
NULL
or
numAttributes
is less than one, the request is ignored and the function succeeds. If
res
already contains attributes, the function will fail. If the function fails, the return value is zero. If
the function succeeds, the return value is non-zero.
PQsetvalue
Sets a tuple fieldvalue of a
PGresult
object.
int PQsetvalue(PGresult
*
res, int tup_num, int field_num, char
*
value, int len);
The function will automatically grow the result’s internal tuples array as needed. However, the
tup_num
argument must be less than or equal to
PQntuples
,meaning this function can only
grow the tuples array one tuple at a time. But any field of any existing tuple can be modified in
any order. If a value at
field_num
already exists, it will be overwritten. If
len
is -1 or
value
is
NULL
,the field value will be set to an SQL null value. The
value
is copied into the result’s
private storage, thus is no longer neededafter the function returns. If the functionfails, thereturn
value is zero. If the function succeeds, the return value is non-zero.
699
C# PDF remove image library: remove, delete images from PDF in C#.
Support removing vector image, graphic picture, digital photo, scanned signature, logo, etc. Remove Image from PDF Page Using C#. Add necessary references:
adding image to pdf file; how to add image to pdf file
VB.NET PDF remove image library: remove, delete images from PDF in
Support removing vector image, graphic picture, digital photo, scanned signature, logo, etc. VB.NET: Remove Image from PDF Page. Add necessary references:
add image to pdf online; add picture to pdf document
Chapter 31. libpq - C Library
PQresultAlloc
Allocate subsidiary storage for a
PGresult
object.
void
*
PQresultAlloc(PGresult
*
res, size_t nBytes);
Any memory allocatedwith this function will be freed when
res
is cleared. If the function fails,
the return value is
NULL
.The result is guaranteed to be adequately aligned for any type of data,
just as for
malloc
.
PQlibVersion
Return the version of libpq that is being used.
int PQlibVersion(void);
The result of this function can be used to determine, at run time, if specific functionality is
available in the currently loaded version of libpq. The function can be used, for example, to
determine which connectionoptions are available for
PQconnectdb
or if the
hex bytea
output
added in PostgreSQL 9.0 is supported.
The number is formed by converting the major, minor, and revision numbers into two-decimal-
digit numbers and appendingthem together. For example, version9.1 will be returned as 90100,
andversion 9.1.2 will be returned as 90102 (leading zeroes are not shown).
Note: This function appeared in PostgreSQL version 9.1, so it cannot be used to detect
required functionality in earlier versions, since linking to it will create a link dependency on
version 9.1.
31.12. Notice Processing
Notice and warning messages generated by the server are not returned by the query execution func-
tions, since they do not imply failure of the query. Instead they are passed to a notice handling func-
tion, and executioncontinues normally after the handler returns. The default notice handling function
prints the message on
stderr
,but the application can override this behavior by supplying its own
handling function.
For historical reasons, there are two levels of notice handling, called the notice receiver and notice
processor. The default behavior is for the notice receiver to format the notice and pass a string to the
notice processor for printing. However, an application that chooses to provide its own notice receiver
will typically ignore the notice processor layer and just do all the work in the notice receiver.
The function
PQsetNoticeReceiver
sets or examines the current notice receiver for a connection
object. Similarly,
PQsetNoticeProcessor
sets or examines the current notice processor.
typedef void (
*
PQnoticeReceiver) (void
*
arg, const PGresult
*
res);
PQnoticeReceiver
PQsetNoticeReceiver(PGconn
*
conn,
PQnoticeReceiver proc,
void
*
arg);
typedef void (
*
PQnoticeProcessor) (void
*
arg, const char
*
message);
PQnoticeProcessor
700
VB.NET PDF copy, paste image library: copy, paste, cut PDF images
to copy, paste and cut vector image, graphic picture, digital photo, scanned signature VB.NET DLLs: Copy, Paste, Cut Image in PDF Page. Add necessary references:
add jpg to pdf acrobat; add jpg to pdf online
Chapter 31. libpq - C Library
PQsetNoticeProcessor(PGconn
*
conn,
PQnoticeProcessor proc,
void
*
arg);
Each of these functions returns the previous notice receiver or processor function pointer, and sets the
newvalue. If you supply a nullfunction pointer, no action is taken, but the current pointer is returned.
When a notice or warning message is received from the server, or generated internally by libpq, the
notice receiver function is called. It is passedthe message inthe form of a
PGRES_NONFATAL_ERROR
PGresult
.(This allows the receiver to extract individualfields using
PQresultErrorField
,or the
complete preformatted message using
PQresultErrorMessage
.) The same void pointer passed to
PQsetNoticeReceiver
is also passed. (This pointer canbe usedto access application-specific state
if needed.)
The defaultnotice receiver simply extracts the message(using
PQresultErrorMessage
)andpasses
it to the notice processor.
The notice processor is responsible for handling a notice or warning message given in text form. It is
passed the string text of the message (includinga trailingnewline), plus avoid pointer that is the same
onepassedto
PQsetNoticeProcessor
.(This pointer canbeusedtoaccess application-specific state
if needed.)
The default notice processor is simply:
static void
defaultNoticeProcessor(void
*
arg, const char
*
message)
{
fprintf(stderr, "%s", message);
}
Once you have set a notice receiver or processor, you should expect that that function could be
called as long as either the
PGconn
object or
PGresult
objects made from it exist. At creation of a
PGresult
,the
PGconn
’s current notice handlingpointers are copied into the
PGresult
for possible
use by functions like
PQgetvalue
.
31.13. Event System
libpq’s event system is designed to notify registered event handlers about interesting libpq events,
such as the creation or destruction of
PGconn
and
PGresult
objects. Aprincipal use case is that this
allows applications to associate their own data with a
PGconn
or
PGresult
and ensure that that data
is freed at an appropriate time.
Each registered event handler is associated with two pieces of data, known to libpq only as opaque
void
*
pointers. There is a passthrough pointer that is provided by the application when the event
handler is registered witha
PGconn
.Thepassthroughpointer never changes for the life of the
PGconn
and all
PGresult
sgenerated from it; so if used, it must point to long-lived data. In addition there
is an instance data pointer, which starts out
NULL
in every
PGconn
and
PGresult
.This pointer can
be manipulated usingthe
PQinstanceData
,
PQsetInstanceData
,
PQresultInstanceData
and
PQsetResultInstanceData
functions. Note that unlike the passthrough pointer, instance data of
a
PGconn
is not automatically inherited by
PGresult
screated from it. libpq does not know what
passthrough and instance data pointers point to (if anything) and will never attempt to free them —
that is the responsibility of the event handler.
701
Chapter 31. libpq - C Library
31.13.1. Event Types
The enum
PGEventId
names the types of events handled by the event system. All its values have
names beginning with
PGEVT
.For each event type, there is a corresponding event info structure that
carries the parameters passed to the event handlers. The event types are:
PGEVT_REGISTER
Theregister event occurs when
PQregisterEventProc
is called. Itis the idealtime to initialize
any
instanceData
aneventprocedure may need. Onlyoneregister event will be firedper event
handler per connection. If the event procedure fails, the registration is aborted.
typedef struct
{
PGconn
*
conn;
} PGEventRegister;
When a
PGEVT_REGISTER
event is received, the
evtInfo
pointer should be cast to a
PGEventRegister
*
.This structure contains a
PGconn
thatshould be in the
CONNECTION_OK
status; guaranteed if one calls
PQregisterEventProc
right after obtaining a good
PGconn
.
When returning a failure code, all cleanup must be performed as no
PGEVT_CONNDESTROY
event will be sent.
PGEVT_CONNRESET
The connection reset event is fired on completion of
PQreset
or
PQresetPoll
.In both cases,
the event is only fired if the reset was successful. If the event procedure fails, the entire con-
nection reset will fail; the
PGconn
is put into
CONNECTION_BAD
status and
PQresetPoll
will
return
PGRES_POLLING_FAILED
.
typedef struct
{
PGconn
*
conn;
} PGEventConnReset;
When a
PGEVT_CONNRESET
event is received, the
evtInfo
pointer should be cast to a
PGEventConnReset
*
.Although the contained
PGconn
was just reset, all event data remains
unchanged. This event should be used to reset/reload/requery any associated
instanceData
.
Note that even if the event procedure fails to process
PGEVT_CONNRESET
,it will still receive a
PGEVT_CONNDESTROY
event when the connection is closed.
PGEVT_CONNDESTROY
The connection destroy event is fired in response to
PQfinish
.It is the event procedure’s re-
sponsibility to properly clean up its event data as libpq has no ability to manage this memory.
Failure to clean up will lead to memory leaks.
typedef struct
{
PGconn
*
conn;
} PGEventConnDestroy;
When a
PGEVT_CONNDESTROY
event is received, the
evtInfo
pointer should be cast to a
PGEventConnDestroy
*
.This event is fired prior to
PQfinish
performinganyother cleanup.
The return value of the event procedure is ignored since there is no way of indicating a failure
from
PQfinish
.Also, an event procedure failure should not abort the process of cleaning up
unwanted memory.
702
Chapter 31. libpq - C Library
PGEVT_RESULTCREATE
The result creation event is fired in response to any query execution function that generates a
result, including
PQgetResult
.This event will only be fired after the result has been created
successfully.
typedef struct
{
PGconn
*
conn;
PGresult
*
result;
} PGEventResultCreate;
When a
PGEVT_RESULTCREATE
event is received, the
evtInfo
pointer should be cast to a
PGEventResultCreate
*
.The
conn
is the connection used to generate the result. This is the
ideal place to initialize any
instanceData
that needs to be associated with the result. If the
event procedure fails, the result will be cleared and the failure will be propagated. The event
procedure must not try to
PQclear
the result object for itself. When returning a failure code, all
cleanup must be performed as no
PGEVT_RESULTDESTROY
event will be sent.
PGEVT_RESULTCOPY
The result copy event is fired in response to
PQcopyResult
. This event will only be fired
after the copy is complete. Only event procedures that have successfully handled the
PGEVT_RESULTCREATE
or
PGEVT_RESULTCOPY
event for the source result will receive
PGEVT_RESULTCOPY
events.
typedef struct
{
const PGresult
*
src;
PGresult
*
dest;
} PGEventResultCopy;
When a
PGEVT_RESULTCOPY
event is received, the
evtInfo
pointer should be cast to a
PGEventResultCopy
*
. The
src
result is what was copied while the
dest
result is the
copy destination. This event can be used to provide a deep copy of
instanceData
, since
PQcopyResult
cannot do that. If the event procedure fails, the entire copy operation will
fail and the
dest
result will be cleared. When returning a failure code, all cleanup must be
performed as no
PGEVT_RESULTDESTROY
event will be sent for the destination result.
PGEVT_RESULTDESTROY
The result destroy event is fired in response to a
PQclear
.It is the event procedure’s responsi-
bility to properly clean up its event data as libpq has no ability to manage this memory. Failure
to clean up will lead to memory leaks.
typedef struct
{
PGresult
*
result;
} PGEventResultDestroy;
When a
PGEVT_RESULTDESTROY
event is received, the
evtInfo
pointer should be cast to
a
PGEventResultDestroy
*
. This event is fired prior to
PQclear
performing any other
cleanup. The return value of the event procedure is ignored since there is no way of indicating a
failure from
PQclear
.Also, an event procedure failure should not abort the process of cleaning
up unwanted memory.
703
Chapter 31. libpq - C Library
31.13.2. Event Callback Procedure
PGEventProc
PGEventProc
is a typedef for a pointer to an event procedure, that is, the user callback function
that receives events from libpq. The signature of an event procedure must be
int eventproc(PGEventId evtId, void
*
evtInfo, void
*
passThrough)
The
evtId
parameter indicates which
PGEVT
event occurred. The
evtInfo
pointer must becast
tothe appropriate structure typetoobtainfurther informationaboutthe event. The
passThrough
parameter is the pointer provided to
PQregisterEventProc
when the event procedure was
registered. The function should return a non-zero value if it succeeds and zero if it fails.
Aparticular event procedure can be registered only once in any
PGconn
.This is because the
address of the procedure is used as a lookup key to identify the associated instance data.
Caution
OnWindows, functions canhave twodifferent addresses: one visible
from outside a DLL and another visible from inside the DLL. One
shouldbecarefulthat onlyoneoftheseaddresses isused withlibpq’s
event-procedure functions, else confusion will result. The simplest
rule for writing code that will work is to ensure that event procedures
are declared
static
.If the procedure’s address must be available
outside its own source file, expose a separate function to return the
address.
31.13.3. Event Support Functions
PQregisterEventProc
Registers an event callback procedure with libpq.
int PQregisterEventProc(PGconn
*
conn, PGEventProc proc,
const char
*
name, void
*
passThrough);
An event procedure must be registered once on each
PGconn
you want to receive events about.
There is no limit, other than memory, on the number of event procedures that can be registered
with a connection. The function returns a non-zero value if it succeeds and zero if it fails.
The
proc
argument will be called when a libpq event is fired. Its memory address is also used
to lookup
instanceData
.The
name
argument is used to refer to the event procedure in error
messages. This value cannot be
NULL
or a zero-length string. The name string is copied into the
PGconn
,so what is passed need not be long-lived. The
passThrough
pointer is passed to the
proc
whenever an event occurs. This argument can be
NULL
.
PQsetInstanceData
Sets the connection
conn
’s
instanceData
for procedure
proc
to
data
.This returns non-zero
for success andzero for failure. (Failure is onlypossible if
proc
has not been properly registered
in
conn
.)
int PQsetInstanceData(PGconn
*
conn, PGEventProc proc, void
*
data);
704
Chapter 31. libpq - C Library
PQinstanceData
Returns the connection
conn
’s
instanceData
associatedwithprocedure
proc
,or
NULL
if there
is none.
void
*
PQinstanceData(const PGconn
*
conn, PGEventProc proc);
PQresultSetInstanceData
Sets the result’s
instanceData
for
proc
to
data
.This returns non-zero for success and zero
for failure. (Failure is only possible if
proc
has not been properly registered in the result.)
int PQresultSetInstanceData(PGresult
*
res, PGEventProc proc, void
*
data);
PQresultInstanceData
Returns the result’s
instanceData
associated with
proc
,or
NULL
if there is none.
void
*
PQresultInstanceData(const PGresult
*
res, PGEventProc proc);
31.13.4. Event Example
Here is a skeleton example of managing private data associated withlibpq connections and results.
/
*
required header for libpq events (note: includes libpq-fe.h)
*
/
#include <libpq-events.h>
/
*
The instanceData
*
/
typedef struct
{
int n;
char
*
str;
} mydata;
/
*
PGEventProc
*
/
static int myEventProc(PGEventId evtId, void
*
evtInfo, void
*
passThrough);
int
main(void)
{
mydata
*
data;
PGresult
*
res;
PGconn
*
conn = PQconnectdb("dbname = postgres");
if (PQstatus(conn) != CONNECTION_OK)
{
fprintf(stderr, "Connection to database failed: %s",
PQerrorMessage(conn));
PQfinish(conn);
return 1;
}
/
*
called once on any connection that should receive events.
*
Sends a PGEVT_REGISTER to myEventProc.
*
/
if (!PQregisterEventProc(conn, myEventProc, "mydata_proc", NULL))
{
fprintf(stderr, "Cannot register PGEventProc\n");
PQfinish(conn);
return 1;
705
Chapter 31. libpq - C Library
}
/
*
conn instanceData is available
*
/
data = PQinstanceData(conn, myEventProc);
/
*
Sends a PGEVT_RESULTCREATE to myEventProc
*
/
res = PQexec(conn, "SELECT 1 + 1");
/
*
result instanceData is available
*
/
data = PQresultInstanceData(res, myEventProc);
/
*
If PG_COPYRES_EVENTS is used, sends a PGEVT_RESULTCOPY to myEventProc
*
/
res_copy = PQcopyResult(res, PG_COPYRES_TUPLES | PG_COPYRES_EVENTS);
/
*
result instanceData is available if PG_COPYRES_EVENTS was
*
used during the PQcopyResult call.
*
/
data = PQresultInstanceData(res_copy, myEventProc);
/
*
Both clears send a PGEVT_RESULTDESTROY to myEventProc
*
/
PQclear(res);
PQclear(res_copy);
/
*
Sends a PGEVT_CONNDESTROY to myEventProc
*
/
PQfinish(conn);
return 0;
}
static int
myEventProc(PGEventId evtId, void
*
evtInfo, void
*
passThrough)
{
switch (evtId)
{
case PGEVT_REGISTER:
{
PGEventRegister
*
e = (PGEventRegister
*
)evtInfo;
mydata
*
data = get_mydata(e->conn);
/
*
associate app specific data with connection
*
/
PQsetInstanceData(e->conn, myEventProc, data);
break;
}
case PGEVT_CONNRESET:
{
PGEventConnReset
*
e = (PGEventConnReset
*
)evtInfo;
mydata
*
data = PQinstanceData(e->conn, myEventProc);
if (data)
memset(data, 0, sizeof(mydata));
break;
}
case PGEVT_CONNDESTROY:
{
PGEventConnDestroy
*
e = (PGEventConnDestroy
*
)evtInfo;
706
Chapter 31. libpq - C Library
mydata
*
data = PQinstanceData(e->conn, myEventProc);
/
*
free instance data because the conn is being destroyed
*
/
if (data)
free_mydata(data);
break;
}
case PGEVT_RESULTCREATE:
{
PGEventResultCreate
*
e = (PGEventResultCreate
*
)evtInfo;
mydata
*
conn_data = PQinstanceData(e->conn, myEventProc);
mydata
*
res_data = dup_mydata(conn_data);
/
*
associate app specific data with result (copy it from conn)
*
/
PQsetResultInstanceData(e->result, myEventProc, res_data);
break;
}
case PGEVT_RESULTCOPY:
{
PGEventResultCopy
*
e = (PGEventResultCopy
*
)evtInfo;
mydata
*
src_data = PQresultInstanceData(e->src, myEventProc);
mydata
*
dest_data = dup_mydata(src_data);
/
*
associate app specific data with result (copy it from a result)
*
/
PQsetResultInstanceData(e->dest, myEventProc, dest_data);
break;
}
case PGEVT_RESULTDESTROY:
{
PGEventResultDestroy
*
e = (PGEventResultDestroy
*
)evtInfo;
mydata
*
data = PQresultInstanceData(e->result, myEventProc);
/
*
free instance data because the result is being destroyed
*
/
if (data)
free_mydata(data);
break;
}
/
*
unknown event ID, just return TRUE.
*
/
default:
break;
}
return TRUE; /
*
event processing succeeded
*
/
}
707
Documents you may be interested
Documents you may be interested