pdf viewer in asp net c# : Add an image to a pdf SDK Library project wpf asp.net azure UWP postgresql-9.4-A439-part2960

Chapter 10. Type Conversion
SELECT substr(CAST (1234 AS text), 3);
substr
--------
34
(1 row)
10.4. Value Storage
Values to be inserted into a table are converted to the destination column’s data type according to the
following steps.
Value Storage Type Conversion
1. Check for an exact match with the target.
2. Otherwise, trytoconverttheexpression to the targettype. Thiswill succeed if there is a registered
cast betweenthe two types. If the expression is an unknown-typeliteral, the contents of the literal
string will be fed to the input conversion routine for the target type.
3. Check to see if there is a sizing cast for the target type. A sizing cast is a cast from that type to
itself. If one is found in the
pg_cast
catalog, apply it to the expression before storing into the
destination column. The implementation function for such a cast always takes an extra param-
eter of type
integer
,which receives the destination column’s
atttypmod
value (typically its
declared length, although the interpretation of
atttypmod
varies for different data types), and it
may take a third
boolean
parameter that says whether the cast is explicit or implicit. The cast
function is responsible for applying any length-dependent semantics such as size checking or
truncation.
Example 10-8.
character
Storage Type Conversion
For a target column declared as
character(20)
the following statement shows that the stored value
is sized correctly:
CREATE TABLE vv (v character(20));
INSERT INTO vv SELECT ’abc’ || ’def’;
SELECT v, octet_length(v) FROM vv;
v
| octet_length
----------------------+--------------
abcdef
|
20
(1 row)
What has really happened here is that the two unknown literals are resolved to
text
by default, al-
lowing the
||
operator to be resolved as
text
concatenation. Then the
text
result of the operator is
converted to
bpchar
(“blank-padded char”, the internal name of the
character
data type) to match
the target column type. (Since the conversion from
text
to
bpchar
is binary-coercible, this conver-
siondoes not insertany real functioncall.) Finally, the sizing function
bpchar(bpchar, integer,
boolean)
is found in the system catalog and applied to the operator’s result and the stored column
length. This type-specific function performs the required length checkandaddition of paddingspaces.
318
Add an image to a pdf - 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
adding an image to a pdf in preview; how to add an image to a pdf file in acrobat
Add an image to a pdf - VB.NET PDF insert image library: insert images into PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide VB.NET Programmers How to Add Images in PDF Document
add photo to pdf form; adding images to a pdf document
Chapter 10. Type Conversion
10.5.
UNION
,
CASE
,and Related Constructs
SQL
UNION
constructs must matchuppossibly dissimilar types tobecome asingle result set. The res-
olution algorithm is applied separately to each output column of a union query. The
INTERSECT
and
EXCEPT
constructs resolve dissimilar types in the same way as
UNION
.The
CASE
,
ARRAY
,
VALUES
,
GREATEST
and
LEAST
constructs use the identicalalgorithm to matchuptheir componentexpressions
and select a result data type.
Type Resolution for
UNION
,
CASE
,and Related Constructs
1. If all inputs are of the same type, and it is not
unknown
,resolve as that type.
2. If any input is of a domain type, treat it as being of the domain’s base type for all subsequent
steps.
2
3. If allinputs are of type
unknown
,resolve as type
text
(the preferred type of the string category).
Otherwise,
unknown
inputs are ignored.
4. If the non-unknown inputs are not all of the same type category, fail.
5. Choose the first non-unknown input type which is a preferred type in that category, if there is
one.
6. Otherwise, choose the last non-unknown input type that allows all the preceding non-unknown
inputs to be implicitly converted to it. (There always is such a type, since at least the first type in
the list must satisfy this condition.)
7. Convert all inputs to the selected type. Fail if there is not a conversion from a given input to the
selected type.
Some examples follow.
Example 10-9. Type Resolution with Underspecified Types in a Union
SELECT text ’a’ AS "text" UNION SELECT ’b’;
text
------
a
b
(2 rows)
Here, the unknown-type literal
’b’
will be resolved to type
text
.
Example 10-10. Type Resolution in a Simple Union
SELECT 1.2 AS "numeric" UNION SELECT 1;
numeric
---------
1
1.2
2. Somewhat like the treatment of domain inputs for operators and functions, this behavior allows a domain type to be
preservedthrougha
UNION
orsimilar construct,solongas the useris carefultoensure that all inputs are implicitly orexplicitly
of that exact type. Otherwise the domain’s base type will be preferred.
319
C# PDF Image Extract Library: Select, copy, paste PDF images in C#
Get image information, such as its location, zonal information, metadata, and so on. Able to edit, add, delete, move, and output PDF document image.
add image to pdf java; add image to pdf online
VB.NET PDF Password Library: add, remove, edit PDF file password
VB: Add Password to PDF with Permission Settings Applied. This VB.NET example shows how to add PDF file password with access permission setting.
add png to pdf acrobat; how to add image to pdf form
Chapter 10. Type Conversion
(2 rows)
The literal
1.2
is of type
numeric
,and the
integer
value
1
can be cast implicitly to
numeric
,so
that type is used.
Example 10-11. Type Resolution in a Transposed Union
SELECT 1 AS "real" UNION SELECT CAST(’2.2’ AS REAL);
real
------
1
2.2
(2 rows)
Here, since type
real
cannot be implicitly cast to
integer
,but
integer
can be implicitly cast to
real
,the union result type is resolved as
real
.
320
VB.NET PDF Image Extract Library: Select, copy, paste PDF images
DLLs for PDF Image Extraction in VB.NET. In order to run the sample code, the following steps would be necessary. Add necessary references:
adding a jpg to a pdf; add picture to pdf file
C# PDF Password Library: add, remove, edit PDF file password in C#
C# Sample Code: Add Password to PDF with Permission Settings Applied in C#.NET. This example shows how to add PDF file password with access permission setting.
add an image to a pdf acrobat; add jpg to pdf
Chapter 11. Indexes
Indexes are a common wayto enhance database performance. An index allows the database server to
find and retrieve specific rows much faster than it could do without an index. But indexes also add
overhead to the database system as a whole, so they should be used sensibly.
11.1. Introduction
Suppose we have a table similar to this:
CREATE TABLE test1 (
id integer,
content varchar
);
and the application issues many queries of the form:
SELECT content FROM test1 WHERE id =
constant
;
With no advance preparation, the system would have to scan the entire
test1
table, row by row, to
find all matching entries. If there are many rows in
test1
and only a few rows (perhaps zero or one)
that would be returned by such a query, this is clearly an inefficient method. But if the system has
been instructed tomaintain anindex on the
id
column, itcan usea more efficient method for locating
matching rows. For instance, it might only have to walk a few levels deep into a search tree.
Asimilar approach is used in most non-fiction books: terms and concepts that are frequently looked
up by readers are collected in an alphabetic index at the end of the book. The interested reader can
scan the index relatively quickly and flip to the appropriate page(s), rather than having to read the
entire book to find the material of interest. Just as it is the task of the author to anticipate the items
that readers are likely to look up, it is the task of the database programmer to foresee which indexes
will be useful.
The following command canbe used to create an index on the
id
column, as discussed:
CREATE INDEX test1_id_index ON test1 (id);
The name
test1_id_index
can be chosen freely, but you should pick something that enables you
to remember later what the indexwas for.
To remove an index, use the
DROP INDEX
command. Indexes can be added to and removed from
tables at any time.
Onceanindexis created, nofurther intervention is required: the system willupdate theindexwhenthe
table is modified, and it will use the index in queries when it thinks doing so would be more efficient
than a sequential table scan. But you might have to run the
ANALYZE
command regularly to update
statistics toallowthequeryplanner tomake educated decisions. See Chapter 14 for information about
how to find out whether an index is used and when and why the planner might choose not to use an
index.
Indexes can also benefit
UPDATE
and
DELETE
commands with search conditions. Indexes can more-
over be used in join searches. Thus, an index defined on a column that is part of a join condition can
also significantly speed up queries with joins.
Creating an index on a large table can take a long time. By default, PostgreSQL allows reads
(
SELECT
statements) to occur on the table in parallel with index creation, but writes (
INSERT
,
321
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 image to pdf file; add jpeg signature to pdf
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.
how to add image to pdf document; add jpg to pdf file
Chapter 11. Indexes
UPDATE
,
DELETE
)are blocked until the index build is finished. In production environments this is
often unacceptable. It is possible to allow writes to occur inparallelwith index creation, but there are
several caveats to be aware of — for more information see Building Indexes Concurrently.
After an index is created, the system has to keep it synchronized with the table. This adds overhead
to data manipulationoperations. Therefore indexes that are seldom or never used in queries should be
removed.
11.2. Index Types
PostgreSQL provides several index types: B-tree, Hash, GiST, SP-GiST and GIN. Each index type
uses a different algorithm that is best suited to different types of queries. By default, the
CREATE
INDEX
command creates B-tree indexes, which fit the most common situations.
B-trees canhandle equality and rangequeries ondata thatcan be sorted into some ordering. Inpartic-
ular, the PostgreSQL query planner will consider using a B-tree index whenever an indexed column
is involved in a comparison using one of these operators:
<
<=
=
>=
>
Constructs equivalent to combinations of these operators, such as
BETWEEN
and
IN
,can also be im-
plemented with a B-tree index search. Also, an
IS NULL
or
IS NOT NULL
condition on an index
column can be used with a B-tree index.
The optimizer can also use a B-tree index for queries involving the pattern matching operators
LIKE
and
~
if the pattern is a constant and is anchored to the beginning of the string — for example,
col
LIKE ’foo%’
or
col ~ ’^foo’
,but not
col LIKE ’%bar’
.However, if your database does not
use the C locale you will need to create the index with a special operator class to support indexing
of pattern-matching queries; see Section 11.9 below. It is also possible to use B-tree indexes for
ILIKE
and
~
*
,but onlyif thepatternstarts with non-alphabetic characters, i.e., characters that are not
affected by upper/lower case conversion.
B-tree indexes can also be usedto retrieve data in sorted order. This is not always faster than a simple
scan and sort, but it is often helpful.
Hash indexes can only handle simple equality comparisons. The query planner will consider using
ahash index whenever an indexed column is involved in a comparison using the
=
operator. The
following command is used to create a hash index:
CREATE INDEX
name
ON
table
USING hash (
column
);
Caution
Hash index operations are not presently WAL-logged, so hash indexes might
need to be rebuilt with
REINDEX
after a database crash if there were unwritten
changes. Also, changes to hash indexes are not replicated over streaming or
file-based replication after the initial base backup, so they give wrong answers
to queries that subsequently use them. For these reasons, hash index use is
presently discouraged.
322
C# PDF remove image library: remove, delete images from PDF in C#.
C# Read: PDF Image Extract; C# Write: Insert text into PDF; C# Write: Add Image to PDF; Remove Image from PDF Page Using C#. Add necessary references:
adding image to pdf form; add multiple jpg to pdf
VB.NET PDF remove image library: remove, delete images from PDF in
C# Read: PDF Image Extract; C# Write: Insert text into PDF; C# Write: Add Image to PDF; VB.NET: Remove Image from PDF Page. Add necessary references:
adding image to pdf; add signature image to pdf
Chapter 11. Indexes
GiST indexes are not a single kind of index, but rather an infrastructure within which many different
indexing strategies can be implemented. Accordingly, the particular operators with which a GiST
index can be used vary depending on the indexing strategy (the operator class). As an example,
the standard distribution of PostgreSQL includes GiST operator classes for several two-dimensional
geometric data types, which support indexed queries using these operators:
<<
&<
&>
>>
<<|
&<|
|&>
|>>
@>
<@
~=
&&
(See Section 9.11 for the meaning of these operators.) The GiST operator classes included in the
standard distribution are documented in Table 56-1. Many other GiST operator classes are available
in the
contrib
collection or as separate projects. For more information see Chapter 56.
GiST indexes are also capable of optimizing “nearest-neighbor” searches, such as
SELECT
*
FROM places ORDER BY location <-> point ’(101,456)’ LIMIT 10;
which finds the ten places closest to a given target point. The ability to do this is again dependent on
the particular operator class being used. InTable 56-1, operators that canbe used inthis wayarelisted
in the column “Ordering Operators”.
SP-GiST indexes, like GiST indexes, offer an infrastructure that supports various kinds of searches.
SP-GiST permits implementation of a wide range of different non-balanced disk-based data struc-
tures, such as quadtrees, k-d trees, and radix trees (tries). As an example, the standard distribution of
PostgreSQL includes SP-GiST operator classes for two-dimensional points, which support indexed
queries using these operators:
<<
>>
~=
<@
<^
>^
(See Section 9.11 for the meaning of these operators.) The SP-GiST operator classes included in the
standard distribution are documented inTable 57-1. For more information see Chapter 57.
GIN indexes are inverted indexes which can handle values that contain more than one key, arrays for
example. Like GiST and SP-GiST, GIN can support many different user-defined indexing strategies
and the particular operators with which a GIN index can be used vary depending on the indexing
strategy. As an example, the standard distribution of PostgreSQL includes GIN operator classes for
one-dimensional arrays, which support indexed queries using these operators:
<@
@>
323
Chapter 11. Indexes
=
&&
(See Section 9.18 for the meaning of these operators.) The GIN operator classes included in the
standard distribution are documented in Table 58-1. Many other GINoperator classes are available in
the
contrib
collection or as separate projects. For more information see Chapter 58.
11.3. Multicolumn Indexes
An index can be defined on more than one column of a table. For example, if you have a table of this
form:
CREATE TABLE test2 (
major int,
minor int,
name varchar
);
(say, you keep your
/dev
directory in a database...) and you frequently issue queries like:
SELECT name FROM test2 WHERE major =
constant
AND minor =
constant
;
then it might be appropriate to define an index on the columns
major
and
minor
together, e.g.:
CREATE INDEX test2_mm_idx ON test2 (major, minor);
Currently, only the B-tree, GiST and GIN index types support multicolumn indexes. Up to 32
columns can be specified. (This limit can be altered when building PostgreSQL; see the file
pg_config_manual.h
.)
Amulticolumn B-tree index can be used with query conditions that involve any subset of the index’s
columns, but the index is most efficient when there are constraints on the leading (leftmost) columns.
The exact rule is that equality constraints on leading columns, plus any inequality constraints on the
first column thatdoes nothave anequality constraint, will beused to limit the portionof the indexthat
is scanned. Constraints oncolumns totherightof thesecolumns are checkedintheindex, sotheysave
visits to the table proper, but they do not reduce the portion of the index that has to be scanned. For
example, given an index on
(a, b, c)
and a query condition
WHERE a = 5 AND b >= 42 AND
c < 77
,the index would have tobe scanned from the firstentry with
a
=5and
b
=42up through the
last entrywith
a
=5. Index entries with
c
>= 77wouldbe skipped, but they’d still have to be scanned
through. This index could in principle be usedfor queries that have constraints on
b
and/or
c
with no
constraint on
a
—but the entire index would have to be scanned, so in most cases the planner would
prefer a sequential table scan over using the index.
Amulticolumn GiST index can be used with query conditions that involve any subset of the index’s
columns. Conditions on additional columns restricttheentries returned by the index, but the condition
on the first column is the most important one for determining how much of the index needs to be
scanned. A GiST index will be relatively ineffective if its first column has only a few distinct values,
even if there are many distinct values in additional columns.
Amulticolumn GIN index can be used with query conditions that involve any subset of the index’s
columns. Unlike B-tree or GiST, index search effectiveness is the same regardless of which index
column(s) the query conditions use.
324
Chapter 11. Indexes
Of course, eachcolumnmustbeusedwith operators appropriatetotheindextype;clauses thatinvolve
other operators will not be considered.
Multicolumn indexes should be used sparingly. In most situations, an index on a single column is
sufficient and saves space and time. Indexes with more than three columns are unlikely to be helpful
unless the usage of the table is extremely stylized. See also Section 11.5 for some discussion of the
merits of different index configurations.
11.4. Indexes and
ORDER BY
Inadditiontosimply findingthe rows tobe returnedbya query, anindexmaybeable todeliver them in
aspecific sorted order. This allows a query’s
ORDER BY
specification to be honoredwithout a separate
sorting step. Of the index types currently supported by PostgreSQL, only B-tree can produce sorted
output — the other index types return matching rows in an unspecified, implementation-dependent
order.
The planner will consider satisfying an
ORDER BY
specificationeither by scanning anavailable index
that matches the specification, or by scanning the table in physical order and doing an explicit sort.
For a query that requires scanning a large fraction of the table, an explicit sort is likely to be faster
than using an index because it requires less disk I/O due to following a sequential access pattern.
Indexes are more useful when only a few rows need be fetched. An important special case is
ORDER
BY
in combination with
LIMIT n
:an explicit sort will have to process all the data to identify the first
n
rows, but if there is an index matching the
ORDER BY
,the first
n
rows can be retrieved directly,
without scanning the remainder at all.
By default, B-tree indexes store their entries in ascending order with nulls last. This means that a
forward scan of an index on column
x
produces output satisfying
ORDER BY x
(or more verbosely,
ORDER BY x ASC NULLS LAST
). The index can also be scanned backward, producing output sat-
isfying
ORDER BY x DESC
(or more verbosely,
ORDER BY x DESC NULLS FIRST
,since
NULLS
FIRST
is the default for
ORDER BY DESC
).
You can adjust the ordering of a B-tree index by including the options
ASC
,
DESC
,
NULLS FIRST
,
and/or
NULLS LAST
when creating the index; for example:
CREATE INDEX test2_info_nulls_low ON test2 (info NULLS FIRST);
CREATE INDEX test3_desc_index ON test3 (id DESC NULLS LAST);
An index stored in ascending order with nulls first can satisfy either
ORDER BY x ASC NULLS
FIRST
or
ORDER BY x DESC NULLS LAST
depending on which direction it is scanned in.
You might wonder why bother providing all four options, when two options together with the pos-
sibility of backward scan would cover all the variants of
ORDER BY
.In single-column indexes the
options are indeed redundant, but in multicolumn indexes they can be useful. Consider a two-column
index on
(x, y)
:this can satisfy
ORDER BY x, y
if we scan forward, or
ORDER BY x DESC, y
DESC
if we scan backward. But it might be that the application frequently needs to use
ORDER BY x
ASC, y DESC
.There is no way to get that ordering from a plain index, but it is possible if the index
is defined as
(x ASC, y DESC)
or
(x DESC, y ASC)
.
Obviously, indexes withnon-defaultsortorderings are a fairlyspecializedfeature, but sometimes they
can produce tremendous speedups for certain queries. Whether it’s worth maintaining such an index
depends on how often you use queries that require a special sort ordering.
325
Chapter 11. Indexes
11.5. Combining Multiple Indexes
Asingle index scan can only use query clauses that use the index’s columns with operators of its
operator class and are joined with
AND
.For example, given an index on
(a, b)
aquery condition
like
WHERE a = 5 AND b = 6
could use the index, but a query like
WHERE a = 5 OR b = 6
could not directly use the index.
Fortunately, PostgreSQL has the ability to combine multiple indexes (including multiple uses of the
same index) to handle cases that cannot be implemented by single index scans. The system can form
AND
and
OR
conditions across several index scans. For example, a query like
WHERE x = 42 OR x
= 47 OR x = 53 OR x = 99
could be broken down intofour separatescans of anindexon
x
,each
scan using one of the query clauses. The results of these scans are then ORed together to produce the
result. Another example is that if we have separate indexes on
x
and
y
,one possible implementation
of a query like
WHERE x = 5 AND y = 6
is to use each indexwith the appropriate query clause and
then AND together the index results to identify the result rows.
To combine multiple indexes, the system scans each needed index and prepares a bitmap in memory
giving the locations of table rows that are reported as matching that index’s conditions. The bitmaps
are then ANDed and ORed together as needed by the query. Finally, the actual table rows are visited
and returned. The table rows are visited in physical order, because that is how the bitmap is laid out;
this means thatany ordering of the originalindexes is lost, andsoa separatesortstepwill beneeded if
the query has an
ORDER BY
clause. For this reason, andbecause each additional index scanadds extra
time, the planner will sometimes choose to use a simple index scan even though additional indexes
are available that could have been used as well.
In all but the simplest applications, there are various combinations of indexes that might be useful,
and the database developer must make trade-offs to decide which indexes to provide. Sometimes
multicolumn indexes are best, but sometimes it’s better to create separate indexes and rely on the
index-combination feature. For example, if your workload includes a mix of queries that sometimes
involve only column
x
,sometimes only column
y
,and sometimes bothcolumns, you might choose to
create two separate indexes on
x
and
y
,relying on index combination to process the queries that use
both columns. You could also create a multicolumn index on
(x, y)
.This index would typically be
more efficient than index combinationfor queries involvingboth columns, but as discussed inSection
11.3, it would be almost useless for queries involving only
y
,so it should not be the only index. A
combination of the multicolumn index and a separate index on
y
would serve reasonably well. For
queries involving only
x
,the multicolumn index could be used, though it would be larger and hence
slower than an index on
x
alone. The last alternative is to create all three indexes, but this is probably
only reasonable if the table is searched muchmore often than it is updated and allthree types of query
are common. If one of the types of query is much less common than the others, you’d probably settle
for creating just the two indexes that best match the common types.
11.6. Unique Indexes
Indexes canalsobeusedtoenforce uniqueness of a column’s value, or theuniqueness of the combined
values of more than one column.
CREATE UNIQUE INDEX
name
ON
table
(
column
[, ...]);
Currently, only B-tree indexes can be declared unique.
When an index is declared unique, multiple table rows with equal indexed values are not allowed.
Null values are not considered equal. A multicolumn unique index will only reject cases where all
indexed columns are equal in multiple rows.
326
Chapter 11. Indexes
PostgreSQL automatically creates a unique index when a unique constraint or primary key is de-
fined for a table. The index covers the columns that make up the primary key or unique constraint (a
multicolumn index, if appropriate), and is the mechanism that enforces the constraint.
Note: The preferred way to add a unique constraint to a table is
ALTER TABLE ... ADD
CONSTRAINT
. The use of indexes to enforce unique constraints could be considered an
implementation detail that should not be accessed directly. One should, however, be aware that
there’s no need to manually create indexes on unique columns; doing so would just duplicatethe
automatically-created index.
11.7. Indexes on Expressions
An index column need not be just a column of the underlying table, but can be a function or scalar
expression computed from one or more columns of the table. This feature is useful to obtain fast
access to tables based on the results of computations.
For example, a common way to do case-insensitive comparisons is to use the
lower
function:
SELECT
*
FROM test1 WHERE lower(col1) = ’value’;
This query can use an index if one has been defined on the result of the
lower(col1)
function:
CREATE INDEX test1_lower_col1_idx ON test1 (lower(col1));
If we were to declare this index
UNIQUE
,it would prevent creation of rows whose
col1
values differ
only in case, as well as rows whose
col1
values are actually identical. Thus, indexes on expressions
can be used to enforce constraints that are not definable as simple unique constraints.
As another example, if one often does queries like:
SELECT
*
FROM people WHERE (first_name || ’ ’ || last_name) = ’John Smith’;
then it might be worth creating an index like this:
CREATE INDEX people_names ON people ((first_name || ’ ’ || last_name));
The syntax of the
CREATE INDEX
command normally requires writing parentheses around index
expressions, as shown in the second example. The parentheses can be omitted when the expression is
just a function call, as in the first example.
Index expressions are relatively expensive to maintain, because the derived expression(s) must be
computed for eachrow uponinsertion and whenever it is updated. However, the indexexpressions are
not recomputedduring an indexedsearch, since theyare already storedin the index. In both examples
above, the system sees the query as just
WHERE indexedcolumn = ’constant’
and so the speed
of the search is equivalent to any other simple index query. Thus, indexes on expressions are useful
whenretrieval speed is more important than insertion and update speed.
327
Documents you may be interested
Documents you may be interested