pdf viewer for asp.net web application : Add an image to a pdf form control SDK platform web page .net azure web browser postgresql-9.4-A4202-part2838

Chapter 56. GiST Indexes
if (entry->leafkey)
{
/
*
replace entry->key with a compressed version
*
/
compressed_data_type
*
compressed_data = palloc(sizeof(compressed_data_type));
/
*
fill
*
compressed_data from entry->key ...
*
/
retval = palloc(sizeof(GISTENTRY));
gistentryinit(
*
retval, PointerGetDatum(compressed_data),
entry->rel, entry->page, entry->offset, FALSE);
}
else
{
/
*
typically we needn’t do anything with non-leaf entries
*
/
retval = entry;
}
PG_RETURN_POINTER(retval);
}
You have to adapt
compressed_data_type
to the specific type you’re converting to in order
to compress your leaf nodes, of course.
Depending on your needs, you could also need to care about compressing
NULL
values in there,
storing for example
(Datum) 0
like
gist_circle_compress
does.
decompress
The reverse of the
compress
method. Converts the index representation of the data item into a
format that can be manipulated by the database.
The SQL declaration of the function must look like this:
CREATE OR REPLACE FUNCTION my_decompress(internal)
RETURNS internal
AS ’MODULE_PATHNAME’
LANGUAGE C STRICT;
And the matchingcode in the C module could thenfollow this skeleton:
Datum
my_decompress(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(my_decompress);
Datum
my_decompress(PG_FUNCTION_ARGS)
{
PG_RETURN_POINTER(PG_GETARG_POINTER(0));
}
The above skeleton is suitable for the case where no decompression is needed.
penalty
Returns avalueindicatingthe “cost” of insertingthenew entryinto aparticular branchof the tree.
Items will be inserted down the path of least
penalty
in the tree. Values returned by
penalty
should be non-negative. If a negative value is returned, it will be treated as zero.
The SQL declaration of the function must look like this:
CREATE OR REPLACE FUNCTION my_penalty(internal, internal, internal)
RETURNS internal
AS ’MODULE_PATHNAME’
LANGUAGE C STRICT;
-- in some cases penalty functions need not be strict
1948
Add an image to a 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
attach image to pdf form; how to add picture to pdf
Add an image to a 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
add a picture to a pdf; add image pdf document
Chapter 56. GiST Indexes
And the matchingcode in the C module could thenfollow this skeleton:
Datum
my_penalty(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(my_penalty);
Datum
my_penalty(PG_FUNCTION_ARGS)
{
GISTENTRY
*
origentry = (GISTENTRY
*
) PG_GETARG_POINTER(0);
GISTENTRY
*
newentry = (GISTENTRY
*
) PG_GETARG_POINTER(1);
float
*
penalty = (float
*
) PG_GETARG_POINTER(2);
data_type
*
orig = DatumGetDataType(origentry->key);
data_type
*
new = DatumGetDataType(newentry->key);
*
penalty = my_penalty_implementation(orig, new);
PG_RETURN_POINTER(penalty);
}
The
penalty
function is crucial to good performance of the index. It’ll get used at insertion
time todetermine whichbranch to follow when choosing where toadd the new entry inthe tree.
At query time, the more balanced the index, the quicker the lookup.
picksplit
When anindex page splitis necessary, this function decides whichentries on the page are to stay
on the old page, and which are to move to the new page.
The SQL declaration of the function must look like this:
CREATE OR REPLACE FUNCTION my_picksplit(internal, internal)
RETURNS internal
AS ’MODULE_PATHNAME’
LANGUAGE C STRICT;
And the matchingcode in the C module could thenfollow this skeleton:
Datum
my_picksplit(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(my_picksplit);
Datum
my_picksplit(PG_FUNCTION_ARGS)
{
GistEntryVector
*
entryvec = (GistEntryVector
*
) PG_GETARG_POINTER(0);
OffsetNumber maxoff = entryvec->n - 1;
GISTENTRY
*
ent = entryvec->vector;
GIST_SPLITVEC
*
v = (GIST_SPLITVEC
*
) PG_GETARG_POINTER(1);
int
i,
nbytes;
OffsetNumber
*
left,
*
right;
data_type
*
tmp_union;
data_type
*
unionL;
data_type
*
unionR;
GISTENTRY
**
raw_entryvec;
maxoff = entryvec->n - 1;
nbytes = (maxoff + 1)
*
sizeof(OffsetNumber);
v->spl_left = (OffsetNumber
*
) palloc(nbytes);
left = v->spl_left;
v->spl_nleft = 0;
1949
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
how to add image to pdf; add image pdf acrobat
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
adding image to pdf form; adding image to pdf
Chapter 56. GiST Indexes
v->spl_right = (OffsetNumber
*
) palloc(nbytes);
right = v->spl_right;
v->spl_nright = 0;
unionL = NULL;
unionR = NULL;
/
*
Initialize the raw entry vector.
*
/
raw_entryvec = (GISTENTRY
**
) malloc(entryvec->n
*
sizeof(void
*
));
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
raw_entryvec[i] = &(entryvec->vector[i]);
for (i = FirstOffsetNumber; i <= maxoff; i = OffsetNumberNext(i))
{
int
real_index = raw_entryvec[i] - entryvec->vector;
tmp_union = DatumGetDataType(entryvec->vector[real_index].key);
Assert(tmp_union != NULL);
/
*
*
Choose where to put the index entries and update unionL and unionR
*
accordingly. Append the entries to either v_spl_left or
*
v_spl_right, and care about the counters.
*
/
if (my_choice_is_left(unionL, curl, unionR, curr))
{
if (unionL == NULL)
unionL = tmp_union;
else
unionL = my_union_implementation(unionL, tmp_union);
*
left = real_index;
++left;
++(v->spl_nleft);
}
else
{
/
*
*
Same on the right
*
/
}
}
v->spl_ldatum = DataTypeGetDatum(unionL);
v->spl_rdatum = DataTypeGetDatum(unionR);
PG_RETURN_POINTER(v);
}
Like
penalty
,the
picksplit
function is crucial to good performance of the index. Designing
suitable
penalty
and
picksplit
implementations is where the challenge of implementing
well-performing GiST indexes lies.
1950
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 jpeg signature to pdf; add photo to pdf preview
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
add photo to pdf file; add picture to pdf file
Chapter 56. GiST Indexes
same
Returns true if two index entries are identical, false otherwise.
The SQL declaration of the function must look like this:
CREATE OR REPLACE FUNCTION my_same(internal, internal, internal)
RETURNS internal
AS ’MODULE_PATHNAME’
LANGUAGE C STRICT;
And the matchingcode in the C module could thenfollow this skeleton:
Datum
my_same(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(my_same);
Datum
my_same(PG_FUNCTION_ARGS)
{
prefix_range
*
v1 = PG_GETARG_PREFIX_RANGE_P(0);
prefix_range
*
v2 = PG_GETARG_PREFIX_RANGE_P(1);
bool
*
result = (bool
*
) PG_GETARG_POINTER(2);
*
result = my_eq(v1, v2);
PG_RETURN_POINTER(result);
}
For historical reasons, the
same
function doesn’t just return a Boolean result; instead it has to
store the flag at the locationindicated by the third argument.
distance
Given anindex entry
p
anda queryvalue
q
,this function determines the index entry’s “distance”
from the query value. This function must be supplied if the operator class contains any ordering
operators. A query using the ordering operator will be implemented by returning index entries
with the smallest “distance” values first, so the results must be consistent with the operator’s
semantics. For a leaf index entry the result just represents the distance to the index entry; for an
internal tree node, the result must be the smallest distance that any child entry could have.
The SQL declaration of the function must look like this:
CREATE OR REPLACE FUNCTION my_distance(internal, data_type, smallint, oid)
RETURNS float8
AS ’MODULE_PATHNAME’
LANGUAGE C STRICT;
And the matchingcode in the C module could thenfollow this skeleton:
Datum
my_distance(PG_FUNCTION_ARGS);
PG_FUNCTION_INFO_V1(my_distance);
Datum
my_distance(PG_FUNCTION_ARGS)
{
GISTENTRY
*
entry = (GISTENTRY
*
) PG_GETARG_POINTER(0);
data_type
*
query = PG_GETARG_DATA_TYPE_P(1);
StrategyNumber strategy = (StrategyNumber) PG_GETARG_UINT16(2);
/
*
Oid subtype = PG_GETARG_OID(3);
*
/
data_type
*
key = DatumGetDataType(entry->key);
double
retval;
/
*
*
determine return value as a function of strategy, key and query.
*
/
1951
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 jpeg to a pdf file; adding image to pdf file
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
add image in pdf using java; how to add jpg to pdf file
Chapter 56. GiST Indexes
PG_RETURN_FLOAT8(retval);
}
The arguments to the
distance
function are identical to the arguments of the
consistent
function, except that no recheck flag is used. The distance to a leaf index entry must always be
determined exactly, since there is no way to re-order the tuples once they are returned. Some
approximation is allowed when determining the distance to an internal tree node, so long as the
result is never greater thananychild’s actual distance. Thus, for example, distance to a bounding
box is usually sufficient in geometric applications. The result value can be any finite
float8
value. (Infinity and minus infinity are used internally to handle cases such as nulls, so it is not
recommended that
distance
functions return these values.)
All the GiST support methods are normally called in short-lived memory contexts; that is,
CurrentMemoryContext
will get reset after each tuple is processed. It is therefore not very
important to worry about pfree’ing everything you palloc. However, in some cases it’s useful for a
support method to cache data across repeated calls. To do that, allocate the longer-lived data in
fcinfo->flinfo->fn_mcxt
,and keep a pointer to it in
fcinfo->flinfo->fn_extra
.Such
data will survive for the life of the index operation (e.g., a single GiST index scan, index build, or
index tuple insertion). Be careful to pfree the previous value when replacing a
fn_extra
value, or
the leak will accumulate for the duration of the operation.
56.4. Implementation
56.4.1. GiST buffering build
Building large GiST indexes by simply inserting all the tuples tends to be slow, because if the index
tuples are scattered across the index and the index is large enough to not fit in cache, the insertions
need to perform a lot of random I/O. Beginning in version 9.2, PostgreSQL supports a more efficient
method to build GiST indexes based on buffering, which can dramatically reduce the number of
random I/Os needed for non-ordered data sets. For well-ordered data sets the benefit is smaller or
non-existent, because only a small number of pages receive new tuples at a time, and those pages fit
in cache evenif the index as whole does not.
However, bufferingindexbuildneeds tocallthe
penalty
functionmoreoften, whichconsumes some
extra CPU resources. Also, the buffers used in the buffering build need temporary disk space, up to
the size of the resulting index. Buffering can also influence the quality of the resulting index, in both
positive andnegativedirections. That influence depends onvarious factors, like the distribution of the
input data and the operator class implementation.
By default, a GiST index build switches to the buffering method when the index size reaches effec-
tive_cache_size. It can be manually turned on or off by the
BUFFERING
parameter to the CREATE
INDEX command. The default behavior is good for most cases, but turning bufferingoff might speed
up the build somewhat if the input data is ordered.
56.5. Examples
The PostgreSQL source distribution includes several examples of index methods implemented
using GiST. The core system currently provides text search support (indexing for
tsvector
and
tsquery
)as well as R-Tree equivalent functionality for some of the built-in geometric data types
1952
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.
adding images to pdf files; add picture to pdf document
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 an image to a pdf file; add photo to pdf form
Chapter 56. GiST Indexes
(see
src/backend/access/gist/gistproc.c
). The following
contrib
modules also contain
GiST operator classes:
btree_gist
B-tree equivalent functionality for several data types
cube
Indexing for multidimensional cubes
hstore
Module for storing (key, value) pairs
intarray
RD-Tree for one-dimensional array of int4 values
ltree
Indexing for tree-like structures
pg_trgm
Text similarity using trigram matching
seg
Indexing for “float ranges”
1953
Chapter 57. SP-GiST Indexes
57.1. Introduction
SP-GiST is an abbreviation for space-partitioned GiST. SP-GiST supports partitioned search trees,
which facilitate development of a wide range of different non-balanced data structures, such as quad-
trees, k-d trees, and radix trees (tries). The common feature of these structures is that they repeatedly
divide the search space into partitions that need not be of equal size. Searches that are well matched
to the partitioning rule can be very fast.
These popular data structures were originally developed for in-memory usage. In main memory, they
are usually designed as a set of dynamically allocated nodes linked by pointers. This is not suitable
for direct storing on disk, since these chains of pointers can be rather long which would require too
many disk accesses. In contrast, disk-based data structures should have ahigh fanout to minimize I/O.
The challenge addressed by SP-GiST is to map search tree nodes to disk pages in such a way that a
search need access only a few disk pages, even if it traverses many nodes.
Like GiST, SP-GiST is meant to allow the development of custom data types with the appropriate
access methods, by an expert in the domainof the data type, rather than a database expert.
Some of the information here is derived from Purdue University’s SP-GiST Indexing Project web
site
1
.The SP-GiST implementation in PostgreSQL is primarily maintained by Teodor Sigaev and
Oleg Bartunov, and there is more information on their web site
2
.
57.2. Built-in Operator Classes
The core PostgreSQL distribution includes the SP-GiST operator classes shown in Table 57-1.
Table 57-1. Built-in SP-GiST Operator Classes
Name
Indexed Data Type
Indexable Operators
kd_point_ops
point
<< <@ <^ >>>^ ~=
quad_point_ops
point
<< <@ <^ >>>^ ~=
range_ops
any range type
&& &< &> -|- <<<@ = >>
@>
text_ops
text
<<= = > >= ~<=~ ~<~
~>=~ ~>~
Of the two operator classes for type
point
,
quad_point_ops
is the default.
kd_point_ops
sup-
ports the same operators but uses a different index data structure which may offer better performance
in some applications.
1. http://www.cs.purdue.edu/spgist/
2. http://www.sai.msu.su/~megera/wiki/spgist_dev
1954
Chapter 57. SP-GiST Indexes
57.3. Extensibility
SP-GiST offers an interface with a high level of abstraction, requiring the access method developer
to implement only methods specific to a given data type. The SP-GiST core is responsible for ef-
ficient disk mapping and searching the tree structure. It also takes care of concurrency and logging
considerations.
Leaf tuples of an SP-GiST tree contain values of the same data type as the indexed column. Leaf
tuples at the root level will always contain the original indexed data value, but leaf tuples at lower
levels might containonly a compressed representation, such as a suffix. In that case the operator class
support functions must be able to reconstruct the original value using information accumulated from
the inner tuples that are passed through to reach the leaf level.
Inner tuples are more complex, since they are branching points in the search tree. Each inner tuple
contains a set of one or more nodes, which represent groups of similar leaf values. A node contains a
downlinkthat leads to either another, lower-level inner tuple, or a short list of leaf tuples thatall lie on
thesame index page. Eachnode has alabel thatdescribes it; for example, ina radix tree the nodelabel
could be the next character of the string value. Optionally, an inner tuple can have a prefix value that
describes all its members. In a radix tree this could be the common prefix of the represented strings.
The prefix value is not necessarily really a prefix, but can be any data needed by the operator class;
for example, in a quad-tree it can store the central point that the four quadrants are measured with
respect to. A quad-tree inner tuple wouldthenalso contain four nodes corresponding to the quadrants
around this central point.
Some tree algorithms require knowledge of level (or depth) of the current tuple, so the SP-GiST core
provides the possibility for operator classes to manage levelcountingwhile descendingthe tree. There
is also support for incrementally reconstructing the represented value when that is needed.
Note: The SP-GiST core code takes care of null entries. Although SP-GiST indexes do store
entries for nulls inindexed columns, this ishidden fromtheindexoperatorclass code: nonullindex
entries or searchconditions will ever bepassed to theoperator class methods. (It is assumedthat
SP-GiST operators are strict and socannot succeed for null values.) Null values are thereforenot
discussed further here.
There are five user-defined methods that an index operator class for SP-GiST must provide. All five
follow the convention of accepting two
internal
arguments, the first of which is a pointer to a
Cstruct containing input values for the support method, while the second argument is a pointer to
aC struct where output values must be placed. Four of the methods just return
void
,since all their
results appear inthe outputstruct; but
leaf_consistent
additionally returns a
boolean
result. The
methods must not modify any fields of their input structs. In all cases, the output struct is initialized
to zeroes before calling the user-defined method.
The five user-defined methods are:
config
Returns static information about the index implementation, including the data type OIDs of the
prefix and node label data types.
The SQL declaration of the function must look like this:
CREATE FUNCTION my_config(internal, internal) RETURNS void ...
Thefirst argumentis a pointer toa
spgConfigIn
Cstruct, containinginputdatafor the function.
The second argumentis a pointer toa
spgConfigOut
Cstruct, whichthe function must fillwith
result data.
1955
Chapter 57. SP-GiST Indexes
typedef struct spgConfigIn
{
Oid
attType;
/
*
Data type to be indexed
*
/
} spgConfigIn;
typedef struct spgConfigOut
{
Oid
prefixType;
/
*
Data type of inner-tuple prefixes
*
/
Oid
labelType;
/
*
Data type of inner-tuple node labels
*
/
bool
canReturnData;
/
*
Opclass can reconstruct original data
*
/
bool
longValuesOK;
/
*
Opclass can cope with values > 1 page
*
/
} spgConfigOut;
attType
is passed in order to support polymorphic index operator classes; for ordinary fixed-
data-type operator classes, it will always have the same value and so can be ignored.
For operator classes that do not use prefixes,
prefixType
can be set to
VOIDOID
.Likewise,
for operator classes that do not use node labels,
labelType
can be set to
VOIDOID
.
canReturnData
should be set true if the operator class is capable of reconstructing the
originally-supplied index value.
longValuesOK
should be set true only when the
attType
is
of variable length and the operator class is capable of segmenting long values by repeated
suffixing (see Section 57.4.1).
choose
Chooses a method for inserting a new value into an inner tuple.
The SQL declaration of the function must look like this:
CREATE FUNCTION my_choose(internal, internal) RETURNS void ...
Thefirst argumentis a pointer toa
spgChooseIn
Cstruct, containinginputdatafor the function.
The second argumentis a pointer toa
spgChooseOut
Cstruct, whichthe function must fillwith
result data.
typedef struct spgChooseIn
{
Datum
datum;
/
*
original datum to be indexed
*
/
Datum
leafDatum;
/
*
current datum to be stored at leaf
*
/
int
level;
/
*
current level (counting from zero)
*
/
/
*
Data from current inner tuple
*
/
bool
allTheSame;
/
*
tuple is marked all-the-same?
*
/
bool
hasPrefix;
/
*
tuple has a prefix?
*
/
Datum
prefixDatum;
/
*
if so, the prefix value
*
/
int
nNodes;
/
*
number of nodes in the inner tuple
*
/
Datum
*
nodeLabels;
/
*
node label values (NULL if none)
*
/
} spgChooseIn;
typedef enum spgChooseResultType
{
spgMatchNode = 1,
/
*
descend into existing node
*
/
spgAddNode,
/
*
add a node to the inner tuple
*
/
spgSplitTuple
/
*
split inner tuple (change its prefix)
*
/
} spgChooseResultType;
typedef struct spgChooseOut
{
spgChooseResultType resultType;
/
*
action code, see above
*
/
union
{
1956
Chapter 57. SP-GiST Indexes
struct
/
*
results for spgMatchNode
*
/
{
int
nodeN;
/
*
descend to this node (index from 0)
*
/
int
levelAdd;
/
*
increment level by this much
*
/
Datum
restDatum;
/
*
new leaf datum
*
/
}
matchNode;
struct
/
*
results for spgAddNode
*
/
{
Datum
nodeLabel;
/
*
new node’s label
*
/
int
nodeN;
/
*
where to insert it (index from 0)
*
/
}
addNode;
struct
/
*
results for spgSplitTuple
*
/
{
/
*
Info to form new inner tuple with one node
*
/
bool
prefixHasPrefix;
/
*
tuple should have a prefix?
*
/
Datum
prefixPrefixDatum;
/
*
if so, its value
*
/
Datum
nodeLabel;
/
*
node’s label
*
/
/
*
Info to form new lower-level inner tuple with all old nodes
*
/
bool
postfixHasPrefix;
/
*
tuple should have a prefix?
*
/
Datum
postfixPrefixDatum; /
*
if so, its value
*
/
}
splitTuple;
}
result;
} spgChooseOut;
datum
is the original datum that was to be inserted into the index.
leafDatum
is initially the
same as
datum
,but canchange at lower levels of the tree if the
choose
or
picksplit
methods
change it. When the insertion search reaches a leaf page, the current value of
leafDatum
is
what will be stored in the newly created leaf tuple.
level
is the current inner tuple’s level,
starting at zero for the root level.
allTheSame
is true if the current inner tuple is marked as
containing multiple equivalent nodes (see Section 57.4.3).
hasPrefix
is true if thecurrent inner
tuple contains a prefix; if so,
prefixDatum
is its value.
nNodes
is the number of child nodes
contained inthe inner tuple, and
nodeLabels
is an array of their label values, or NULL if there
are no labels.
The
choose
function can determine either that the new value matches one of the existing child
nodes, or that a new child node must be added, or that the new value is inconsistent with the
tuple prefix and so the inner tuple must be split to create a less restrictive prefix.
If the new value matches one of the existing child nodes, set
resultType
to
spgMatchNode
.
Set
nodeN
totheindex (from zero) of thatnode in the nodearray. Set
levelAdd
tothe increment
in
level
caused by descending through that node, or leave it as zero if the operator class does
not uselevels. Set
restDatum
toequal
datum
if the operator class does not modifydatums from
one level to the next, or otherwise set it to the modified value to be used as
leafDatum
at the
next level.
If a new child node must be added, set
resultType
to
spgAddNode
.Set
nodeLabel
to the
label to be used for the new node, and set
nodeN
to the index (from zero) at which to insert the
node in the node array. After the node has been added, the
choose
function will be called again
with the modified inner tuple; that call should result in an
spgMatchNode
result.
If the new value is inconsistentwith the tuple prefix, set
resultType
to
spgSplitTuple
.This
action moves all the existing nodes into a new lower-level inner tuple, and replaces the existing
inner tuple with a tuple having a single node that links to the new lower-level inner tuple. Set
prefixHasPrefix
to indicate whether the new upper tuple should have a prefix, and if so
set
prefixPrefixDatum
to the prefix value. This new prefix value must be sufficiently less
restrictive than the original to accept the new value to be indexed, and it should be no longer
1957
Documents you may be interested
Documents you may be interested