pdf viewer dll for c# : How to add image to pdf form SDK control service wpf web page azure dnn postgresql-9.4-A4126-part2753

Chapter 44. Server Programming Interface
2
2
-- 2 rows
*
1 (x in first row)
6
-- 3 rows (2 + 1 just inserted)
*
2 (x in second row)
(4 rows)
^^^^^^
rows visible to execq() in different invocations
1188
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
how to add an image to a pdf file in acrobat; how to add a photo to a pdf document
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
how to add image to pdf file; how to add image to pdf
Chapter 45. Background Worker Processes
PostgreSQL can be extended to run user-supplied code in separate processes. Such processes are
started, stopped and monitoredby
postgres
,which permits them to have a lifetime closely linked to
theserver’s status. These processes have the option to attachtoPostgreSQL’s sharedmemoryarea and
to connect to databases internally; they can also run multiple transactions serially, just like a regular
client-connected server process. Also, by linking to libpq they can connect to the server and behave
like a regular client application.
Warning
There are considerable robustness and security risks in using background
worker processes because, being written in the
C
language, they have
unrestricted access to data. Administrators wishing to enable modules that
include background worker process should exercise extreme caution. Only
carefully audited modules should be permitted to run background worker
processes.
Background workers can be initialized at the time that PostgreSQL is started by including the
module name in
shared_preload_libraries
.A module wishing to run a background worker
can register it by calling
RegisterBackgroundWorker(
BackgroundWorker
*
worker
)
from
its
_PG_init()
. Background workers can also be started after the system is up and running by
calling the function
RegisterDynamicBackgroundWorker(
BackgroundWorker
*
worker,
BackgroundWorkerHandle
**
handle
)
.Unlike
RegisterBackgroundWorker
,which can only be
called from within the postmaster,
RegisterDynamicBackgroundWorker
must be called from a
regular backend.
The structure
BackgroundWorker
is defined thus:
typedef void (
*
bgworker_main_type)(Datum main_arg);
typedef struct BackgroundWorker
{
char
bgw_name[BGW_MAXLEN];
int
bgw_flags;
BgWorkerStartTime bgw_start_time;
int
bgw_restart_time;
/
*
in seconds, or BGW_NEVER_RESTART
*
/
bgworker_main_type bgw_main;
char
bgw_library_name[BGW_MAXLEN];
/
*
only if bgw_main is NULL
*
/
char
bgw_function_name[BGW_MAXLEN];
/
*
only if bgw_main is NULL
*
/
Datum
bgw_main_arg;
int
bgw_notify_pid;
} BackgroundWorker;
bgw_name
is a string to be used in log messages, process listings and similar contexts.
bgw_flags
is a bitwise-or’d bit mask indicating the capabilities that the module wants.
Possible values are
BGWORKER_SHMEM_ACCESS
(requesting shared memory access) and
BGWORKER_BACKEND_DATABASE_CONNECTION
(requesting the ability to establish a database
connection, through which it can later run transactions and queries). A background worker using
BGWORKER_BACKEND_DATABASE_CONNECTION
to connect to a database must also attach shared
memory using
BGWORKER_SHMEM_ACCESS
,or worker start-up will fail.
bgw_start_time
is the server state during which
postgres
should start the process; it can be
one of
BgWorkerStart_PostmasterStart
(start as soon as
postgres
itself has finished
1189
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
add jpg to pdf online; adding an image to a pdf in preview
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
add a picture to a pdf; adding images to pdf
Chapter 45. Background Worker Processes
its own initialization; processes requesting this are not eligible for database connections),
BgWorkerStart_ConsistentState
(start as soon as a consistent state has been reached
in a hot standby, allowing processes to connect to databases and run read-only queries), and
BgWorkerStart_RecoveryFinished
(start as soon as the system has entered normal read-write
state). Note the last two values are equivalent in a server that’s not a hot standby. Note that this
setting only indicates when the processes are to be started; they do not stop when a different state is
reached.
bgw_restart_time
is the interval, in seconds, that
postgres
should wait before restarting the
process, in case it crashes. It can be any positive value, or
BGW_NEVER_RESTART
,indicating not to
restart the process in case of a crash.
bgw_main
is a pointer to the function to run when the process is started. This function must take a
single argumentof type
Datum
and return
void
.
bgw_main_arg
will be passed to it as its onlyargu-
ment. Note that the global variable
MyBgworkerEntry
points to a copy of the
BackgroundWorker
structure passed at registration time.
bgw_main
may be NULL; in that case,
bgw_library_name
and
bgw_function_name
will be used to determine the entry point. This is useful for background
workers launched after postmaster startup, where the postmaster does not have the requisite library
loaded.
bgw_library_name
is the name of a library in which the initial entry point for the background
worker should be sought. It is ignored unless
bgw_main
is NULL. But if
bgw_main
is NULL, then
the named library will be dynamically loaded by the worker process and
bgw_function_name
will
be used to identify the function to be called.
bgw_function_name
is the name of a function in a dynamically loaded library which should be
used as the initial entry point for a new background worker. It is ignored unless
bgw_main
is NULL.
bgw_notify_pid
is the PID of a PostgreSQL backend process to which the postmaster should send
SIGUSR1
when the process is started or exits. It should be 0 for workers registered at postmaster
startup time, or when the backend registering the worker does not wish to wait for the worker to start
up. Otherwise, it should be initialized to
MyProcPid
.
Once
running,
the
process
can
connect
to
a
database
by
calling
BackgroundWorkerInitializeConnection(
char
*
dbname
,
char
*
username
)
. This allows
the process to run transactions andqueries using the
SPI
interface. If
dbname
is NULL, the sessionis
notconnectedto any particular database, but sharedcatalogs can be accessed. If
username
is NULL,
the process willrun as the superuser created during
initdb
.BackgroundWorkerInitializeConnection
can only be called once per background process, it is not possible to switch databases.
Signals are initially blocked when control reaches the
bgw_main
function, and must be unblocked
by it; this is to allow the process to customize its signal handlers, if necessary. Signals can be un-
blockedinthenew process bycalling
BackgroundWorkerUnblockSignals
andblocked bycalling
BackgroundWorkerBlockSignals
.
If
bgw_restart_time
for a background worker is configured as
BGW_NEVER_RESTART
,or if it
exits with an exit code of 0 or is terminated by
TerminateBackgroundWorker
,it will be auto-
matically unregistered by the postmaster on exit. Otherwise, it will be restarted after the time period
configured via
bgw_restart_time
,or immediately if the postmaster reinitializes the cluster due
to a backend failure. Backends which need to suspend execution only temporarily should use an
interruptible sleep rather than exiting; this can be achieved by calling
WaitLatch()
.Make sure the
WL_POSTMASTER_DEATH
flagissetwhencallingthat function, andverifythe returncode for a prompt
exit in the emergency case that
postgres
itself has terminated.
When a background worker is registered using the
RegisterDynamicBackgroundWorker
function, it is possible for the backend performing the registration to obtain
information regarding the status of the worker. Backends wishing to do this should
1190
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
adding an image to a pdf form; add image to pdf file acrobat
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
how to add a picture to a pdf document; add image to pdf online
Chapter 45. Background Worker Processes
pass the address of a
BackgroundWorkerHandle
*
as the second argument to
RegisterDynamicBackgroundWorker
. If
the
worker
is
successfully
registered,
this pointer will be initialized with an opaque handle that can subsequently be
passed
to
GetBackgroundWorkerPid(
BackgroundWorkerHandle
*
,
pid_t
*
)
or
TerminateBackgroundWorker(
BackgroundWorkerHandle
*
)
.
GetBackgroundWorkerPid
can
be usedto poll the status of the worker: a returnvalue of
BGWH_NOT_YET_STARTED
indicates that the
worker has not yet been started by the postmaster;
BGWH_STOPPED
indicates that it has been started
but is no longer running; and
BGWH_STARTED
indicates that it is currently running. In this last case,
the PID will also be returned via the second argument.
TerminateBackgroundWorker
causes the
postmaster to send
SIGTERM
to the worker if it is running, and tounregister it as soon as it is not.
In some cases, a process which registers a background worker may wish to wait for the worker
to start up. This can be accomplished by initializing
bgw_notify_pid
to
MyProcPid
and then passing the
BackgroundWorkerHandle
*
obtained at registration time to
WaitForBackgroundWorkerStartup(
BackgroundWorkerHandle
*
handle
,
pid_t
*
)
function.
This function will block until the postmaster has attempted to start the background worker, or until
the postmaster dies. If the background runner is running, the return value will
BGWH_STARTED
,and
the PID will be written to the provided address. Otherwise, the return value will be
BGWH_STOPPED
or
BGWH_POSTMASTER_DIED
.
The
worker_spi
contrib module contains aworkingexample, which demonstrates someuseful tech-
niques.
The maximum number of registered background workers is limited by max_worker_processes.
1191
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
attach image to pdf form; add image to pdf preview
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
adding an image to a pdf in acrobat; add photo to pdf file
Chapter 46. Logical Decoding
PostgreSQL provides infrastructure to stream the modifications performed via SQL to external con-
sumers. This functionality can beused to for a variety of purposes, includingreplication solutions and
auditing.
Changes are sent out in streams identified by logical replication slots. Each stream outputs each
change exactly once.
The formatin which those changes are streamed is determinedby the output plugin used. Anexample
plugin is provided in the PostgreSQL distribution. Additional plugins can be written to extend the
choice of available formats without modifying any core code. Every output plugin has access to each
individual new rowproduced by
INSERT
and the new rowversioncreated by
UPDATE
.Availability of
old row versions for
UPDATE
and
DELETE
depends on the configured replica identity (see
REPLICA
IDENTITY
).
Changes can be consumed either using the streaming replication protocol (see Section 49.3 and Sec-
tion 46.3), or by calling functions via SQL (see Section 46.4). It is also possible to write additional
methods of consumingtheoutput of a replicationslotwithout modifying corecode(seeSection46.7).
46.1. Logical Decoding Examples
The following example demonstrates controlling logical decoding using the SQL interface.
Before you can use logical decoding, you must set wal_level to
logical
and max_replication_slots
to at least 1. Then, you should connect to the target database (in the example below,
postgres
)as a
superuser.
postgres=# -- Create a slot named ’regression_slot’ using the output plugin ’test_decoding’
postgres=# SELECT
*
FROM pg_create_logical_replication_slot(’regression_slot’, ’test_decoding’);
slot_name
| xlog_position
-----------------+---------------
regression_slot | 0/16B1970
(1 row)
postgres=# SELECT
*
FROM pg_replication_slots;
slot_name
|
plugin
| slot_type | datoid | database | active |
xmin
| catalog_xmin | restart_lsn
-----------------+---------------+-----------+--------+----------+--------+--------+--------------+-------------
regression_slot | test_decoding | logical
|
12052 | postgres | f
|
|
(1 row)
postgres=# -- There are no changes to see yet
postgres=# SELECT
*
FROM pg_logical_slot_get_changes(’regression_slot’, NULL, NULL);
location | xid | data
----------+-----+------
(0 rows)
postgres=# CREATE TABLE data(id serial primary key, data text);
CREATE TABLE
postgres=# -- DDL isn’t replicated, so all you’ll see is the transaction
postgres=# SELECT
*
FROM pg_logical_slot_get_changes(’regression_slot’, NULL, NULL);
location
| xid |
data
-----------+-----+------------
0/16D5D48 | 688 | BEGIN 688
1192
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.
add an image to a pdf; add an image to a pdf form
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 a png to a pdf; how to add image to pdf acrobat
Chapter 46. Logical Decoding
0/16E0380 | 688 | COMMIT 688
(2 rows)
postgres=# -- Once changes are read, they’re consumed and not emitted
postgres=# -- in a subsequent call:
postgres=# SELECT
*
FROM pg_logical_slot_get_changes(’regression_slot’, NULL, NULL);
location | xid | data
----------+-----+------
(0 rows)
postgres=# BEGIN;
postgres=# INSERT INTO data(data) VALUES(’1’);
postgres=# INSERT INTO data(data) VALUES(’2’);
postgres=# COMMIT;
postgres=# SELECT
*
FROM pg_logical_slot_get_changes(’regression_slot’, NULL, NULL);
location
| xid |
data
-----------+-----+-----------------------------------------------
0/16E0478 | 689 | BEGIN 689
0/16E0478 | 689 | table public.data: INSERT: id[integer]:1 data[text]:’1’
0/16E0580 | 689 | table public.data: INSERT: id[integer]:2 data[text]:’2’
0/16E0650 | 689 | COMMIT 689
(4 rows)
postgres=# INSERT INTO data(data) VALUES(’3’);
postgres=# -- You can also peek ahead in the change stream without consuming changes
postgres=# SELECT
*
FROM pg_logical_slot_peek_changes(’regression_slot’, NULL, NULL);
location
| xid |
data
-----------+-----+-----------------------------------------------
0/16E09C0 | 690 | BEGIN 690
0/16E09C0 | 690 | table public.data: INSERT: id[integer]:3 data[text]:’3’
0/16E0B90 | 690 | COMMIT 690
(3 rows)
postgres=# -- The next call to pg_logical_slot_peek_changes() returns the same changes again
postgres=# SELECT
*
FROM pg_logical_slot_peek_changes(’regression_slot’, NULL, NULL);
location
| xid |
data
-----------+-----+-----------------------------------------------
0/16E09C0 | 690 | BEGIN 690
0/16E09C0 | 690 | table public.data: INSERT: id[integer]:3 data[text]:’3’
0/16E0B90 | 690 | COMMIT 690
(3 rows)
postgres=# -- options can be passed to output plugin, to influence the formatting
postgres=# SELECT
*
FROM pg_logical_slot_peek_changes(’regression_slot’, NULL, NULL, ’include-timestamp’, ’on’);
location
| xid |
data
-----------+-----+-----------------------------------------------
0/16E09C0 | 690 | BEGIN 690
0/16E09C0 | 690 | table public.data: INSERT: id[integer]:3 data[text]:’3’
0/16E0B90 | 690 | COMMIT 690 (at 2014-02-27 16:41:51.863092+01)
(3 rows)
postgres=# -- Remember to destroy a slot you no longer need to stop it consuming
postgres=# -- server resources:
postgres=# SELECT pg_drop_replication_slot(’regression_slot’);
pg_drop_replication_slot
1193
Chapter 46. Logical Decoding
-----------------------
(1 row)
The following example shows how logical decoding is controlled over the streaming replication
protocol, using the program pg_recvlogical included in the PostgreSQL distribution. This requires
that client authentication is set up to allow replication connections (see Section 25.2.5.1) and that
max_wal_senders
is set sufficiently high to allowan additional connection.
$ pg_recvlogical -d postgres --slot test --create-slot
$ pg_recvlogical -d postgres --slot test --start -f -
Control+Z
$ psql -d postgres -c "INSERT INTO data(data) VALUES(’4’);"
$ fg
BEGIN 693
table public.data: INSERT: id[integer]:4 data[text]:’4’
COMMIT 693
Control+C
$ pg_recvlogical -d postgres --slot test --drop-slot
46.2. Logical Decoding Concepts
46.2.1. Logical Decoding
Logical decoding is the process of extracting all persistent changes toa database’s tables into acoher-
ent, easy to understand format which can be interpreted without detailed knowledge of the database’s
internal state.
In PostgreSQL, logical decoding is implemented by decoding the contents of the write-ahead log,
which describe changes on a storage level, intoan application-specific form such as a stream of tuples
or SQL statements.
46.2.2. Replication Slots
In the context of logical replication, a slot represents a stream of changes that can be replayed to a
client in the order they were made on the origin server. Each slot streams a sequence of changes from
asingle database, sending each change exactly once (except whenpeeking forward in the stream).
Note: PostgreSQL also has streaming replication slots (see Section 25.2.5), but they are used
somewhat differently there.
Areplication slot has an identifier that is unique across all databases in a PostgreSQL cluster. Slots
persist independently of the connection using them and are crash-safe.
Multiple independent slots may exist for a single database. Each slot has its own state, allowing
different consumers to receive changes from different points in the database change stream. For most
applications, a separate slot will be required for each consumer.
Alogical replication slot knows nothing about the state of the receiver(s). It’s even possible to have
multipledifferentreceiversusingthe same slotat different times; they’ll just getthechanges following
1194
Chapter 46. Logical Decoding
on from when the last receiver stopped consuming them. Only one receiver may consume changes
from a slot at anygiven time.
Note: Replication slots persist across crashes and know nothing about the state of their con-
sumer(s). They will prevent removal of required resources even when there is no connection
using them. This consumes storage because neither required WAL nor required rows from the
system catalogs canbe removed by
VACUUM
as long as they are required by a replication slot. So
if a slot is no longer required it should be dropped.
46.2.3. Output Plugins
Output plugins transform the data from the write-ahead log’s internal representation into the format
the consumer of a replication slot desires.
46.2.4. Exported Snapshots
When a newreplication slot is createdusingthe streamingreplication interface, a snapshotis exported
(see Section 9.26.5), which will show exactly the state of the database after which all changes will be
includedin the change stream. This can be used to create a newreplica by using
SET TRANSACTION
SNAPSHOT
to read the state of the database at the moment the slot was created. This transaction can
thenbe usedto dumpthe database’s state atthatpoint intime, which afterwards can be updatedusing
the slot’s contents without losing any changes.
46.3. Streaming Replication Protocol Interface
The commands
CREATE_REPLICATION_SLOT
slot_name
LOGICAL
output_plugin
DROP_REPLICATION_SLOT
slot_name
START_REPLICATION SLOT
slot_name
LOGICAL ...
are used to create, drop, and stream changes from a replication slot, respectively. These commands
are only available over a replication connection; they cannot be used via SQL. See Section 49.3 for
details on these commands.
The command pg_recvlogical can be used to control logical decoding over a streaming replication
connection. (It uses these commands internally.)
46.4. Logical Decoding SQL Interface
See Section 9.26.6 for detailed documentation on the SQL-level API for interacting with logical
decoding.
1195
Chapter 46. Logical Decoding
Synchronous replication (see Section 25.2.8) is only supported on replication slots used over the
streaming replication interface. The function interface and additional, non-core interfaces do not sup-
port synchronous replication.
46.5. System Catalogs Related to Logical Decoding
The
pg_replication_slots
view and the
pg_stat_replication
view provide information
about the current state of replication slots and streaming replication connections respectively. These
views apply to both physical and logical replication.
46.6. Logical Decoding Output Plugins
An example output plugin can be found in the
contrib/test_decoding
subdirectory of the
PostgreSQL source tree.
46.6.1. Initialization Function
An output plugin is loaded by dynamically loading a shared library with the output plugin’s name
as the library base name. The normal library search path is used to locate the library. To provide the
required output plugin callbacks and to indicate that the library is actually an output plugin it needs
to provide a function named
_PG_output_plugin_init
.This function is passed a struct that needs
to be filled withthe callback function pointers for individual actions.
typedef struct OutputPluginCallbacks
{
LogicalDecodeStartupCB startup_cb;
LogicalDecodeBeginCB begin_cb;
LogicalDecodeChangeCB change_cb;
LogicalDecodeCommitCB commit_cb;
LogicalDecodeShutdownCB shutdown_cb;
} OutputPluginCallbacks;
typedef void (
*
LogicalOutputPluginInit)(struct OutputPluginCallbacks
*
cb);
The
begin_cb
,
change_cb
and
commit_cb
callbacks are required, while
startup_cb
and
shutdown_cb
are optional.
46.6.2. Capabilities
To decode, format and output changes, output plugins can use most of the backend’s normal infras-
tructure, including calling output functions. Read onlyaccess to relations is permitted as long as only
relations are accessed that either have been created by
initdb
in the
pg_catalog
schema, or have
been marked as user provided catalog tables using
ALTER TABLE user_catalog_table SET (user_catalog_table = true);
CREATE TABLE another_catalog_table(data text) WITH (user_catalog_table = true);
Any actions leadingto transaction ID assignmentareprohibited. That, among others, includes writing
to tables, performing DDL changes, and calling
txid_current()
.
1196
Chapter 46. Logical Decoding
46.6.3. Output Modes
Output plugin callbacks can pass data to the consumer in nearly arbitrary formats. For some
use cases, like viewing the changes via SQL, returning data in a data type that can contain
arbitrary data (e.g.,
bytea
)is cumbersome. If the output plugin only outputs textual data in the
server’s encoding, it can declare that by setting
OutputPluginOptions.output_mode
to
OUTPUT_PLUGIN_TEXTUAL_OUTPUT
instead of
OUTPUT_PLUGIN_BINARY_OUTPUT
in the startup
callback. In that case, all the data has to be in the server’s encodingso that a
text
datum can contain
it. This is checked in assertion-enabled builds.
46.6.4. Output Plugin Callbacks
An output plugin gets notified about changes that are happening via various callbacks it needs to
provide.
Concurrent transactions are decoded in commit order, andonly changes belonging to a specific trans-
action are decoded between the
begin
and
commit
callbacks. Transactions that were rolled back
explicitly or implicitly never get decoded. Successful savepoints are folded into the transaction con-
taining them in the order they were executed within that transaction.
Note: Only transactions that have already safely been flushed to disk will be decoded.
That can lead to a
COMMIT
not immediately being decoded in a directly following
pg_logical_slot_get_changes()
when
synchronous_commit
is set to
off
.
46.6.4.1. Startup Callback
The optional
startup_cb
callbackis called whenever a replication slot is created or asked to stream
changes, independent of the number of changes that are ready to be put out.
typedef void (
*
LogicalDecodeStartupCB) (
struct LogicalDecodingContext
*
ctx,
OutputPluginOptions
*
options,
bool is_init
);
The
is_init
parameter will be true when the replication slot is being created and false otherwise.
options
points to a struct of options that output plugins can set:
typedef struct OutputPluginOptions
{
OutputPluginOutputType output_type;
} OutputPluginOptions;
output_type
has
to
either be
set to
OUTPUT_PLUGIN_TEXTUAL_OUTPUT
or
OUTPUT_PLUGIN_BINARY_OUTPUT
.See also Section 46.6.3.
The startup callback should validate the options present in
ctx->output_plugin_options
.If the
output plugin needs to have a state, it can use
ctx->output_plugin_private
to store it.
1197
Documents you may be interested
Documents you may be interested