pdf viewer dll for c# : Add a picture to a pdf application software utility azure windows web page visual studio postgresql-9.4-A4103-part2728

Chapter 35. Extending SQL
);
When you define a new base type, PostgreSQL automatically provides support for arrays of that
type. The array type typically has the same name as the base type with the underscore character (
_
)
prepended.
Oncethe data type exists, we can declare additionalfunctions toprovide useful operations on the data
type. Operators can then be defined atop the functions, and if needed, operator classes can be created
to support indexing of the data type. These additional layers are discussed in following sections.
If the values of your data type vary in size (in internal form), you should make the data type TOAST-
able (see Section 59.2). You should do this even if the data are always too small to be compressed or
stored externally, because TOAST can save space on small data too, by reducing header overhead.
To do this, the internalrepresentationmustfollowthe standard layout for variable-length data:thefirst
four bytes must be a
char[4]
field which is never accessed directly (customarily named
vl_len_
).
You must use
SET_VARSIZE()
to store the size of the datum in this field and
VARSIZE()
to retrieve
it. The C functions operating on the data type must always be careful to unpack any toasted values
they are handed, by using
PG_DETOAST_DATUM
.(This detail is customarily hidden by defining type-
specific
GETARG_DATATYPE_P
macros.) Then, when running the
CREATE TYPE
command, specify
the internal length as
variable
and select the appropriate storage option.
If the alignment is unimportant (either just for a specific function or because the data type specifies
byte alignment anyway) then it’s possible to avoid some of the overhead of
PG_DETOAST_DATUM
.
You can use
PG_DETOAST_DATUM_PACKED
instead (customarily hidden by defining a
GETARG_DATATYPE_PP
macro) and using the macros
VARSIZE_ANY_EXHDR
and
VARDATA_ANY
to
access a potentially-packed datum. Again, the data returned by these macros is not aligned even if
the data type definition specifies an alignment. If the alignment is important you must go through the
regular
PG_DETOAST_DATUM
interface.
Note:Older code frequently declares
vl_len_
as an
int32
fieldinsteadof
char[4]
.Thisis OKas
longas thestruct definitionhasother fieldsthat haveat least
int32
alignment. But it is dangerous
to usesuch a struct definition when working with apotentially unaligned datum; the compiler may
takeit as licensetoassumethe datum actually is aligned, leading to coredumps on architectures
that are strict about alignment.
For further details see the description of the CREATE TYPE command.
35.12. User-defined Operators
Every operator is “syntactic sugar” for a call to an underlying function that does the real work; so
youmust first create the underlyingfunction before youcan create the operator. However, an operator
is not merely syntactic sugar, because it carries additional information that helps the query planner
optimize queries that use the operator. The next section will be devoted to explaining that additional
information.
PostgreSQL supports left unary, right unary, and binary operators. Operators can be overloaded; that
is, the same operator name can be used for different operators that have different numbers and types
of operands. When a query is executed, the system determines the operator to call from the number
and types of the provided operands.
958
Add a picture 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
add image to pdf acrobat reader; how to add image to pdf file
Add a picture 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
how to add image to pdf acrobat; acrobat add image to pdf
Chapter 35. Extending SQL
Here is an example of creating an operator for adding two complex numbers. We assume we’ve
already created the definition of type
complex
(see Section 35.11). First we need afunction that does
the work, then we can define the operator:
CREATE FUNCTION complex_add(complex, complex)
RETURNS complex
AS ’
filename
’, ’complex_add’
LANGUAGE C IMMUTABLE STRICT;
CREATE OPERATOR + (
leftarg = complex,
rightarg = complex,
procedure = complex_add,
commutator = +
);
Now we could execute a query like this:
SELECT (a + b) AS c FROM test_complex;
c
-----------------
(5.2,6.05)
(133.42,144.95)
We’ve shown how to create a binary operator here. To create unary operators, just omit one of
leftarg
(for left unary) or
rightarg
(for right unary). The
procedure
clause and the argument
clauses are the only required items in
CREATE OPERATOR
.The
commutator
clause shown in the
example is an optional hint tothe queryoptimizer. Further details about
commutator
andother opti-
mizer hints appear in the next section.
35.13. Operator Optimization Information
APostgreSQL operator definition can include several optional clauses that tell the system useful
things about how the operator behaves. These clauses should be provided whenever appropriate, be-
cause theycanmake for considerable speedups inexecutionof queries thatuse the operator. Butif you
provide them, you must be sure that they are right! Incorrect use of an optimization clause can result
in slow queries, subtly wrong output, or other Bad Things. You can always leave out an optimization
clause if you are not sure about it; the only consequence is that queries might run slower than they
need to.
Additionaloptimizationclauses mightbeadded infuture versions of PostgreSQL. The ones described
here are all the ones that release 9.4.7 understands.
35.13.1.
COMMUTATOR
The
COMMUTATOR
clause, if provided, names anoperator that is the commutator of the operator being
defined. We say that operator A is the commutator of operator B if (x A y) equals (y B x) for all
possible inputvalues x, y. Notice that B is also the commutator of A. For example, operators
<
and
>
959
C# TIFF: How to Insert & Burn Picture/Image into TIFF Document
Support adding image or picture to an existing or new new REImage(@"c:\ logo.png"); // add the image powerful & profession imaging controls, PDF document, tiff
how to add picture to pdf; add jpg to pdf acrobat
VB.NET Image: Image Cropping SDK to Cut Out Image, Picture and
VB.NET image cropper control SDK; VB.NET image cropping method to crop picture / photo; you can adjust the size of created cropped image file, add antique effect
adding image to pdf file; how to add a picture to a pdf document
Chapter 35. Extending SQL
for a particular datatype are usuallyeach others’ commutators, andoperator
+
is usuallycommutative
with itself. But operator
-
is usually not commutative with anything.
The left operand type of a commutable operator is the same as the right operand type of its commuta-
tor, and vice versa. So the name of the commutator operator is all that PostgreSQL needs to be given
to look up the commutator, and that’s all that needs to be provided in the
COMMUTATOR
clause.
It’s critical to provide commutator information for operators that will be used in indexes and join
clauses, because this allows the query optimizer to “flip around” such aclause to the forms needed for
different plan types. For example, consider a query with a WHERE clause like
tab1.x = tab2.y
,
where
tab1.x
and
tab2.y
are of a user-defined type, and suppose that
tab2.y
is indexed. The
optimizer cannot generate an index scan unless it can determine how to flip the clause around to
tab2.y = tab1.x
,because the index-scan machinery expects to see the indexed column on the left
of the operator it is given. PostgreSQL will not simply assume that this is a valid transformation —
the creator of the
=
operator must specify that it is valid, by marking the operator with commutator
information.
When you are defining a self-commutative operator, you just do it. When you are defining a pair of
commutative operators, things are a little trickier:how can the first one to be defined refer tothe other
one, which you haven’t defined yet? There are two solutions tothis problem:
One way is to omit the
COMMUTATOR
clause in the first operator that you define, and then provide
one inthe second operator’s definition. Since PostgreSQL knows that commutative operators come
in pairs, when it sees the second definition it will automatically go back and fill in the missing
COMMUTATOR
clause in the first definition.
The other, more straightforward way is just to include
COMMUTATOR
clauses in both definitions.
When PostgreSQL processes the first definition and realizes that
COMMUTATOR
refers to a nonex-
istent operator, the system will make a dummy entry for that operator in the system catalog. This
dummy entry will have valid data only for the operator name, left and right operand types, and
result type, since that’s all that PostgreSQL can deduce at this point. The first operator’s catalog
entry will linkto this dummyentry. Later, when you define thesecondoperator, the system updates
the dummy entry with the additional information from the second definition. If you try to use the
dummy operator before it’s been filled in, you’ll just get an error message.
35.13.2.
NEGATOR
The
NEGATOR
clause, if provided, names an operator that is the negator of the operator being defined.
We say that operator A is the negator of operator B if both return Boolean results and (x A y) equals
NOT (x B y) for all possible inputs x, y. Notice that B is also the negator of A. For example,
<
and
>=
are a negator pair for most data types. An operator can never validly be its own negator.
Unlike commutators, a pair of unary operators could validly be marked as each other’s negators; that
would mean (A x) equals NOT (B x) for all x, or the equivalent for right unary operators.
Anoperator’s negator must have the same left and/or rightoperandtypes as the operator tobe defined,
so just as with
COMMUTATOR
,only the operator name need be givenin the
NEGATOR
clause.
Providing a negator is very helpful to the query optimizer since it allows expressions like
NOT (x
= y)
to be simplified into
x <> y
.This comes up more often than you might think, because
NOT
operations can be inserted as a consequence of other rearrangements.
Pairs of negator operators can be defined using the same methods explained above for commutator
pairs.
960
VB.NET TIFF: How to Draw Picture & Write Text on TIFF Document in
drawing As RaterEdgeDrawing = New RaterEdgeDrawing() drawing.Picture = "RasterEdge" drawing provide powerful & profession imaging controls, PDF document, tiff
add picture pdf; add picture to pdf
VB.NET Image: VB.NET Codes to Add Antique Effect to Image with .
mature technology to replace a picture's original colors add the glow and noise, and add a little powerful & profession imaging controls, PDF document, image
adding jpg to pdf; add an image to a pdf with acrobat
Chapter 35. Extending SQL
35.13.3.
RESTRICT
The
RESTRICT
clause, if provided, names a restriction selectivity estimation function for theoperator.
(Note that this is a function name, not an operator name.)
RESTRICT
clauses only make sense for
binary operators that return
boolean
.The idea behind a restriction selectivity estimator is to guess
what fraction of the rows in a table will satisfy a
WHERE
-clause conditionof the form:
column OP constant
for the current operator and a particular constant value. This assists the optimizer by giving it some
idea of how many rows will be eliminated by
WHERE
clauses that have this form. (What happens if
the constant is on the left, you might be wondering? Well, that’s one of the things that
COMMUTATOR
is for...)
Writing new restriction selectivity estimation functions is far beyond the scope of this chapter, but
fortunately you can usually just use one of the system’s standard estimators for many of your own
operators. These are the standard restriction estimators:
eqsel
for
=
neqsel
for
<>
scalarltsel
for
<
or
<=
scalargtsel
for
>
or
>=
It might seem a little odd that these are the categories, but they make sense if you think about it.
=
will typically accept only a small fraction of the rows in a table;
<>
will typically reject only a
small fraction.
<
will accept a fraction that depends on where the given constant falls in the range
of values for that table column (which, it just so happens, is information collected by
ANALYZE
and
made available to the selectivity estimator).
<=
will accept a slightly larger fraction than
<
for the
same comparison constant, but they’re close enough to not be worth distinguishing, especially since
we’re not likely to do better than a rough guess anyhow. Similar remarks apply to
>
and
>=
.
You can frequently get away with using either
eqsel
or
neqsel
for operators that have very high or
very low selectivity, even if they aren’t really equality or inequality. For example, the approximate-
equality geometric operators use
eqsel
on the assumption that they’ll usually only match a small
fraction of the entries in a table.
You can use
scalarltsel
and
scalargtsel
for comparisons on data types that have
some sensible means of being converted into numeric scalars for range comparisons. If
possible, add the data type to those understood by the function
convert_to_scalar()
in
src/backend/utils/adt/selfuncs.c
. (Eventually, this function should be replaced by
per-data-type functions identified through a column of the
pg_type
system catalog; but that hasn’t
happened yet.) If you do not do this, things will still work, but the optimizer’s estimates won’t be as
good as they could be.
There are additional selectivity estimation functions designed for geometric operators in
src/backend/utils/adt/geo_selfuncs.c
:
areasel
,
positionsel
,and
contsel
. At this
writing these are just stubs, but you might want to use them (or even better, improve them) anyway.
35.13.4.
JOIN
The
JOIN
clause, if provided, names a join selectivityestimation functionfor the operator. (Note that
this is a function name, not an operator name.)
JOIN
clauses only make sense for binary operators
961
VB.NET Image: Image Scaling SDK to Scale Picture / Photo
Framework application; VB.NET sample code for how to scale image / picture; Frequently asked questions about RasterEdge VB.NET image scaling control SDK add-on.
how to add an image to a pdf in acrobat; how to add a jpeg to a pdf file
VB.NET Image: Create Code 11 Barcode on Picture & Document Using
file, apart from above mentioned .NET core imaging SDK and .NET barcode creator add-on, you also need to buy .NET PDF document editor add-on, namely, RasterEdge
add image field to pdf form; add jpg to pdf
Chapter 35. Extending SQL
thatreturn
boolean
.The idea behind a join selectivityestimator is to guess what fraction of the rows
in a pair of tables will satisfy a
WHERE
-clause conditionof the form:
table1.column1 OP table2.column2
for the current operator. As with the
RESTRICT
clause, this helps the optimizer very substantially by
letting it figure out which of several possible join sequences is likely to take the least work.
As before, this chapter will make no attempt to explain how to write a join selectivity estimator
function, but will just suggest that you use one of the standard estimators if one is applicable:
eqjoinsel
for
=
neqjoinsel
for
<>
scalarltjoinsel
for
<
or
<=
scalargtjoinsel
for
>
or
>=
areajoinsel
for 2D area-based comparisons
positionjoinsel
for 2D position-based comparisons
contjoinsel
for 2D containment-based comparisons
35.13.5.
HASHES
The
HASHES
clause, if present, tells the system that it is permissible to use the hash join method for
ajoin based on this operator.
HASHES
only makes sense for a binary operator that returns
boolean
,
and in practice the operator must represent equality for some data type or pair of data types.
The assumption underlying hashjoin is that the join operator can only return true for pairs of left and
right values that hash to the same hash code. If two values get put in different hash buckets, the join
will never compare them at all, implicitly assuming that the result of the join operator must be false.
So it never makes sense to specify
HASHES
for operators that do not represent some form of equality.
In most cases it is only practical to support hashing for operators that take the same data type onboth
sides. However, sometimes it is possible to design compatible hash functions for two or more data
types; that is, functions that will generate the same hash codes for “equal” values, even though the
values have different representations. For example, it’s fairly simple to arrange this property when
hashing integers of different widths.
To be marked
HASHES
,the join operator must appear in a hash index operator family. This is not
enforced when you create the operator, since of course the referencing operator family couldn’t exist
yet. But attempts to use the operator inhashjoins will fail atrun timeif nosuchoperator family exists.
The system needs the operator family tofind the data-type-specific hash function(s) for the operator’s
input data type(s). Of course, you must also create suitable hash functions before you can create the
operator family.
Care should be exercisedwhen preparing a hashfunction, because there are machine-dependent ways
in which it might fail to do the right thing. For example, if your data type is a structure in which there
might be uninteresting pad bits, you cannot simply pass the whole structure to
hash_any
.(Unless
you write your other operators and functions to ensure that the unused bits are always zero, which
is the recommended strategy.) Another example is that on machines that meet the IEEE floating-
point standard, negative zero andpositive zero are different values (different bit patterns) but they are
defined to compare equal. If a float value might contain negative zero then extra steps are needed to
ensure it generates the same hash value as positive zero.
Ahash-joinable operator must havea commutator (itself if the twooperand data types are the same, or
arelated equality operator if they are different) that appears in the same operator family. If this is not
962
C# Word - Paragraph Processing in C#.NET
Add references: C# users can set paragraph properties and create content such as run, footnote, endnote and picture in a paragraph.
adding an image to a pdf in acrobat; how to add image to pdf document
VB.NET Image: Image Resizer Control SDK to Resize Picture & Photo
NET Method to Resize Image & Picture. Here we this VB.NET image resizer control add-on, can provide powerful & profession imaging controls, PDF document, image
add photo to pdf in preview; how to add image to pdf form
Chapter 35. Extending SQL
the case, planner errors might occur when the operator is used. Also, it is a good idea (but not strictly
required) for ahash operator familythatsupports multiple data types to provideequalityoperators for
every combination of the data types; this allows better optimization.
Note: The function underlying a hash-joinable operator must be marked immutable or stable. If it
is volatile, the system will never attempt to use the operator for a hash join.
Note:If a hash-joinableoperator has anunderlying functionthat is markedstrict, thefunctionmust
also becomplete: that is, it should return trueor false, never null, for any twononnull inputs. If this
rule is not followed, hash-optimizationof
IN
operationsmight generatewrongresults. (Specifically,
IN
might returnfalsewhere thecorrect answer accordingtothe standardwouldbe null; or it might
yield anerror complaining that it wasn’t prepared for a null result.)
35.13.6.
MERGES
The
MERGES
clause, if present, tells the system that it is permissible to use the merge-join method for
ajoin based on this operator.
MERGES
only makes sense for a binary operator that returns
boolean
,
and in practice the operator must represent equality for some data type or pair of data types.
Merge join is based on the idea of sorting the left- and right-hand tables into order and then scanning
them in parallel. So, both data types must be capable of being fully ordered, and the join operator
must be one that can only succeed for pairs of values that fall at the “same place” in the sort order. In
practice this means that the join operator must behave like equality. But it is possible to merge-join
two distinct data types so long as they are logically compatible. For example, the
smallint
-versus-
integer
equalityoperator is merge-joinable. Weonly need sortingoperatorsthatwill bring bothdata
types into a logically compatible sequence.
To be marked
MERGES
,thejoinoperator must appear asan equalitymember of a
btree
indexoperator
family. This is not enforced when you create the operator, since of course the referencing operator
family couldn’t exist yet. Butthe operator will not actuallybe used for merge joins unless a matching
operator family canbefound. The
MERGES
flag thus acts as a hinttotheplanner that it’s worthlooking
for a matching operator family.
Amerge-joinable operator must have a commutator (itself if the twooperanddata types are the same,
or a related equality operator if they are different) that appears in the same operator family. If this is
not the case, planner errors might occur when the operator is used. Also, it is a good idea (but not
strictly required) for a
btree
operator family that supports multiple data types to provide equality
operators for every combination of the data types; this allows better optimization.
Note: The function underlying a merge-joinable operator must be marked immutable or stable. If
it is volatile, the system will never attempt to use the operator for a merge join.
963
Chapter 35. Extending SQL
35.14. Interfacing Extensions To Indexes
The procedures described thus far let you define new types, new functions, and new operators. How-
ever, we cannot yet define an index on a column of a new data type. To do this, we must define an
operator class for the new data type. Later in this section, we will illustrate this concept in an ex-
ample: a new operator class for the B-tree index method that stores and sorts complex numbers in
ascending absolute value order.
Operator classes canbegroupedinto operator families toshow therelationships betweensemantically
compatible classes. When only a single data type is involved, an operator class is sufficient, so we’ll
focus on that case first and then return to operator families.
35.14.1. Index Methods and Operator Classes
The
pg_am
table contains one row for every index method (internally known as access method).
Support for regular access to tables is built into PostgreSQL, but all index methods are described in
pg_am
.It is possible to add a new index method by defining the required interface routines and then
creating a row in
pg_am
—but that is beyond the scope of this chapter (see Chapter 55).
The routines for an index method do not directly know anything about the data types that the index
methodwilloperate on. Instead, anoperator class identifiestheset of operations that theindexmethod
needs to use towork with a particular data type. Operator classes are so called because one thingthey
specify is the set of
WHERE
-clause operators that can be used with an index (i.e., can be converted
into an index-scan qualification). An operator class can also specify some support procedures that
are needed by the internal operations of the index method, but do not directly correspond to any
WHERE
-clause operator that can be used with the index.
It is possible to define multiple operator classes for the same data type and index method. By doing
this, multiple sets of indexing semantics can be defined for a single data type. For example, a B-tree
index requires a sort ordering to be defined for each data type it works on. It might be useful for a
complex-number data type to have one B-tree operator class that sorts the data by complex absolute
value, another that sorts by real part, and so on. Typically, one of the operator classes will be deemed
most commonly useful and will be marked as the default operator class for that data type and index
method.
The same operator class name can be used for several different index methods (for example, both
B-tree and hash index methods have operator classes named
int4_ops
), but each such class is an
independent entity and must be defined separately.
35.14.2. Index Method Strategies
The operators associated with an operator class are identified by “strategy numbers”, which serve to
identify the semantics of each operator within the context of its operator class. For example, B-trees
impose a strict ordering on keys, lesser to greater, and so operators like “less than” and “greater than
or equal to” are interesting with respect to a B-tree. Because PostgreSQL allows the user to define
operators, PostgreSQL cannot look at the name of an operator (e.g.,
<
or
>=
)and tell what kind
of comparison it is. Instead, the index method defines a set of “strategies”, which can be thought
of as generalized operators. Each operator class specifies which actual operator corresponds to each
strategy for a particular data type and interpretation of the index semantics.
The B-tree index method defines five strategies, shown in Table 35-2.
964
Chapter 35. Extending SQL
Table 35-2. B-tree Strategies
Operation
Strategy Number
less than
1
less than or equal
2
equal
3
greater than or equal
4
greater than
5
Hash indexes support only equality comparisons, and so they use only one strategy, shown in Table
35-3.
Table 35-3. Hash Strategies
Operation
Strategy Number
equal
1
GiST indexes are more flexible: they do not have a fixed set of strategies at all. Instead, the “consis-
tency” support routine of each particular GiST operator class interprets the strategynumbers however
it likes. As an example, several of the built-in GiST index operator classes index two-dimensional
geometric objects, providing the “R-tree” strategies shown in Table 35-4. Four of these are true two-
dimensionaltests(overlaps, same, contains, contained by); four of them consider only the Xdirection;
and the other four provide the same tests in the Ydirection.
Table 35-4. GiST Two-Dimensional “R-tree” Strategies
Operation
Strategy Number
strictly left of
1
does not extend to right of
2
overlaps
3
does not extend to left of
4
strictly right of
5
same
6
contains
7
contained by
8
does not extend above
9
strictly below
10
strictly above
11
does not extend below
12
SP-GiST indexes are similar to GiST indexes in flexibility: they don’t have a fixed set of strategies.
Instead the support routines of each operator class interpret the strategy numbers according to the
operator class’s definition. As an example, the strategy numbers used by the built-in operator classes
for points are shown in Table 35-5.
Table 35-5. SP-GiST Point Strategies
Operation
Strategy Number
965
Chapter 35. Extending SQL
Operation
Strategy Number
strictly left of
1
strictly right of
5
same
6
contained by
8
strictly below
10
strictly above
11
GIN indexes are similar to GiST andSP-GiST indexes, inthatthey don’t have a fixed set of strategies
either. Instead the support routines of each operator class interpret the strategy numbers according
to the operator class’s definition. As an example, the strategy numbers used by the built-in operator
classes for arrays are shown in Table 35-6.
Table 35-6. GIN Array Strategies
Operation
Strategy Number
overlap
1
contains
2
is contained by
3
equal
4
Notice that all the operators listed above return Boolean values. In practice, all operators defined as
index method search operators mustreturn type
boolean
,since they must appear at the top level of a
WHERE
clause to be used with anindex. (Some index access methods alsosupportorderingoperators,
which typically don’t return Boolean values; that feature is discussed in Section 35.14.7.)
35.14.3. Index Method Support Routines
Strategies aren’t usually enough information for the system to figure out how to use an index. In
practice, the index methods require additional support routines in order to work. For example, the B-
tree index method mustbe able tocompare two keys anddetermine whether one is greater than, equal
to, or less than the other. Similarly, the hash index method must be able to compute hash codes for
keyvalues. These operations donot correspond tooperators used inqualifications in SQL commands;
they are administrative routines used by the index methods, internally.
Just as withstrategies, the operator class identifies which specific functions should play eachof these
roles for a given data type and semantic interpretation. The index method defines the set of functions
it needs, and the operator class identifies the correct functions touse by assigning them tothe“support
function numbers” specified by the index method.
B-trees require a single support function, and allow a second one to be supplied at the operator class
author’s option, as shown in Table 35-7.
Table 35-7. B-tree Support Functions
Function
Support Number
966
Chapter 35. Extending SQL
Function
Support Number
Compare two keys and return 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
1
Return the addresses of C-callable sort support
function(s), as documentedin
utils/sortsupport.h
(optional)
2
Hash indexes require one support function, shown in Table 35-8.
Table 35-8. Hash Support Functions
Function
Support Number
Compute the hash value for a key
1
GiST indexes require seven support functions, with an optional eighth, as shown in Table 35-9. (For
more information see Chapter 56.)
Table 35-9. GiST Support Functions
Function
Description
Support Number
consistent
determine whether key satisfies
the query qualifier
1
union
compute union of a set of keys
2
compress
compute a compressed
representation of a key or value
to be indexed
3
decompress
compute a decompressed
representation of a compressed
key
4
penalty
compute penalty for inserting
new key into subtree with given
subtree’s key
5
picksplit
determine which entries of a
page are to be moved tothe new
page and compute the union
keys for resulting pages
6
equal
compare two keys and return
true if they are equal
7
distance
determine distance from key to
query value (optional)
8
SP-GiST indexes require five support functions, as shown in Table 35-10. (For more information see
Chapter 57.)
Table 35-10. SP-GiST Support Functions
Function
Description
Support Number
967
Documents you may be interested
Documents you may be interested