pdf viewer dll for c# : Add image to pdf java SDK control service wpf web page html dnn postgresql-9.4-A4119-part2745

Chapter 43. PL/Python- Python Procedural Language
43.3. Data Values
Generally speaking, the aim of PL/Python is to provide a “natural” mapping between the PostgreSQL
and the Python worlds. This informs the data mappingrules described below.
43.3.1. Data Type Mapping
Function arguments are converted from their PostgreSQL type to a corresponding Python type:
PostgreSQL
boolean
is converted to Python
bool
.
PostgreSQL
smallint
and
int
are converted to Python
int
.PostgreSQL
bigint
and
oid
are
converted to
long
in Python 2 and to
int
in Python 3.
PostgreSQL
real
and
double
are converted to Python
float
.
PostgreSQL
numeric
is convertedto Python
Decimal
.This type is imported from the
cdecimal
package if that is available. Otherwise,
decimal.Decimal
from the standard library will be used.
cdecimal
is significantly faster than
decimal
.In Python 3.3, however,
cdecimal
has been inte-
grated into the standard library under the name
decimal
,so there is no longer any difference.
PostgreSQL
bytea
is converted to Python
str
in Python 2 and to
bytes
in Python 3. In Python
2, the string should be treated as a byte sequence without any character encoding.
All other data types, including the PostgreSQL character string types, are converted to a Python
str
.In Python 2, this string will be in the PostgreSQL server encoding; in Python 3, it will be a
Unicode string like all strings.
For nonscalar data types, see below.
Function return values are converted to the declared PostgreSQL return data type as follows:
Whenthe PostgreSQL returntypeis
boolean
,the returnvaluewill be evaluatedfor truth according
to the Python rules. That is, 0 and emptystring are false, but notably
’f’
is true.
When the PostgreSQL return type is
bytea
,the return value will be converted to a string (Python
2) or bytes (Python3) using the respective Python built-ins, with the result being converted
bytea
.
For all other PostgreSQL return types, the returned Python value is converted to a string using the
Python built-in
str
,andthe result is passed to the input function of the PostgreSQL data type.
Strings in Python 2 are required to be in the PostgreSQL server encoding when they are passed
to PostgreSQL. Strings that are not valid in the current server encoding will raise an error, but not
all encoding mismatches can be detected, so garbage data can still result when this is not done
correctly. Unicode strings are converted to the correct encoding automatically, so it can be safer
and more convenient to use those. In Python 3, all strings are Unicode strings.
For nonscalar data types, see below.
Note that logical mismatches between the declared PostgreSQL return type and the Python data type
of the actual return object are not flagged; the value will be converted in any case.
1118
Add image to pdf java - 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 to pdf document; how to add an image to a pdf in reader
Add image to pdf java - 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 a pdf document; add an image to a pdf in preview
Chapter 43. PL/Python- Python Procedural Language
43.3.2. Null, None
If an SQL null value is passed to a function, the argument value will appear as
None
in Python. For
example, the function definition of
pymax
shown in Section 43.2 will return the wrong answer for
null inputs. 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 could check for null inputs in the function body:
CREATE FUNCTION pymax (a integer, b integer)
RETURNS integer
AS $$
if (a is None) or (b is None):
return None
if a > b:
return a
return b
$$ LANGUAGE plpythonu;
As shown above, toreturnan SQL null value from a PL/Python function, return the value
None
.This
can be done whether the function is strict or not.
43.3.3. Arrays, Lists
SQL array values are passed into PL/Python as a Python list. To return an SQL array value out of a
PL/Python function, return a Python sequence, for example a list or tuple:
CREATE FUNCTION return_arr()
RETURNS int[]
AS $$
return (1, 2, 3, 4, 5)
$$ LANGUAGE plpythonu;
SELECT return_arr();
return_arr
-------------
{1,2,3,4,5}
(1 row)
Note that in Python, strings are sequences, which can have undesirable effects that might be familiar
to Python programmers:
CREATE FUNCTION return_str_arr()
RETURNS varchar[]
AS $$
return "hello"
$$ LANGUAGE plpythonu;
SELECT return_str_arr();
return_str_arr
----------------
{h,e,l,l,o}
(1 row)
1119
Java Imaging SDK Library: Document Image Scan, Process, PDF
imaging solutions, allowing developers to add document and Using RasterEdge Java Image SDK, developers can easily open Tiff, Jpeg2000, DICOM, JBIG2, PDF, MS Word
how to add a jpg to a pdf; add image to pdf acrobat reader
Zero Footprint AJAX Document Image Viewer| ASP.NET Imaging SDK
Image Annotating Draw and add various text or graphics annotations on Converting Transform, convert and save web document or image file to PDF or TIFF
add image to pdf java; add png to pdf acrobat
Chapter 43. PL/Python- Python Procedural Language
43.3.4. Composite Types
Composite-type arguments are passed to the function as Python mappings. The element names of the
mapping are the attribute names of the composite type. If an attribute in the passed row has the null
value, it has the value
None
in the mapping. Here is an example:
CREATE TABLE employee (
name text,
salary integer,
age integer
);
CREATE FUNCTION overpaid (e employee)
RETURNS boolean
AS $$
if e["salary"] > 200000:
return True
if (e["age"] < 30) and (e["salary"] > 100000):
return True
return False
$$ LANGUAGE plpythonu;
There are multiple ways to return row or composite types from a Python function. The following
examples assume we have:
CREATE TYPE named_value AS (
name
text,
value
integer
);
Acomposite result can be returned as a:
Sequence type (a tuple or list, but not a set because it is not indexable)
Returned sequence objects must have the same number of items as the composite result type has
fields. The item with index 0 is assigned to the first field of the composite type, 1 to the second
andso on. For example:
CREATE FUNCTION make_pair (name text, value integer)
RETURNS named_value
AS $$
return [ name, value ]
# or alternatively, as tuple: return ( name, value )
$$ LANGUAGE plpythonu;
To return a SQL null for any column, insert
None
at the corresponding position.
Mapping (dictionary)
The value for each result type column is retrieved from the mapping with the column name as
key. Example:
CREATE FUNCTION make_pair (name text, value integer)
RETURNS named_value
AS $$
return { "name": name, "value": value }
$$ LANGUAGE plpythonu;
1120
DocImage SDK for .NET: HTML Viewer, View, Annotate, Convert, Print
in .NET, including Microsoft Word, Excel, PPT, PDF, Tiff, Dicom OCR .NET OCR Add-on provides you with powerful and of years before I found this .NET Image SDK.
add picture to pdf; add jpg to pdf acrobat
.NET PDF SDK | Read & Processing PDF files
by this .NET Imaging PDF Reader Add-on. and metadata; Advanced document cleanup and image processing options provides royalty-free .NET Imaging PDF Reader SDK
add signature image to pdf acrobat; how to add an image to a pdf in preview
Chapter 43. PL/Python- Python Procedural Language
Any extra dictionary key/value pairs are ignored. Missing keys are treated as errors. To return a
SQL null value for any column, insert
None
with the corresponding column name as the key.
Object (any object providing method
__getattr__
)
This works the same as a mapping. Example:
CREATE FUNCTION make_pair (name text, value integer)
RETURNS named_value
AS $$
class named_value:
def __init__ (self, n, v):
self.name = n
self.value = v
return named_value(name, value)
# or simply
class nv: pass
nv.name = name
nv.value = value
return nv
$$ LANGUAGE plpythonu;
Functions with
OUT
parameters are also supported. For example:
CREATE FUNCTION multiout_simple(OUT i integer, OUT j integer) AS $$
return (1, 2)
$$ LANGUAGE plpythonu;
SELECT
*
FROM multiout_simple();
43.3.5. Set-returning Functions
APL/Python function can also return sets of scalar or composite types. There are several ways to
achieve this because the returned object is internally turned into an iterator. The following examples
assume we have composite type:
CREATE TYPE greeting AS (
how text,
who text
);
Aset result can be returned from a:
Sequence type (tuple, list, set)
CREATE FUNCTION greet (how text)
RETURNS SETOF greeting
AS $$
# return tuple containing lists as composite types
# all other combinations work also
return ( [ how, "World" ], [ how, "PostgreSQL" ], [ how, "PL/Python" ] )
$$ LANGUAGE plpythonu;
1121
.NET PDF Generator | Generate & Manipulate PDF files
RasterEdge .NET Image SDK - PDF Generator. swap and delete any pages in PDFs; Add metadata of a RasterEdge provides royalty-free .NET Imaging PDF Generator of
add image field to pdf form; adding image to pdf
Image Converter | Convert Image, Document Formats
Can be used as an add-on for .NET Imaging SDK; support, like ASCII, PDF, HTML, MS- Word, PDF/A Most Find image converters to suit your needs in this following
adding an image to a pdf; how to add image to pdf form
Chapter 43. PL/Python- Python Procedural Language
Iterator (any object providing
__iter__
and
next
methods)
CREATE FUNCTION greet (how text)
RETURNS SETOF greeting
AS $$
class producer:
def __init__ (self, how, who):
self.how = how
self.who = who
self.ndx = -1
def __iter__ (self):
return self
def next (self):
self.ndx += 1
if self.ndx == len(self.who):
raise StopIteration
return ( self.how, self.who[self.ndx] )
return producer(how, [ "World", "PostgreSQL", "PL/Python" ])
$$ LANGUAGE plpythonu;
Generator (
yield
)
CREATE FUNCTION greet (how text)
RETURNS SETOF greeting
AS $$
for who in [ "World", "PostgreSQL", "PL/Python" ]:
yield ( how, who )
$$ LANGUAGE plpythonu;
Warning
Due to Python bug #14831334, some debug versions of Python 2.4
(configured and compiledwithoption
--with-pydebug
)areknown to
crash the PostgreSQL server when using an iterator to return a set
result. Unpatched versions of Fedora 4 contain this bug. It does not
happen in production versions of Python or on patched versions of
Fedora 4.
Set-returning functions with
OUT
parameters (using
RETURNS SETOF record
)are also supported.
For example:
CREATE FUNCTION multiout_simple_setof(n integer, OUT integer, OUT integer) RETURNS SETOF record AS $$
return [(1, 2)]
*
n
$$ LANGUAGE plpythonu;
SELECT
*
FROM multiout_simple_setof(3);
1122
.NET Annotation SDK| Annotate, Redact Images
object or group of annotation objects add-on; Save annotation into image files, separate annotation files NET Document Imaging SDK and Java Document Imaging
add image pdf acrobat; adding an image to a pdf file
.NET Barcode Generate SDK| Generate Barcodes
Support QR Code, Data Matrix, PDF-417; Seamless integrate into any Automatically add check digit for barcodes; High-usability image options provided to
add jpeg to pdf; add jpg to pdf form
Chapter 43. PL/Python- Python Procedural Language
43.4. Sharing Data
The global dictionary
SD
is available to store data between function calls. This variable is private
static data. The global dictionary
GD
is public data, available to all Python functions within a session.
Use with care.
Each function gets its own execution environment in the Python interpreter, so that global data and
function arguments from
myfunc
are not available to
myfunc2
.The exception is the data in the
GD
dictionary, as mentioned above.
43.5. Anonymous Code Blocks
PL/Python also supports anonymous code blocks called with the DOstatement:
DO $$
# PL/Python code
$$ LANGUAGE plpythonu;
An anonymous code block receives no arguments, and whatever value it might return is discarded.
Otherwise it behaves just like a function.
43.6. Trigger Functions
When a function is used as a trigger, the dictionary
TD
contains trigger-related values:
TD["event"]
contains the event as a string:
INSERT
,
UPDATE
,
DELETE
,or
TRUNCATE
.
TD["when"]
contains one of
BEFORE
,
AFTER
,or
INSTEAD OF
.
TD["level"]
contains
ROW
or
STATEMENT
.
TD["new"]
TD["old"]
For a row-level trigger, one or bothof these fields containthe respective trigger rows, depending
on the trigger event.
TD["name"]
contains the trigger name.
TD["table_name"]
contains the name of the table on which the trigger occurred.
TD["table_schema"]
contains the schema of the table on which the trigger occurred.
TD["relid"]
contains the OID of the table on which the trigger occurred.
1123
.NET Excel Document Add-on | Manipulate Excel File in .NET
to convert Excel to PNG, JPEG, BMP, and GIF image formats, and to TIFF, PDF and SVG functions of this DLL, .NET programmers also need to add .NET Basic DLL
add jpg signature to pdf; add jpeg signature to pdf
.NET Word Document Add-on DLL of RasterEdge DocImage SDK for .NET
any page of Word document to raster image file (PNG and convert Word to other documents, like PDF, TIFF and be ordered for using .NET Word Document Add-on for
how to add a photo to a pdf document; add jpg to pdf online
Chapter 43. PL/Python- Python Procedural Language
TD["args"]
If the
CREATE TRIGGER
command included arguments, they are available in
TD["args"][0]
to
TD["args"][
n
-1]
.
If
TD["when"]
is
BEFORE
or
INSTEAD OF
and
TD["level"]
is
ROW
, you can return
None
or
"OK"
from the Python function to indicate the row is unmodified,
"SKIP"
to abort the event, or if
TD["event"]
is
INSERT
or
UPDATE
you can return
"MODIFY"
to indicate you’ve modified the new
row. Otherwise the return value is ignored.
43.7. Database Access
The PL/Python language module automatically imports a Python module called
plpy
.The functions
and constants in this module are available to you in the Python code as
plpy.
foo
.
43.7.1. Database Access Functions
The
plpy
module provides several functions to execute database commands:
plpy.
execute
(
query
[,
max-rows
])
Calling
plpy.execute
witha query string and an optionalrowlimitargument causes that query
to be run and the result to be returned in a result object.
The result object emulates a list or dictionary object. The result object can be accessed by row
number and column name. For example:
rv = plpy.execute("SELECT
*
FROM my_table", 5)
returns up to 5 rows from
my_table
.If
my_table
has a column
my_column
, it would be
accessed as:
foo = rv[i]["my_column"]
The number of rows returned can be obtained using the built-in
len
function.
The result object has these additional methods:
nrows
()
Returns the number of rows processedby the command. Note that this is not necessarily the
same as the number of rows returned. For example, an
UPDATE
command will setthis value
but won’t return any rows (unless
RETURNING
is used).
status
()
The
SPI_execute()
return value.
colnames
()
coltypes
()
coltypmods
()
Return a list of column names, list of column type OIDs, and list of type-specific type
modifiers for the columns, respectively.
These methods raise an exception when called on a result object from a command that did
not produce a result set, e.g.,
UPDATE
without
RETURNING
,or
DROP TABLE
.But it is OK
to use these methods on a result set containing zerorows.
1124
Chapter 43. PL/Python- Python Procedural Language
__str__
()
The standard
__str__
method is defined so that it is possible for example to debug query
execution results using
plpy.debug(rv)
.
The result object can be modified.
Note that calling
plpy.execute
will cause the entire result set to be read into memory. Only
use that function when you are sure that the result set will be relatively small. If you don’t
want toriskexcessive memory usage when fetchinglarge results, use
plpy.cursor
rather than
plpy.execute
.
plpy.
prepare
(
query
[,
argtypes
])
plpy.
execute
(
plan
[,
arguments
[,
max-rows
]])
plpy.prepare
prepares the execution plan for a query. It is called with a query stringand a list
of parameter types, if you have parameter references in the query. For example:
plan = plpy.prepare("SELECT last_name FROM my_users WHERE first_name = $1", ["text"])
text
is the type of the variable you will be passing for
$1
.The second argument is optional if
you don’t want to pass any parameters to the query.
After preparing a statement, you use a variant of the function
plpy.execute
to run it:
rv = plpy.execute(plan, ["name"], 5)
Pass the plan as the first argument (instead of the query string), and a list of values to substitute
into the query as the second argument. The second argument is optional if the query does not
expect any parameters. The third argument is the optional row limit as before.
Queryparameters and resultrowfields are convertedbetweenPostgreSQL and Pythondata types
as described in Section 43.3. The exception is that composite types are currently not supported:
They will be rejected as queryparameters andare convertedtostrings whenappearing in a query
result. As a workaround for the latter problem, the query can sometimes be rewritten so that the
compositetype result appears as a resultrowrather than as a fieldof the resultrow. Alternatively,
the resultingstringcould be parsed apartbyhand, but this approachis not recommendedbecause
it is not future-proof.
When you prepare a plan using the PL/Python module it is automatically saved. Read the SPI
documentation (Chapter 44) for a description of what this means. In order to make effective use
of this across function calls one needs to use one of the persistent storage dictionaries
SD
or
GD
(see Section 43.4). For example:
CREATE FUNCTION usesavedplan() RETURNS trigger AS $$
if "plan" in SD:
plan = SD["plan"]
else:
plan = plpy.prepare("SELECT 1")
SD["plan"] = plan
# rest of function
$$ LANGUAGE plpythonu;
plpy.
cursor
(
query
)
plpy.
cursor
(
plan
[,
arguments
])
The
plpy.cursor
function accepts the same arguments as
plpy.execute
(except for the row
limit) andreturns a cursor object, which allows you toprocess large resultsets insmaller chunks.
As with
plpy.execute
,either a query string or a plan object alongwith a listof arguments can
be used.
1125
Chapter 43. PL/Python- Python Procedural Language
Thecursor object provides a
fetch
methodthataccepts an integer parameter andreturns a result
object. Each time you call
fetch
,the returned object will contain the next batch of rows, never
larger than the parameter value. Once all rows are exhausted,
fetch
starts returning an empty
result object. Cursor objects also provide an iterator interface
5
,yielding one row at a time until
all rows are exhausted. Data fetched that way is not returned as result objects, but rather as
dictionaries, each dictionary corresponding to a single result row.
An example of two ways of processing data from a large table is:
CREATE FUNCTION count_odd_iterator() RETURNS integer AS $$
odd = 0
for row in plpy.cursor("select num from largetable"):
if row[’num’] % 2:
odd += 1
return odd
$$ LANGUAGE plpythonu;
CREATE FUNCTION count_odd_fetch(batch_size integer) RETURNS integer AS $$
odd = 0
cursor = plpy.cursor("select num from largetable")
while True:
rows = cursor.fetch(batch_size)
if not rows:
break
for row in rows:
if row[’num’] % 2:
odd += 1
return odd
$$ LANGUAGE plpythonu;
CREATE FUNCTION count_odd_prepared() RETURNS integer AS $$
odd = 0
plan = plpy.prepare("select num from largetable where num % $1 <> 0", ["integer"])
rows = list(plpy.cursor(plan, [2]))
return len(rows)
$$ LANGUAGE plpythonu;
Cursors are automatically disposed of. But if you want toexplicitly release all resources held by
acursor, use the
close
method. Once closed, a cursor cannot be fetched from anymore.
Tip: Do not confuse objects created by
plpy.cursor
with DB-API cursors as defined by
thePython Database API specification6. They don’t have anything incommon except for the
name.
43.7.2. Trapping Errors
Functions accessing the database might encounter errors, which will cause them to abort and raise
an exception. Both
plpy.execute
and
plpy.prepare
can raise an instance of a subclass of
5. http://docs.python.org/library/stdtypes.html#iterator-types
6. http://www.python.org/dev/peps/pep-0249/
1126
Chapter 43. PL/Python- Python Procedural Language
plpy.SPIError
,which by default will terminate the function. This error can be handled just like
any other Python exception, by using the
try/except
construct. For example:
CREATE FUNCTION try_adding_joe() RETURNS text AS $$
try:
plpy.execute("INSERT INTO users(username) VALUES (’joe’)")
except plpy.SPIError:
return "something went wrong"
else:
return "Joe added"
$$ LANGUAGE plpythonu;
The actual class of the exception being raised corresponds to the specific condition that caused
the error. Refer to Table A-1 for a list of possible conditions. The module
plpy.spiexceptions
defines an exception class for each PostgreSQL condition, deriving their names from the condi-
tion name. For instance,
division_by_zero
becomes
DivisionByZero
,
unique_violation
becomes
UniqueViolation
,
fdw_error
becomes
FdwError
,and so on. Each of these exception
classes inherits from
SPIError
.This separationmakes iteasier tohandlespecific errors, for instance:
CREATE FUNCTION insert_fraction(numerator int, denominator int) RETURNS text AS $$
from plpy import spiexceptions
try:
plan = plpy.prepare("INSERT INTO fractions (frac) VALUES ($1 / $2)", ["int", "int"])
plpy.execute(plan, [numerator, denominator])
except spiexceptions.DivisionByZero:
return "denominator cannot equal zero"
except spiexceptions.UniqueViolation:
return "already have that fraction"
except plpy.SPIError, e:
return "other error, SQLSTATE %s" % e.sqlstate
else:
return "fraction inserted"
$$ LANGUAGE plpythonu;
Note that because all exceptions from the
plpy.spiexceptions
module inherit from
SPIError
,
an
except
clause handling it will catch any database access error.
As an alternative way of handling different error conditions, you can catch the
SPIError
exception
and determine the specific error condition inside the
except
block by looking at the
sqlstate
attribute of the exception object. This attribute is a string value containing the “SQLSTATE” error
code. This approach provides approximately the same functionality
43.8. Explicit Subtransactions
Recoveringfrom errors caused by database access as described in Section 43.7.2 canlead to an unde-
sirable situation where some operations succeed before one of them fails, and after recovering from
that error the data is left in an inconsistent state. PL/Python offers a solution to this problem in the
form of explicit subtransactions.
1127
Documents you may be interested
Documents you may be interested