pdf viewer dll for c# : Adding image to pdf in preview Library control component .net web page asp.net mvc postgresql-9.4-A4117-part2743

Chapter 41. PL/Tcl - Tcl Procedural Language
INSERT {
set NEW($1) 0
}
UPDATE {
set NEW($1) $OLD($1)
incr NEW($1)
}
default {
return OK
}
}
return [array get NEW]
$$ LANGUAGE pltcl;
CREATE TABLE mytab (num integer, description text, modcnt integer);
CREATE TRIGGER trig_mytab_modcount BEFORE INSERT OR UPDATE ON mytab
FOR EACH ROW EXECUTE PROCEDURE trigfunc_modcount(’modcnt’);
Notice that the trigger procedure itself does not know the column name; that’s supplied from the
trigger arguments. This lets the trigger procedure be reused with different tables.
41.7. Event Trigger Procedures in PL/Tcl
Event trigger procedures can be written in PL/Tcl. PostgreSQL requires that a procedure that is to
be called as an event trigger must be declared as a function with no arguments and a return type of
event_trigger
.
The information from thetrigger manager is passedto the procedure bodyin the following variables:
$TG_event
The name of the event the trigger is fired for.
$TG_tag
The command tag for which the trigger is fired.
The return value of the trigger procedure is ignored.
Here’s a little example event trigger procedure that simply raises a
NOTICE
message each time a
supported command is executed:
CREATE OR REPLACE FUNCTION tclsnitch() RETURNS event_trigger AS $$
elog NOTICE "tclsnitch: $TG_event $TG_tag"
$$ LANGUAGE pltcl;
CREATE EVENT TRIGGER tcl_a_snitch ON ddl_command_start EXECUTE PROCEDURE tclsnitch();
1098
Adding image to 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 image to pdf acrobat; add picture to pdf file
Adding image to 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
adding images to pdf; add an image to a pdf with acrobat
Chapter 41. PL/Tcl - Tcl Procedural Language
41.8. Modules and the
unknown
Command
PL/Tcl has support for autoloading Tcl code when used. It recognizes a special table,
pltcl_modules
,which is presumed to contain modules of Tcl code. If this table exists, the module
unknown
is fetched from the table and loaded into the Tcl interpreter immediately before the first
execution of a PL/Tcl function in a database session. (This happens separately for each Tcl
interpreter, if more than one is used in a session; see Section 41.4.)
While the
unknown
module could actually contain any initialization script you need, it normally de-
fines a Tcl
unknown
procedure that is invokedwhenever Tcl does notrecognize aninvoked procedure
name. PL/Tcl’s standard version of this procedure tries to find a module in
pltcl_modules
thatwill
define the requiredprocedure. If one is found, it is loaded intothe interpreter, andthenexecutionis al-
lowed to proceed with the originally attempted procedure call. A secondary table
pltcl_modfuncs
provides an index of which functions are defined by which modules, so that the lookup is reasonably
quick.
The PostgreSQL distribution includes support scripts to maintain these tables:
pltcl_loadmod
,
pltcl_listmod
,
pltcl_delmod
, as well as source for the standard
unknown
module in
share/unknown.pltcl
.This module must be loaded into each database initially to support the
autoloading mechanism.
The tables
pltcl_modules
and
pltcl_modfuncs
must be readable by all, but it is wise to make
them owned and writable only by the database administrator. As a security precaution, PL/Tcl will
ignore
pltcl_modules
(and thus, not attempt to load the
unknown
module) unless it is owned
by a superuser. But update privileges on this table can be granted to other users, if you trust them
sufficiently.
41.9. Tcl Procedure Names
In PostgreSQL, the same function name can be used for different function definitions as long as the
number of arguments or their types differ. Tcl, however, requires all procedure names to be distinct.
PL/Tcl deals with this by making the internal Tcl procedure names contain the object ID of the
function from the system table
pg_proc
as part of their name. Thus, PostgreSQL functions with the
same name and different argument types will be different Tcl procedures, too. This is not normally a
concern for a PL/Tcl programmer, but it might be visible when debugging.
1099
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 image to pdf online; add a jpg to a pdf
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 picture to pdf reader; adding a jpg to a pdf
Chapter 42. PL/Perl - Perl Procedural
Language
PL/Perl is a loadable procedural language that enables you to write PostgreSQL functions in the Perl
programming language
1
.
The main advantage to using PL/Perl is that this allows use, within stored functions, of the manyfold
“string munging” operators and functions available for Perl. Parsing complex strings might be easier
using Perl than it is with the string functions and control structures provided in PL/pgSQL.
To install PL/Perl in a particular database, use
CREATE EXTENSION plperl
,or from the shell com-
mand line use
createlang plperl
dbname
.
Tip: If a language is installed into
template1
,all subsequently created databases will have the
languageinstalled automatically.
Note: Users of source packages must specially enable the build of PL/Perl during the installation
process. (Refer to Chapter 15 for more information.) Users of binary packages might find PL/Perl
in a separate subpackage.
42.1. PL/Perl Functions and Arguments
To create a function in the PL/Perl language, use the standard CREATE FUNCTION syntax:
CREATE FUNCTION
funcname
(
argument-types
) RETURNS
return-type
AS $$
# PL/Perl function body
$$ LANGUAGE plperl;
The body of the function is ordinary Perl code. In fact, the PL/Perl glue code wraps it inside a Perl
subroutine. A PL/Perl function is called in a scalar context, so it can’t return a list. You can return
non-scalar values (arrays, records, and sets) by returning a reference, as discussed below.
PL/Perl also supports anonymous code blocks called with the DO statement:
DO $$
# PL/Perl code
$$ LANGUAGE plperl;
An anonymous code block receives no arguments, and whatever value it might return is discarded.
Otherwise it behaves just like a function.
Note: The use of named nested subroutines is dangerous in Perl, especially if they refer to lex-
ical variables in the enclosing scope. Because a PL/Perl function is wrapped in a subroutine,
any named subroutine you place inside one will be nested. In general, it is far safer to create
anonymous subroutines which you call via a coderef. For more information, see the entries for
Variable "%s" will not stay shared
and
Variable "%s" is not available
in the perl-
diag man page, or search the Internet for “perl nested named subroutine”.
1. http://www.perl.org
1100
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
how to add image to pdf in preview; add signature image to pdf
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.
add a picture to a pdf; how to add an image to a pdf file in acrobat
Chapter 42. PL/Perl - Perl Procedural Language
The syntax of the
CREATE FUNCTION
command requires the function body to be written as a string
constant. It is usually most convenient to use dollar quoting (see Section 4.1.2.4) for the string con-
stant. If you choose to use escape string syntax
E”
,you must double any single quote marks (
)and
backslashes (
\
)used in the body of the function (see Section 4.1.2.1).
Arguments and results are handled as in any other Perl subroutine: arguments are passed in
@_
,and a
result value is returned with
return
or as the last expression evaluated in the function.
For example, a function returning the greater of two integer values could be defined as:
CREATE FUNCTION perl_max (integer, integer) RETURNS integer AS $$
if ($_[0] > $_[1]) { return $_[0]; }
return $_[1];
$$ LANGUAGE plperl;
Note: Arguments will beconverted from thedatabase’s encoding to UTF-8 for use inside PL/Perl,
and then converted from UTF-8 back to the database encoding upon return.
If an SQL null value is passed to a function, the argument value will appear as “undefined” in Perl.
The above functiondefinitionwill notbehavevery nicelywith nullinputs (infact, itwill actas though
they are zeroes). We could add
STRICT
to the function definition to make PostgreSQL do something
more reasonable: if a null value is passed, the function will not be called at all, but will just return a
null result automatically. Alternatively, we couldcheckfor undefined inputs in the function body. For
example, suppose that we wanted
perl_max
with one null and one nonnull argument to return the
nonnull argument, rather than a null value:
CREATE FUNCTION perl_max (integer, integer) RETURNS integer AS $$
my ($x, $y) = @_;
if (not defined $x) {
return undef if not defined $y;
return $y;
}
return $x if not defined $y;
return $x if $x > $y;
return $y;
$$ LANGUAGE plperl;
As shown above, to returnan SQL null value from a PL/Perlfunction, return anundefined value. This
can be done whether the function is strict or not.
Anything in a function argument that is not a reference is a string, which is in the standard Post-
greSQL external text representation for the relevant data type. In the case of ordinary numeric or text
types, Perl will just do the right thing and the programmer will normally not have to worry about it.
However, in other cases the argument will need to be converted into a form that is more usable in
Perl. For example, the
decode_bytea
function can be used to convert an argument of type
bytea
into unescaped binary.
Similarly, values passed back to PostgreSQL must be in the external text representation format. For
example, the
encode_bytea
function can be used to escape binary data for a return value of type
bytea
.
Perl can return PostgreSQL arrays as references to Perl arrays. Here is an example:
CREATE OR REPLACE function returns_array()
1101
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 image to pdf reader; add image to pdf in preview
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 a picture to a pdf file; add an image to a pdf acrobat
Chapter 42. PL/Perl - Perl Procedural Language
RETURNS text[][] AS $$
return [[’a"b’,’c,d’],[’e\\f’,’g’]];
$$ LANGUAGE plperl;
select returns_array();
Perl passes PostgreSQL arrays as a blessed
PostgreSQL::InServer::ARRAY
object. This object
may be treated as an array reference or a string, allowing for backward compatibility with Perl code
written for PostgreSQL versions below 9.1 to run. For example:
CREATE OR REPLACE FUNCTION concat_array_elements(text[]) RETURNS TEXT AS $$
my $arg = shift;
my $result = "";
return undef if (!defined $arg);
# as an array reference
for (@$arg) {
$result .= $_;
}
# also works as a string
$result .= $arg;
return $result;
$$ LANGUAGE plperl;
SELECT concat_array_elements(ARRAY[’PL’,’/’,’Perl’]);
Note: Multidimensional arrays are represented as references to lower-dimensional arrays of ref-
erences in a way common to every Perl programmer.
Composite-type arguments are passed to the function as references to hashes. The keys of the hash
are the attribute names of the composite type. Here is an example:
CREATE TABLE employee (
name text,
basesalary integer,
bonus integer
);
CREATE FUNCTION empcomp(employee) RETURNS integer AS $$
my ($emp) = @_;
return $emp->{basesalary} + $emp->{bonus};
$$ LANGUAGE plperl;
SELECT name, empcomp(employee.
*
) FROM employee;
APL/Perl function can return a composite-type result using the same approach: return a reference to
ahash that has the required attributes. For example:
1102
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
pdf insert image; add photo to pdf
C# PowerPoint - Insert Blank PowerPoint Page in C#.NET
This C# .NET PowerPoint document page inserting & adding component from RasterEdge is written in managed C# code and designed particularly for .NET class
add an image to a pdf; adding an image to a pdf in preview
Chapter 42. PL/Perl - Perl Procedural Language
CREATE TYPE testrowperl AS (f1 integer, f2 text, f3 text);
CREATE OR REPLACE FUNCTION perl_row() RETURNS testrowperl AS $$
return {f2 => ’hello’, f1 => 1, f3 => ’world’};
$$ LANGUAGE plperl;
SELECT
*
FROM perl_row();
Any columns in the declared result data type that are not present in the hash will be returned as null
values.
PL/Perl functions can also return sets of either scalar or composite types. Usually you’ll want to
return rows one at a time, both to speed up startup time and to keep from queuing up the entire
result set in memory. You can do this with
return_next
as illustrated below. Note thatafter the last
return_next
,you must put either
return
or (better)
return undef
.
CREATE OR REPLACE FUNCTION perl_set_int(int)
RETURNS SETOF INTEGER AS $$
foreach (0..$_[0]) {
return_next($_);
}
return undef;
$$ LANGUAGE plperl;
SELECT
*
FROM perl_set_int(5);
CREATE OR REPLACE FUNCTION perl_set()
RETURNS SETOF testrowperl AS $$
return_next({ f1 => 1, f2 => ’Hello’, f3 => ’World’ });
return_next({ f1 => 2, f2 => ’Hello’, f3 => ’PostgreSQL’ });
return_next({ f1 => 3, f2 => ’Hello’, f3 => ’PL/Perl’ });
return undef;
$$ LANGUAGE plperl;
For small result sets, you can return a reference to an array that contains either scalars, references to
arrays, or references to hashes for simple types, array types, and composite types, respectively. Here
are some simple examples of returning the entire result set as an array reference:
CREATE OR REPLACE FUNCTION perl_set_int(int) RETURNS SETOF INTEGER AS $$
return [0..$_[0]];
$$ LANGUAGE plperl;
SELECT
*
FROM perl_set_int(5);
CREATE OR REPLACE FUNCTION perl_set() RETURNS SETOF testrowperl AS $$
return [
{ f1 => 1, f2 => ’Hello’, f3 => ’World’ },
{ f1 => 2, f2 => ’Hello’, f3 => ’PostgreSQL’ },
{ f1 => 3, f2 => ’Hello’, f3 => ’PL/Perl’ }
];
$$ LANGUAGE plperl;
SELECT
*
FROM perl_set();
If you wish to use the
strict
pragma with your code you have a few options. For temporary global
use you can
SET plperl.use_strict
to true. This will affect subsequent compilations of PL/Perl
1103
Chapter 42. PL/Perl - Perl Procedural Language
functions, but not functions already compiled in the current session. For permanent global use you
can set
plperl.use_strict
to true in the
postgresql.conf
file.
For permanent use in specific functions you can simply put:
use strict;
at the top of the function body.
The
feature
pragma is also available to
use
if your Perl is version 5.10.0 or higher.
42.2. Data Values in PL/Perl
The argument values supplied to a PL/Perl function’s code are simply the input arguments converted
to text form (just as if they had been displayed by a
SELECT
statement). Conversely, the
return
and
return_next
commands will accept anystring that is acceptable inputformat for the function’s
declared return type.
42.3. Built-in Functions
42.3.1. Database Access from PL/Perl
Access to the database itself from your Perl function can be done via the following functions:
spi_exec_query
(
query
[,
max-rows
])
spi_exec_query
executes an SQL command and returns the entire row set as a reference to
an array of hash references. You should only use this command when you know that the result
set will be relatively small. Here is an example of a query (
SELECT
command) with the optional
maximum number of rows:
$rv = spi_exec_query(’SELECT
*
FROM my_table’, 5);
This returns up to 5rows from the table
my_table
.If
my_table
has a column
my_column
,you
can get that value from row
$i
of the result like this:
$foo = $rv->{rows}[$i]->{my_column};
The total number of rows returned from a
SELECT
query can be accessed like this:
$nrows = $rv->{processed}
Here is an example using a different command type:
$query = "INSERT INTO my_table VALUES (1, ’test’)";
$rv = spi_exec_query($query);
You can then access the command status (e.g.,
SPI_OK_INSERT
)like this:
$res = $rv->{status};
To get the number of rows affected, do:
$nrows = $rv->{processed};
Here is a complete example:
CREATE TABLE test (
i int,
v varchar
);
1104
Chapter 42. PL/Perl - Perl Procedural Language
INSERT INTO test (i, v) VALUES (1, ’first line’);
INSERT INTO test (i, v) VALUES (2, ’second line’);
INSERT INTO test (i, v) VALUES (3, ’third line’);
INSERT INTO test (i, v) VALUES (4, ’immortal’);
CREATE OR REPLACE FUNCTION test_munge() RETURNS SETOF test AS $$
my $rv = spi_exec_query(’select i, v from test;’);
my $status = $rv->{status};
my $nrows = $rv->{processed};
foreach my $rn (0 .. $nrows - 1) {
my $row = $rv->{rows}[$rn];
$row->{i} += 200 if defined($row->{i});
$row->{v} =~ tr/A-Za-z/a-zA-Z/ if (defined($row->{v}));
return_next($row);
}
return undef;
$$ LANGUAGE plperl;
SELECT
*
FROM test_munge();
spi_query(
command
)
spi_fetchrow(
cursor
)
spi_cursor_close(
cursor
)
spi_query
and
spi_fetchrow
work together as a pair for row sets which might be large,
or for cases where you wish to return rows as they arrive.
spi_fetchrow
works only with
spi_query
.The following example illustrates how you use them together:
CREATE TYPE foo_type AS (the_num INTEGER, the_text TEXT);
CREATE OR REPLACE FUNCTION lotsa_md5 (INTEGER) RETURNS SETOF foo_type AS $$
use Digest::MD5 qw(md5_hex);
my $file = ’/usr/share/dict/words’;
my $t = localtime;
elog(NOTICE, "opening file $file at $t" );
open my $fh, ’<’, $file # ooh, it’s a file access!
or elog(ERROR, "cannot open $file for reading: $!");
my @words = <$fh>;
close $fh;
$t = localtime;
elog(NOTICE, "closed file $file at $t");
chomp(@words);
my $row;
my $sth = spi_query("SELECT
*
FROM generate_series(1,$_[0]) AS b(a)");
while (defined ($row = spi_fetchrow($sth))) {
return_next({
the_num => $row->{a},
the_text => md5_hex($words[rand @words])
});
}
return;
$$ LANGUAGE plperlu;
SELECT
*
from lotsa_md5(500);
Normally,
spi_fetchrow
should be repeated until it returns
undef
, indicating that there
are no more rows to read. The cursor returned by
spi_query
is automatically freed
1105
Chapter 42. PL/Perl - Perl Procedural Language
when
spi_fetchrow
returns
undef
. If you do not wish to read all the rows, instead call
spi_cursor_close
to free the cursor. Failure to do sowill result in memory leaks.
spi_prepare(
command
,
argument types
)
spi_query_prepared(
plan
,
arguments
)
spi_exec_prepared(
plan
[,
attributes
],
arguments
)
spi_freeplan(
plan
)
spi_prepare
,
spi_query_prepared
,
spi_exec_prepared
, and
spi_freeplan
implement the same functionality but for prepared queries.
spi_prepare
accepts a query
string withnumbered argument placeholders ($1, $2, etc) and a string list of argument types:
$plan = spi_prepare(’SELECT
*
FROM test WHERE id > $1 AND name = $2’,
’INTEGER’, ’TEXT’);
Once a query plan is prepared by a call to
spi_prepare
, the plan can be used instead of
the string query, either in
spi_exec_prepared
, where the result is the same as returned
by
spi_exec_query
, or in
spi_query_prepared
which returns a cursor exactly as
spi_query
does, which can be later passed to
spi_fetchrow
.The optional second parameter
to
spi_exec_prepared
is a hash reference of attributes; the only attribute currently supported
is
limit
,which sets the maximum number of rows returned by a query.
The advantage of prepared queries is that is it possible to use one prepared plan for more than
one query execution. After the planis notneeded anymore, it can be freed with
spi_freeplan
:
CREATE OR REPLACE FUNCTION init() RETURNS VOID AS $$
$_SHARED{my_plan} = spi_prepare(’SELECT (now() + $1)::date AS now’,
’INTERVAL’);
$$ LANGUAGE plperl;
CREATE OR REPLACE FUNCTION add_time( INTERVAL ) RETURNS TEXT AS $$
return spi_exec_prepared(
$_SHARED{my_plan},
$_[0]
)->{rows}->[0]->{now};
$$ LANGUAGE plperl;
CREATE OR REPLACE FUNCTION done() RETURNS VOID AS $$
spi_freeplan( $_SHARED{my_plan});
undef $_SHARED{my_plan};
$$ LANGUAGE plperl;
SELECT init();
SELECT add_time(’1 day’), add_time(’2 days’), add_time(’3 days’);
SELECT done();
add_time
|
add_time
|
add_time
------------+------------+------------
2005-12-10 | 2005-12-11 | 2005-12-12
Note that the parameter subscript in
spi_prepare
is definedvia $1, $2, $3, etc, so avoiddeclar-
ing query strings in double quotes that might easily lead to hard-to-catch bugs.
Another example illustrates usage of an optional parameter in
spi_exec_prepared
:
CREATE TABLE hosts AS SELECT id, (’192.168.1.’||id)::inet AS address
FROM generate_series(1,3) AS id;
CREATE OR REPLACE FUNCTION init_hosts_query() RETURNS VOID AS $$
$_SHARED{plan} = spi_prepare(’SELECT
*
FROM hosts
WHERE address << $1’, ’inet’);
1106
Chapter 42. PL/Perl - Perl Procedural Language
$$ LANGUAGE plperl;
CREATE OR REPLACE FUNCTION query_hosts(inet) RETURNS SETOF hosts AS $$
return spi_exec_prepared(
$_SHARED{plan},
{limit => 2},
$_[0]
)->{rows};
$$ LANGUAGE plperl;
CREATE OR REPLACE FUNCTION release_hosts_query() RETURNS VOID AS $$
spi_freeplan($_SHARED{plan});
undef $_SHARED{plan};
$$ LANGUAGE plperl;
SELECT init_hosts_query();
SELECT query_hosts(’192.168.1.0/30’);
SELECT release_hosts_query();
query_hosts
-----------------
(1,192.168.1.1)
(2,192.168.1.2)
(2 rows)
42.3.2. Utility Functions in PL/Perl
elog(
level
,
msg
)
Emit a log or error message. Possible levels are
DEBUG
,
LOG
,
INFO
,
NOTICE
,
WARNING
,and
ERROR
.
ERROR
raises an error condition; if this is not trapped by the surrounding Perl code,
the error propagates out to the calling query, causing the current transaction or subtransaction
to be aborted. This is effectively the same as the Perl
die
command. The other levels only
generate messages of different priority levels. Whether messages of a particular priority are re-
ported to the client, written to the server log, or bothis controlled by the log_min_messages and
client_min_messages configuration variables. See Chapter 18 for more information.
quote_literal(
string
)
Return the given string suitably quoted to be used as a string literal in an SQL statement string.
Embedded single-quotes and backslashes are properly doubled. Note that
quote_literal
re-
turns undef on undef input; if the argument might be undef,
quote_nullable
is often more
suitable.
quote_nullable(
string
)
Return the given string suitably quoted to be used as a string literal in an SQL statement string;
or, if the argument is undef, return the unquoted string "NULL". Embedded single-quotes and
backslashes are properly doubled.
quote_ident(
string
)
Return the given string suitably quoted to be used as an identifier in an SQL statement string.
Quotes are added only if necessary (i.e., if the string contains non-identifier characters or would
be case-folded). Embedded quotes are properly doubled.
1107
Documents you may be interested
Documents you may be interested