pdf viewer for asp.net web application : How to add a photo to a pdf document control SDK platform web page .net azure web browser postgresql-9.4-A4203-part2839

Chapter 57. SP-GiST Indexes
than the original prefix. Set
nodeLabel
to the label to be used for the node that will point to the
new lower-level inner tuple. Set
postfixHasPrefix
to indicate whether the new lower-level
inner tuple should have a prefix, and if so set
postfixPrefixDatum
to the prefix value. The
combination of these two prefixes and the additional label must have the same meaning as the
original prefix, because there is no opportunity to alter the node labels that are moved to the
new lower-level tuple, nor to change any child index entries. After the node has been split, the
choose
function will be called again with the replacement inner tuple. That call will usually
result in an
spgAddNode
result, since presumably the node label added in the split step will not
match the new value; so after that, there will be a third call that finally returns
spgMatchNode
andallows the insertion to descend to the leaf level.
picksplit
Decides how to create a new inner tuple over a set of leaf tuples.
The SQL declaration of the function must look like this:
CREATE FUNCTION my_picksplit(internal, internal) RETURNS void ...
The first argument is a pointer to a
spgPickSplitIn
Cstruct, containing input data for the
function. The secondargumentis a pointer toa
spgPickSplitOut
Cstruct, which the function
must fill with result data.
typedef struct spgPickSplitIn
{
int
nTuples;
/
*
number of leaf tuples
*
/
Datum
*
datums;
/
*
their datums (array of length nTuples)
*
/
int
level;
/
*
current level (counting from zero)
*
/
} spgPickSplitIn;
typedef struct spgPickSplitOut
{
bool
hasPrefix;
/
*
new inner tuple should have a prefix?
*
/
Datum
prefixDatum;
/
*
if so, its value
*
/
int
nNodes;
/
*
number of nodes for new inner tuple
*
/
Datum
*
nodeLabels;
/
*
their labels (or NULL for no labels)
*
/
int
*
mapTuplesToNodes;
/
*
node index for each leaf tuple
*
/
Datum
*
leafTupleDatums;
/
*
datum to store in each new leaf tuple
*
/
} spgPickSplitOut;
nTuples
is the number of leaf tuples provided.
datums
is an array of their datum values.
level
is the current level that all the leaf tuples share, which will become the level of the new inner
tuple.
Set
hasPrefix
to indicate whether the new inner tuple should have a prefix, and if so set
prefixDatum
to the prefix value. Set
nNodes
to indicate the number of nodes thatthenew inner
tuple will contain, and set
nodeLabels
to an array of their label values. (If the nodes do not re-
quire labels, set
nodeLabels
to NULL;seeSection 57.4.2for details.) Set
mapTuplesToNodes
toan arraythat gives the index(from zero) of the node that eachleaf tuple should be assignedto.
Set
leafTupleDatums
to an array of the values to be stored in the new leaf tuples (these will
be the same as the input
datums
if the operator class does not modify datums from one level
to the next). Note that the
picksplit
function is responsible for palloc’ing the
nodeLabels
,
mapTuplesToNodes
and
leafTupleDatums
arrays.
If more than one leaf tuple is supplied, it is expected that the
picksplit
function will classify
them into more than one node; otherwise it is not possible to split the leaf tuples across multiple
pages, which is the ultimate purpose of this operation. Therefore, if the
picksplit
function
ends up placing all the leaf tuples in the same node, the core SP-GiST code will override that
1958
How to add a photo to a pdf document - insert images into PDF in C#.net, ASP.NET, MVC, Ajax, WinForms, WPF
Sample C# code to add image, picture, logo or digital photo into PDF document page using PDF page editor control
how to add an image to a pdf in acrobat; adding images to pdf
How to add a photo to a pdf document - VB.NET PDF insert image library: insert images into PDF in vb.net, ASP.NET, MVC, Ajax, WinForms, WPF
Guide VB.NET Programmers How to Add Images in PDF Document
how to add image to pdf in acrobat; how to add an image to a pdf in reader
Chapter 57. SP-GiST Indexes
decision and generate an inner tuple in which the leaf tuples are assigned at random to several
identically-labeled nodes. Such atuple is marked
allTheSame
tosignifythat this has happened.
The
choose
and
inner_consistent
functions must take suitable care with such inner tuples.
See Section 57.4.3 for more information.
picksplit
can be applied to a single leaf tuple only in the case that the
config
function set
longValuesOK
to true and a larger-than-a-page input value has been supplied. In this case the
pointof theoperationis to stripoff a prefix and produce a new, shorter leaf datum value. The call
will be repeated until a leaf datum short enough to fit on a page has been produced. See Section
57.4.1for more information.
inner_consistent
Returns set of nodes (branches) to follow during tree search.
The SQL declaration of the function must look like this:
CREATE FUNCTION my_inner_consistent(internal, internal) RETURNS void ...
The firstargumentis a pointer toa
spgInnerConsistentIn
Cstruct, containing inputdata for
the function. The second argument is a pointer to a
spgInnerConsistentOut
Cstruct, which
the function must fill with result data.
typedef struct spgInnerConsistentIn
{
ScanKey
scankeys;
/
*
array of operators and comparison values
*
/
int
nkeys;
/
*
length of array
*
/
Datum
reconstructedValue;
/
*
value reconstructed at parent
*
/
int
level;
/
*
current level (counting from zero)
*
/
bool
returnData;
/
*
original data must be returned?
*
/
/
*
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)
*
/
} spgInnerConsistentIn;
typedef struct spgInnerConsistentOut
{
int
nNodes;
/
*
number of child nodes to be visited
*
/
int
*
nodeNumbers;
/
*
their indexes in the node array
*
/
int
*
levelAdds;
/
*
increment level by this much for each
*
/
Datum
*
reconstructedValues;
/
*
associated reconstructed values
*
/
} spgInnerConsistentOut;
Thearray
scankeys
,of length
nkeys
,describes the indexsearch condition(s). These conditions
are combined with AND — only index entries that satisfy all of them are interesting. (Note that
nkeys
=0 implies that all index entries satisfy the query.) Usually the consistent function only
cares about the
sk_strategy
and
sk_argument
fields of each array entry, which respectively
give the indexable operator and comparison value. In particular it is not necessary to check
sk_flags
to see if the comparison value is NULL, because the SP-GiST core code will filter
out such conditions.
reconstructedValue
is the value reconstructed for the parent tuple; it
is
(Datum) 0
at the root level or if the
inner_consistent
function did not provide a value
at the parent level.
level
is the current inner tuple’s level, starting at zero for the root level.
returnData
is
true
if reconstructed data is required for this query; this will only be so if the
config
function asserted
canReturnData
.
allTheSame
is true if the current inner tuple is
marked “all-the-same”; in this case all the nodes have the same label (if any) and so either all
1959
VB.NET Image: Mark Photo, Image & Document with Polygon Annotation
What's more, if coupled with .NET PDF document imaging add-on, the VB.NET annotator SDK can easily generate polygon annotation on PDF file without using
how to add an image to a pdf file; add png to pdf preview
VB.NET Image: Image Cropping SDK to Cut Out Image, Picture and
SDK; VB.NET image cropping method to crop picture / photo; VB.NET image cropping control add-on needs a PC com is professional provider of document, content and
adding images to a pdf document; add picture to pdf preview
Chapter 57. SP-GiST Indexes
or none of them match the query (see Section 57.4.3).
hasPrefix
is true if the current inner
tuple contains a prefix; if so,
prefixDatum
is its value.
nNodes
is the number of child nodes
contained in the inner tuple, and
nodeLabels
is an array of their label values, or NULL if the
nodes do not have labels.
nNodes
must be set to the number of child nodes that need to be visited by the search, and
nodeNumbers
must be set toan arrayof their indexes. If the operator class keeps trackof levels,
set
levelAdds
toan array of the level increments requiredwhen descending to each node to be
visited. (Often these increments will be the same for all the nodes, but that’s not necessarily
so, so an array is used.) If value reconstruction is needed, set
reconstructedValues
to
an array of the values reconstructed for each child node to be visited; otherwise, leave
reconstructedValues
as NULL. Note that the
inner_consistent
function is responsible
for palloc’ing the
nodeNumbers
,
levelAdds
and
reconstructedValues
arrays.
leaf_consistent
Returns true if a leaf tuple satisfies a query.
The SQL declaration of the function must look like this:
CREATE FUNCTION my_leaf_consistent(internal, internal) RETURNS bool ...
The first argument is a pointer to a
spgLeafConsistentIn
Cstruct, containing input data for
the function. The second argument is a pointer to a
spgLeafConsistentOut
Cstruct, which
the function must fill with result data.
typedef struct spgLeafConsistentIn
{
ScanKey
scankeys;
/
*
array of operators and comparison values
*
/
int
nkeys;
/
*
length of array
*
/
Datum
reconstructedValue;
/
*
value reconstructed at parent
*
/
int
level;
/
*
current level (counting from zero)
*
/
bool
returnData;
/
*
original data must be returned?
*
/
Datum
leafDatum;
/
*
datum in leaf tuple
*
/
} spgLeafConsistentIn;
typedef struct spgLeafConsistentOut
{
Datum
leafValue;
/
*
reconstructed original data, if any
*
/
bool
recheck;
/
*
set true if operator must be rechecked
*
/
} spgLeafConsistentOut;
Thearray
scankeys
,of length
nkeys
,describes the indexsearch condition(s). These conditions
are combinedwith AND— only index entries thatsatisfyallof them satisfy the query. (Note that
nkeys
=0 implies that all index entries satisfy the query.) Usually the consistent function only
cares about the
sk_strategy
and
sk_argument
fields of each array entry, which respectively
give the indexable operator and comparison value. In particular it is not necessary to check
sk_flags
to see if the comparison value is NULL, because the SP-GiST core code will filter
out such conditions.
reconstructedValue
is the value reconstructed for the parent tuple; it
is
(Datum) 0
at the root level or if the
inner_consistent
function did not provide a value
at the parent level.
level
is the current leaf tuple’s level, starting at zero for the root level.
returnData
is
true
if reconstructed data is required for this query; this will only be so if the
config
function asserted
canReturnData
.
leafDatum
is the key value stored in the current
leaf tuple.
The function must return
true
if the leaf tuple matches the query, or
false
if not. In the
true
case, if
returnData
is
true
then
leafValue
must be set to the value originally supplied to be
1960
VB.NET Image: Image Scaling SDK to Scale Picture / Photo
this VB.NET image scaling control add-on, we can only scale one image / picture / photo at a RasterEdge.com is professional provider of document, content and
add jpg to pdf file; acrobat add image to pdf
C# Image: How to Add Antique & Vintage Effect to Image, Photo
C#.NET antique effect creating control add-on is widely used in modern photo editors, which powerful & profession imaging controls, PDF document, tiff files
add image to pdf preview; add signature image to pdf acrobat
Chapter 57. SP-GiST Indexes
indexed for this leaf tuple. Also,
recheck
may be set to
true
if the match is uncertain and so
the operator(s) must be re-applied to the actual heap tuple to verify the match.
All the SP-GiST support methods are normally called in a short-lived memory context; that is,
CurrentMemoryContext
will be reset after processing of each tuple. It is therefore not very impor-
tant to worry about pfree’ing everything you palloc. (The
config
method is an exception: it should
try to avoid leaking memory. But usually the
config
method need do nothing but assign constants
into the passed parameter struct.)
If the indexed column is of a collatable data type, the index collation will be passed to all the support
methods, using the standard
PG_GET_COLLATION()
mechanism.
57.4. Implementation
This section covers implementation details and other tricks that are useful for implementers of SP-
GiST operator classes to know.
57.4.1. SP-GiST Limits
Individual leaf tuples and inner tuples must fit on a single index page (8KB by default). Therefore,
when indexing values of variable-length data types, long values can only be supported by methods
such as radix trees, in which each level of the tree includes a prefix that is short enough to fit on a
page, and the final leaf level includes a suffix also short enough to fit on a page. The operator class
should set
longValuesOK
to TRUE only if it is prepared to arrange for this to happen. Otherwise,
the SP-GiST core will reject any request to index a value that is too large to fit on an index page.
Likewise, it is the operator class’s responsibility that inner tuples do not grow too large to fit on an
index page; this limits the number of child nodes that can be used in one inner tuple, as well as the
maximum size of a prefixvalue.
Another limitation is that when an inner tuple’s node points to a set of leaf tuples, those tuples must
all be inthe same index page. (This is a design decision to reduce seeking and save space in the links
thatchain suchtuples together.) If the setof leaf tuples grows toolargefor a page, a split is performed
and an intermediateinner tuple is inserted. For this tofixtheproblem, the new inner tuple must divide
the set of leaf values into more thanone node group. If the operator class’s
picksplit
functionfails
to do that, the SP-GiST core resorts to extraordinary measures described in Section 57.4.3.
57.4.2. SP-GiST Without Node Labels
Some tree algorithms use a fixed set of nodes for each inner tuple; for example, in a quad-tree there
are always exactly four nodes corresponding to the four quadrants around the inner tuple’s centroid
point. In such a case the code typically works with the nodes by number, and there is no need for
explicit node labels. To suppress node labels (andtherebysave some space), the
picksplit
function
can return NULL for the
nodeLabels
array. This will in turn result in
nodeLabels
being NULL
during subsequent calls to
choose
and
inner_consistent
.In principle, node labels could be used
for some inner tuples and omitted for others in the same index.
When working with an inner tuple having unlabeled nodes, it is an error for
choose
to return
spgAddNode
,since the set of nodes is supposed to be fixed in such cases. Also, there is no pro-
vision for generating an unlabeled node in
spgSplitTuple
actions, since it is expected that an
spgAddNode
action will be needed as well.
1961
VB.NET Image: Image Resizer Control SDK to Resize Picture & Photo
VB.NET Image & Photo Resizing Overview. The practical VB.NET image resizer control add-on, can I powerful & profession imaging controls, PDF document, image to
how to add image to pdf acrobat; add photo to pdf
VB.NET Image: How to Save Image & Print Image Using VB.NET
NET programmers save & print image / photo / picture from NET method and demo code to add image printing printing multi-page document files, like PDF and Word
how to add an image to a pdf in preview; add picture to pdf
Chapter 57. SP-GiST Indexes
57.4.3. “All-the-same” Inner Tuples
The SP-GiST core can override the results of the operator class’s
picksplit
function when
picksplit
fails to divide the supplied leaf values into at least two node categories. When this
happens, the new inner tuple is created with multiple nodes that each have the same label (if any)
that
picksplit
gave to the one node it did use, and the leaf values are divided at random among
these equivalent nodes. The
allTheSame
flag is set on the inner tuple to warn the
choose
and
inner_consistent
functions that the tuple does not have the node set that they might otherwise
expect.
When dealing with an
allTheSame
tuple, a
choose
result of
spgMatchNode
is interpreted to mean
that the new value can be assigned to any of the equivalent nodes; the core code will ignore the
supplied
nodeN
value and descend into one of the nodes at random (so as to keep the tree balanced).
It is an error for
choose
to return
spgAddNode
,since that would make the nodes not all equivalent;
the
spgSplitTuple
action must be used if the value to be inserted doesn’t matchthe existing nodes.
When dealing with an
allTheSame
tuple, the
inner_consistent
function should return either all
or none of the nodes as targets for continuing the indexsearch, since they are allequivalent. This may
or maynotrequire any special-case code, dependingon howmuch the
inner_consistent
function
normally assumes about the meaning of the nodes.
57.5. Examples
The PostgreSQL sourcedistributionincludes severalexamples of indexoperator classes for SP-GiST.
The core system currently provides radix trees over text columns and two types of trees over points:
quad-tree and k-d tree. Look into
src/backend/access/spgist/
to see the code.
1962
VB.NET Image: Tutorial for Flipping Image Using Our .NET Image SDK
version of .NET imaging SDK and add the following dlls a mirror reflection of the photo on the powerful & profession imaging controls, PDF document, tiff files
add photo to pdf online; how to add a picture to a pdf file
VB.NET PDF remove image library: remove, delete images from PDF in
removing vector image, graphic picture, digital photo, scanned signature Add necessary references code extract all images and delete them all from PDF document.
add image to pdf online; how to add a picture to a pdf document
Chapter 58. GIN Indexes
58.1. Introduction
GIN stands for Generalized Inverted Index. GIN is designed for handling cases where the items to be
indexed are composite values, and the queries to be handled by the index need to search for element
values that appear within the composite items. For example, the items could be documents, and the
queries could be searches for documents containing specific words.
We use the word item to refer to a composite value that is to be indexed, and the word key to refer to
an element value. GIN always stores and searches for keys, not item values per se.
AGIN index stores a set of (key, posting list) pairs, where a posting list is a set of row IDs in which
the key occurs. The same row ID can appear in multiple posting lists, since an item can contain more
than one key. Each keyvalue is stored only once, so a GIN index is very compact for cases where the
same key appears many times.
GIN is generalized in the sense that the GIN access method code does not need to know the spe-
cific operations that it accelerates. Instead, it uses custom strategies defined for particular data types.
The strategy defines how keys are extracted from indexed items and query conditions, and how to
determine whether a row that contains some of the key values in a queryactually satisfies the query.
One advantage of GIN is that it allows the development of custom data types with the appropriate
access methods, by an expert in the domain of the data type, rather than a database expert. This is
much the same advantage as using GiST.
The GIN implementation in PostgreSQL is primarily maintained by Teodor Sigaev and Oleg Bar-
tunov. There is more information about GIN on their website
1
.
58.2. Built-in Operator Classes
The core PostgreSQL distribution includes the GIN operator classes shown in Table 58-1. (Some of
the optional modules described in Appendix F provide additional GIN operator classes.)
Table 58-1. Built-in GIN Operator Classes
Name
Indexed Data Type
Indexable Operators
_abstime_ops
abstime[]
&& <@ = @>
_bit_ops
bit[]
&& <@ = @>
_bool_ops
boolean[]
&& <@ = @>
_bpchar_ops
character[]
&& <@ = @>
_bytea_ops
bytea[]
&& <@ = @>
_char_ops
"char"[]
&& <@ = @>
_cidr_ops
cidr[]
&& <@ = @>
_date_ops
date[]
&& <@ = @>
1. http://www.sai.msu.su/~megera/wiki/Gin
1963
Chapter 58. GIN Indexes
Name
Indexed Data Type
Indexable Operators
_float4_ops
float4[]
&& <@ = @>
_float8_ops
float8[]
&& <@ = @>
_inet_ops
inet[]
&& <@ = @>
_int2_ops
smallint[]
&& <@ = @>
_int4_ops
integer[]
&& <@ = @>
_int8_ops
bigint[]
&& <@ = @>
_interval_ops
interval[]
&& <@ = @>
_macaddr_ops
macaddr[]
&& <@ = @>
_money_ops
money[]
&& <@ = @>
_name_ops
name[]
&& <@ = @>
_numeric_ops
numeric[]
&& <@ = @>
_oid_ops
oid[]
&& <@ = @>
_oidvector_ops
oidvector[]
&& <@ = @>
_reltime_ops
reltime[]
&& <@ = @>
_text_ops
text[]
&& <@ = @>
_time_ops
time[]
&& <@ = @>
_timestamp_ops
timestamp[]
&& <@ = @>
_timestamptz_ops
timestamp with time
zone[]
&& <@ = @>
_timetz_ops
time with time zone[]
&& <@ = @>
_tinterval_ops
tinterval[]
&& <@ = @>
_varbit_ops
bit varying[]
&& <@ = @>
_varchar_ops
character varying[]
&& <@ = @>
jsonb_ops
jsonb
??& ?| @>
jsonb_path_ops
jsonb
@>
tsvector_ops
tsvector
@@ @@@
Of the two operator classes for type
jsonb
,
jsonb_ops
is the default.
jsonb_path_ops
supports
fewer operators but offers better performance for those operators. See Section 8.14.4 for details.
58.3. Extensibility
The GIN interface has a high level of abstraction, requiring the access method implementer only to
implement the semantics of the data type being accessed. The GIN layer itself takes care of concur-
rency, logging and searching the tree structure.
All it takes to get a GIN access method working is to implement a few user-defined methods, which
define the behavior of keys in the tree and the relationships between keys, indexed items, and index-
able queries. In short, GIN combines extensibility with generality, code reuse, and a clean interface.
There are three methods that an operator class for GIN must provide:
int compare(Datum a, Datum b)
Compares two keys (not indexed items!) and returns an integer less than zero, zero, or greater
than zero, indicating whether the first key is less than, equal to, or greater than the second. Null
1964
Chapter 58. GIN Indexes
keys are never passed to this function.
Datum
*
extractValue(Datum itemValue, int32
*
nkeys, bool
**
nullFlags)
Returns a palloc’d array of keys given an item to be indexed. The number of returned keys must
be stored into
*
nkeys
.If any of the keys can be null, also palloc an array of
*
nkeys bool
fields, store its address at
*
nullFlags
,and set these null flags as needed.
*
nullFlags
can be
left
NULL
(its initial value) if all keys are non-null. The return value can be
NULL
if the item
contains no keys.
Datum
*
extractQuery(Datum query, int32
*
nkeys, StrategyNumber n, bool
**
pmatch, Pointer
**
extra_data, bool
**
nullFlags, int32
*
searchMode)
Returns a palloc’d array of keys given a value to be queried; that is,
query
is the value on
the right-hand side of an indexable operator whose left-hand side is the indexed column.
n
is the strategy number of the operator within the operator class (see Section 35.14.2). Often,
extractQuery
will need to consult
n
to determine the data type of
query
and the method it
should use to extract key values. The number of returned keys must be stored into
*
nkeys
.If
any of the keys can be null, also palloc an array of
*
nkeys bool
fields, store its address at
*
nullFlags
,andset these null flags as needed.
*
nullFlags
canbe left
NULL
(its initialvalue)
if all keys are non-null. The return value can be
NULL
if the
query
contains no keys.
searchMode
is an output argument that allows
extractQuery
to specify details about how
the search will be done. If
*
searchMode
is set to
GIN_SEARCH_MODE_DEFAULT
(which is the
value it is initialized to before call), only items that match at least one of the returned keys are
consideredcandidate matches. If
*
searchMode
issetto
GIN_SEARCH_MODE_INCLUDE_EMPTY
,
then in addition to items containing at least one matching key, items that contain no keys at all
are considered candidate matches. (This mode is useful for implementing is-subset-of operators,
for example.) If
*
searchMode
is set to
GIN_SEARCH_MODE_ALL
,then all non-null items in the
index are considered candidate matches, whether they match any of the returned keys or not.
(This mode is much slower than the other two choices, since it requires scanning essentially the
entire index, but it may be necessaryto implement corner cases correctly. An operator that needs
this mode in most cases is probablynota good candidate for aGIN operator class.) The symbols
to use for setting this mode are defined in
access/gin.h
.
pmatch
is anoutputargument for use whenpartialmatchis supported. Touse it,
extractQuery
must allocate an array of
*
nkeys
booleans and store its address at
*
pmatch
.Each element of
the array should be set to TRUE if the corresponding key requires partial match, FALSE if
not. If
*
pmatch
is set to
NULL
then GIN assumes partial match is not required. The variable is
initialized to
NULL
before call, so this argument can simply be ignored by operator classes that
do not support partial match.
extra_data
is an output argument that allows
extractQuery
to pass additional data to the
consistent
and
comparePartial
methods. To use it,
extractQuery
must allocate an ar-
ray of
*
nkeys
Pointers and store its address at
*
extra_data
,then store whatever it wants
to into the individual pointers. The variable is initialized to
NULL
before call, so this argument
can simply be ignored by operator classes that do not require extra data. If
*
extra_data
is
set, the whole array is passed to the
consistent
method, and the appropriate element to the
comparePartial
method.
An operator class must also provide a function to check if an indexed item matches the query. It
comes in two flavors, a boolean
consistent
function, and a ternary
triConsistent
function.
triConsistent
covers the functionality of both, soproviding triConsistentalone is sufficient. How-
ever, if the boolean variantissignificantly cheaper to calculate, itcanbeadvantageous toprovideboth.
If only the boolean variantis provided, some optimizations that dependonrefutingindex items before
fetching all the keys are disabled.
1965
Chapter 58. GIN Indexes
bool consistent(bool check[], StrategyNumber n, Datum query, int32 nkeys,
Pointer extra_data[], bool
*
recheck, Datum queryKeys[], bool nullFlags[])
Returns TRUE if an indexed item satisfies the query operator with strategy number
n
(or might
satisfy it, if the recheck indication is returned). This function does not have direct access to
the indexed item’s value, since GIN does not store items explicitly. Rather, what is available is
knowledge about which key values extractedfrom thequery appear in a given indexeditem. The
check
array has length
nkeys
,which is the same as the number of keys previously returned
by
extractQuery
for this
query
datum. Each element of the
check
array is TRUE if the
indexed item contains the corresponding query key, i.e., if (check[i] == TRUE) the i-th key of
the
extractQuery
result array is present in the indexed item. The original
query
datum is
passed in case the
consistent
method needs to consult it, and so are the
queryKeys[]
and
nullFlags[]
arrays previously returned by
extractQuery
.
extra_data
is the extra-data
array returned by
extractQuery
,or
NULL
if none.
When
extractQuery
returns a null key in
queryKeys[]
, the corresponding
check[]
el-
ement is TRUE if the indexed item contains a null key; that is, the semantics of
check[]
are like
IS NOT DISTINCT FROM
.The
consistent
function can examine the corresponding
nullFlags[]
element if it needs to tell the difference between a regular value match and a null
match.
On success,
*
recheck
should be set to TRUE if the heap tuple needs to be rechecked against
the query operator, or FALSE if the index test is exact. That is, a FALSE return value guarantees
that the heaptuple does notmatch the query; a TRUE return value with
*
recheck
set toFALSE
guarantees that the heap tuple does match the query; and a TRUE return value with
*
recheck
set to TRUE means that the heap tuple might match the query, so it needs to be fetched and
rechecked by evaluating the query operator directly against the originally indexed item.
GinTernaryValue triConsistent(GinTernaryValue check[], StrategyNumber n,
Datum query, int32 nkeys, Pointer extra_data[], Datum queryKeys[], bool
nullFlags[])
triConsistent
is similar to
consistent
, but instead of a boolean
check[]
, there are
three possible values for each key:
GIN_TRUE
,
GIN_FALSE
and
GIN_MAYBE
.
GIN_FALSE
and
GIN_TRUE
have the same meaning as regular boolean values.
GIN_MAYBE
means that
the presence of that key is not known. When
GIN_MAYBE
values are present, the function
should only return GIN_TRUE if the item matches whether or not the index item contains the
corresponding query keys. Likewise, the function must return GIN_FALSE only if the item
does not match, whether or not it contains the GIN_MAYBE keys. If the result depends on the
GIN_MAYBE entries, i.e. the match cannot be confirmed or refuted based on the known query
keys, the function must return GIN_MAYBE.
When there are no GIN_MAYBE values in the
check
vector,
GIN_MAYBE
return value is equiv-
alent of setting
recheck
flag in the boolean
consistent
function.
Optionally, an operator class for GIN can supply the following method:
int comparePartial(Datum partial_key, Datum key, StrategyNumber n, Pointer
extra_data)
Compare a partial-match query key to an index key. Returns an integer whose sign indicates the
result: less than zero means the index key does not match the query, but the index scan should
continue; zero means that the index key does match the query; greater than zero indicates that
the index scan should stop because no more matches are possible. The strategy number
n
of the
operator that generated the partial match query is provided, in case its semantics are needed to
determine when to end the scan. Also,
extra_data
is the corresponding element of the extra-
data arraymade by
extractQuery
,or
NULL
if none. Nullkeys are never passedtothis function.
1966
Chapter 58. GIN Indexes
To support “partial match” queries, an operator class must provide the
comparePartial
method,
and its
extractQuery
method must set the
pmatch
parameter when a partial-match query is en-
countered. See Section 58.4.2 for details.
The actual data types of the various
Datum
values mentioned above vary depending on the opera-
tor class. The item values passed to
extractValue
are always of the operator class’s input type,
and all key values must be of the class’s
STORAGE
type. The type of the
query
argument passed to
extractQuery
,
consistent
and
triConsistent
is whatever is specified as the right-hand input
type of the class member operator identified bythe strategy number. This need not be the same as the
item type, so long as keyvalues of the correct type canbe extracted from it.
58.4. Implementation
Internally, a GIN index contains a B-tree index constructed over keys, where each key is an element
of one or more indexed items (a member of an array, for example) and where each tuple in a leaf
page contains either a pointer to a B-tree of heap pointers (a “posting tree”), or a simple list of heap
pointers (a “posting list”) when the list is small enough to fit into a single index tuple along with the
key value.
As of PostgreSQL 9.1, null key values can be included in the index. Also, placeholder nulls are
includedin the index for indexed items that are null or contain no keys according to
extractValue
.
This allows searches that should find empty items to do so.
MulticolumnGINindexes areimplementedbybuildinga singleB-tree over composite values (column
number, key value). The key values for different columns canbe of different types.
58.4.1. GIN Fast Update Technique
Updating a GIN index tends to be slow because of the intrinsic nature of inverted indexes: inserting
or updating one heap row can cause many inserts into the index (one for each key extracted from the
indexed item). As of PostgreSQL 8.4, GIN is capable of postponing much of this work by inserting
new tuples into a temporary, unsorted list of pending entries. When the table is vacuumed, or if
the pending list becomes too large (larger than work_mem), the entries are moved to the main GIN
data structure using the same bulk insert techniques used during initial index creation. This greatly
improves GIN index update speed, even counting the additional vacuum overhead. Moreover the
overhead workcan be done by a background process instead of in foreground query processing.
The main disadvantage of this approach is that searches must scan the list of pending entries in ad-
dition to searching the regular index, and so a large list of pending entries will slow searches signif-
icantly. Another disadvantage is that, while most updates are fast, an update that causes the pending
list to become “too large” will incur an immediate cleanup cycle and thus be much slower than other
updates. Proper use of autovacuum can minimize both of these problems.
If consistent response time ismoreimportant thanupdatespeed, use of pending entries can be disabled
by turningoff the
FASTUPDATE
storage parameter for a GINindex. See CREATE INDEXfor details.
58.4.2. Partial Match Algorithm
GIN can support “partial match” queries, in which the query does not determine an exact match for
oneor morekeys, but the possiblematchesfall within areasonably narrow range of keyvalues (within
1967
Documents you may be interested
Documents you may be interested