pdf viewer for asp.net web application : Add signature image to pdf acrobat application control tool html azure .net online postgresql-9.4-A421-part2846

Chapter 8. Data Types
8.11.2.
tsquery
A
tsquery
value stores lexemes thataretobe searchedfor, andcombines them honoring the Boolean
operators
&
(AND),
|
(OR), and
!
(NOT). Parentheses can be used to enforce grouping of the opera-
tors:
SELECT ’fat & rat’::tsquery;
tsquery
---------------
’fat’ & ’rat’
SELECT ’fat & (rat | cat)’::tsquery;
tsquery
---------------------------
’fat’ & ( ’rat’ | ’cat’ )
SELECT ’fat & rat & ! cat’::tsquery;
tsquery
------------------------
’fat’ & ’rat’ & !’cat’
In the absence of parentheses,
!
(NOT) binds most tightly, and
&
(AND) binds more tightly than
|
(OR).
Optionally, lexemes in a
tsquery
can be labeled with one or more weight letters, which restricts
them to match only
tsvector
lexemes with matching weights:
SELECT ’fat:ab & cat’::tsquery;
tsquery
------------------
’fat’:AB & ’cat’
Also, lexemes in a
tsquery
can be labeled with
*
to specify prefix matching:
SELECT ’super:
*
’::tsquery;
tsquery
-----------
’super’:
*
This query will match any word in a
tsvector
that begins with “super”. Note that prefixes are first
processed by text search configurations, which means this comparison returns true:
SELECT to_tsvector( ’postgraduate’ ) @@ to_tsquery( ’postgres:
*
’ );
?column?
----------
t
(1 row)
because
postgres
gets stemmedto
postgr
:
SELECT to_tsquery(’postgres:
*
’);
to_tsquery
------------
’postgr’:
*
(1 row)
which then matches
postgraduate
.
138
Add signature image to pdf acrobat - 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 a jpeg to a pdf; adding images to pdf
Add signature image to pdf acrobat - 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 reader; add photo to pdf preview
Chapter 8. Data Types
Quoting rules for lexemes are the same as describedpreviously for lexemes in
tsvector
;and, aswith
tsvector
,anyrequirednormalizationof words mustbedone beforeconvertingtothe
tsquery
type.
The
to_tsquery
function is convenient for performing such normalization:
SELECT to_tsquery(’Fat:ab & Cats’);
to_tsquery
------------------
’fat’:AB & ’cat’
8.12. UUID Type
The data type
uuid
stores Universally Unique Identifiers (UUID) as defined by RFC 4122, ISO/IEC
9834-8:2005, and related standards. (Some systems refer to this data type as a globally unique identi-
fier, or GUID, instead.) This identifier is a 128-bit quantity that is generated by an algorithm chosen
to make it very unlikely that the same identifier will be generated by anyone else in the known uni-
verse using the same algorithm. Therefore, for distributed systems, these identifiers provide a better
uniqueness guarantee than sequence generators, which are only unique within a single database.
AUUID is written as a sequence of lower-case hexadecimal digits, in several groups separated by
hyphens, specifically a group of 8 digits followed by three groups of 4 digits followed by a group of
12 digits, for a total of 32 digits representing the 128 bits. An example of a UUID in this standard
form is:
a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11
PostgreSQL also accepts the following alternative forms for input: use of upper-case digits, the stan-
dard format surrounded by braces, omitting some or all hyphens, adding a hyphen after any group of
four digits. Examples are:
A0EEBC99-9C0B-4EF8-BB6D-6BB9BD380A11
{a0eebc99-9c0b-4ef8-bb6d-6bb9bd380a11}
a0eebc999c0b4ef8bb6d6bb9bd380a11
a0ee-bc99-9c0b-4ef8-bb6d-6bb9-bd38-0a11
{a0eebc99-9c0b4ef8-bb6d6bb9-bd380a11}
Output is always in the standard form.
PostgreSQL provides storage and comparison functions for UUIDs, but the core database does not
include any function for generating UUIDs, because no single algorithm is well suited for every
application. The uuid-ossp module provides functions that implement several standard algorithms.
The pgcrypto module also provides a generation function for random UUIDs. Alternatively, UUIDs
could be generated by client applications or other libraries invoked through a server-side function.
8.13. XML Type
The
xml
data type can be used to store XML data. Its advantage over storing XML data in a
text
field is that it checks the input values for well-formedness, and there are support functions to perform
type-safe operations on it; seeSection9.14. Use of this data type requires the installationtohave been
built with
configure --with-libxml
.
139
.NET PDF Document Viewing, Annotation, Conversion & Processing
Convert image files to PDF. File & Page Process. Allow to create digital signature. Easy to set PDF file permission. Add, insert PDF native annotations to PDF file
add picture to pdf; add image to pdf java
BMP to PDF Converter | Convert Bitmap to PDF, Convert PDF to BMP
Also designed to be used add-on for .NET Image SDK, RasterEdge Bitmap to PDF Converter can Powerful image converter for Bitmap and PDF files; No need for
attach image to pdf form; adding images to a pdf document
Chapter 8. Data Types
The
xml
type can store well-formed “documents”, as defined by the XML standard, as well as “con-
tent” fragments, which are defined by the production
XMLDecl? content
in the XML standard.
Roughly, this means that content fragments can have more than one top-level element or character
node. The expression
xmlvalue
IS DOCUMENT
can be used to evaluate whether a particular
xml
value is a full document or only a content fragment.
8.13.1. Creating XML Values
To produce a value of type
xml
from character data, use the function
xmlparse
:
XMLPARSE ( { DOCUMENT | CONTENT }
value
)
Examples:
XMLPARSE (DOCUMENT ’<?xml version="1.0"?><book><title>Manual</title><chapter>...</chapter></book>’)
XMLPARSE (CONTENT ’abc<foo>bar</foo><bar>foo</bar>’)
Whilethis is theonly waytoconvert character strings intoXMLvaluesaccordingtotheSQL standard,
the PostgreSQL-specific syntaxes:
xml ’<foo>bar</foo>’
’<foo>bar</foo>’::xml
can also be used.
The
xml
type does not validate input values against a document type declaration (DTD), even when
the input value specifies a DTD. There is alsocurrentlyno built-insupport for validatingagainst other
XML schema languages such as XML Schema.
The inverse operation, producinga character string value from
xml
,uses the function
xmlserialize
:
XMLSERIALIZE ( { DOCUMENT | CONTENT }
value
AS
type
)
type
can be
character
,
character varying
,or
text
(or an alias for one of those). Again,
according to the SQL standard, this is the only way to convert between type
xml
and character types,
but PostgreSQL also allows you to simplycast the value.
When a character string value is cast to or from type
xml
without going through
XMLPARSE
or
XMLSERIALIZE
,respectively, the choice of
DOCUMENT
versus
CONTENT
is determined by the “XML
option” session configuration parameter, which can be set using the standard command:
SET XML OPTION { DOCUMENT | CONTENT };
or the more PostgreSQL-like syntax
SET xmloption TO { DOCUMENT | CONTENT };
The default is
CONTENT
,so all forms of XML data are allowed.
Note: With thedefault XML option setting, you cannot directly cast character strings to type
xml
if
they contain a document type declaration, because the definition of XML content fragment does
not accept them. If you need to do that, either use
XMLPARSE
or change the XML option.
140
JPEG to PDF Converter | Convert JPEG to PDF, Convert PDF to JPEG
It can be used standalone. JPEG to PDF Converter is able to convert image files to PDF directly without the software Adobe Acrobat Reader for conversion.
add an image to a pdf form; acrobat insert image into pdf
PDF to WORD Converter | Convert PDF to Word, Convert Word to PDF
out transformation between different kinds of image files and Word Converter has accurate output, and PDF to Word need the support of Adobe Acrobat & Microsoft
how to add image to pdf acrobat; how to add image to pdf file
Chapter 8. Data Types
8.13.2. Encoding Handling
Care must be taken when dealing with multiple character encodings on the client, server, and in
the XML data passed through them. When using the text mode to pass queries to the server and
query results tothe client (which is the normalmode), PostgreSQL converts all character data passed
between the client and the server and vice versa to the character encoding of the respective end; see
Section 22.3. This includes string representations of XML values, such as in the above examples.
This wouldordinarily mean that encoding declarations contained in XML data can become invalid as
the character data is converted to other encodings while traveling between client and server, because
the embeddedencoding declarationis notchanged. To cope with this behavior, encoding declarations
contained in character strings presentedfor input to the
xml
type are ignored, and content is assumed
to be in the current server encoding. Consequently, for correct processing, character strings of XML
data must be sent from the client in the current client encoding. It is the responsibility of the client
to either convert documents to the current client encoding before sending them to the server, or to
adjust the client encoding appropriately. On output, values of type
xml
will not have an encoding
declaration, and clients should assume all data is in the current client encoding.
When usingbinarymodetopass queryparameters tothe server andqueryresults backtotheclient, no
character setconversionis performed, sothesituation is different. Inthis case, anencodingdeclaration
in the XML data will be observed, and if it is absent, the data will be assumed to be in UTF-8 (as
required bythe XML standard; note that PostgreSQL does notsupportUTF-16). On output, data will
have an encoding declaration specifying the client encoding, unless the client encoding is UTF-8, in
which case it will be omitted.
Needless to say, processing XML data with PostgreSQL will be less error-prone and more efficient
if the XML data encoding, client encoding, and server encoding are the same. Since XML data is
internally processed in UTF-8, computations will be most efficient if the server encoding is also
UTF-8.
Caution
Some XML-related functions may not work at all on non-ASCII data when the
server encoding is not UTF-8. This is known to be an issue for
xpath()
in
particular.
8.13.3. Accessing XML Values
The
xml
data type is unusual in that it does not provide any comparison operators. This is because
there is nowell-defined and universallyusefulcomparisonalgorithm for XML data. Oneconsequence
of this is that you cannot retrieve rows by comparing an
xml
column against a search value. XML
values shouldtherefore typically be accompaniedbya separate key fieldsuch as an ID. An alternative
solutionfor comparingXML values is to convert them to character strings first, but note thatcharacter
string comparison has little to do with a useful XML comparison method.
Since there are no comparison operators for the
xml
data type, it is not possible to create an index
directly on a column of this type. If speedy searches in XML data are desired, possible workarounds
include casting the expression to a character string type and indexing that, or indexing an XPath
expression. Of course, the actualquery wouldhave tobeadjusted to searchby the indexedexpression.
The text-search functionality in PostgreSQL can also be used to speed up full-document searches
of XML data. The necessary preprocessing support is, however, not yet available in the PostgreSQL
distribution.
141
GIF to PDF Converter | Convert GIF to PDF, Convert PDF to GIF
use of external applications & Adobe Acrobat Reader. This GIF to PDF Converter provided by RasterEdge is Features and Benefits. Powerful image converter for GIF
add a picture to a pdf file; adding image to pdf in preview
DICOM to PDF Converter | Convert DICOM to PDF, Convert PDF to
Different from other image converters, users do not need to load Adobe Acrobat or any other print drivers when they use DICOM to PDF Converter.
pdf insert image; add image pdf document
Chapter 8. Data Types
8.14. JSON Types
JSON data types are for storing JSON (JavaScript Object Notation) data, as specified in RFC 7159
1
.
Such data can also be stored as
text
,but the JSON data types have the advantage of enforcing
that each stored value is valid according to the JSON rules. There are also assorted JSON-specific
functions and operators available for data stored in these data types; see Section 9.15.
There are two JSONdata types:
json
and
jsonb
.Theyaccept almost identical sets of values asinput.
The major practical difference is one of efficiency. The
json
data type stores an exact copy of the
input text, which processing functions must reparse on each execution; while
jsonb
data is stored in
adecomposed binary format that makes it slightly slower to input due to added conversionoverhead,
but significantly faster to process, since no reparsing is needed.
jsonb
also supports indexing, which
can be a significant advantage.
Becausethe
json
type storesan exactcopyof the input text, itwillpreserve semantically-insignificant
white space between tokens, as wellas the order of keys within JSON objects. Also, if a JSON object
within the value contains the same key more than once, all the key/value pairs are kept. (The pro-
cessing functions consider the last value as the operative one.) By contrast,
jsonb
does not preserve
white space, does not preserve the order of object keys, and does not keep duplicate object keys. If
duplicate keys are specified inthe input, only the last value is kept.
In general, most applications should prefer to store JSON data as
jsonb
,unless there are quite spe-
cialized needs, such as legacy assumptions about ordering of object keys.
PostgreSQL allows only one character set encoding per database. It is therefore not possible for the
JSON types to conform rigidly to the JSON specification unless the database encoding is UTF8. At-
tempts to directly include characters that cannot be represented in the database encoding will fail;
conversely, characters that can be represented in the database encoding but not in UTF8 will be al-
lowed.
RFC7159permits JSONstrings tocontainUnicodeescapesequences denotedby
\u
XXXX
.Inthe input
function for the
json
type, Unicode escapes are allowed regardless of the database encoding, and are
checked only for syntactic correctness (that is, that four hex digits follow
\u
). However, the input
function for
jsonb
is stricter: it disallows Unicode escapes for non-ASCII characters (those above
U+007F
)unless the database encoding is UTF8. The
jsonb
type also rejects
\u0000
(because that
cannot be represented in PostgreSQL’s
text
type), and it insists that any use of Unicode surrogate
pairs to designate characters outside the Unicode Basic Multilingual Plane be correct. Valid Unicode
escapes are converted to the equivalent ASCII or UTF8 character for storage; this includes folding
surrogate pairs into a single character.
Note: Many of the JSON processing functions described in Section 9.15 will convert Unicode
escapes to regular characters, and will therefore throw the same types of errors just described
even if their input is of type
json
not
jsonb
.The fact that the
json
input function does not make
these checks may be considered a historical artifact, although it does allow for simple storage
(without processing) of JSON Unicode escapes in a non-UTF8 database encoding. In general, it
isbest toavoidmixingUnicode escapes inJSONwitha non-UTF8databaseencoding, if possible.
When converting textual JSON input into
jsonb
,the primitive types described by RFC 7159 are
effectively mapped onto native PostgreSQL types, as shown in Table 8-23. Therefore, there are some
minor additional constraints on what constitutes valid
jsonb
data that do not apply tothe
json
type,
nor to JSON in the abstract, corresponding to limits on what can be represented by the underlying
data type. Notably,
jsonb
willreject numbers that are outside the range of the PostgreSQL
numeric
data type, while
json
will not. Such implementation-defined restrictions are permitted by RFC 7159.
1. http://rfc7159.net/rfc7159
142
TIFF to PDF Converter | Convert TIFF to PDF, Convert PDF to TIFF
PDF to TIFF Converter doesn't require other third-party such as Adobe Acrobat. PDF to TIFF Converter can create the output TIFF image with 68-1024 dpi.
add image pdf; add photo to pdf in preview
Chapter 8. Data Types
However, in practice such problems are far more likely to occur in other implementations, as it is
common to represent JSON’s
number
primitive type as IEEE 754 double precision floating point
(which RFC 7159 explicitly anticipates and allows for). When using JSON as an interchange format
with such systems, the danger of losing numeric precision compared to data originally stored by
PostgreSQL should be considered.
Conversely, as noted in the table there are some minor restrictions on the input format of JSON
primitive types that do not apply to the corresponding PostgreSQL types.
Table 8-23. JSON primitive types and corresponding PostgreSQL types
JSON primitive type
PostgreSQL type
Notes
string
text
\u0000
is disallowed, as are
non-ASCII Unicode escapes if
database encoding is not UTF8
number
numeric
NaN
and
infinity
values are
disallowed
boolean
boolean
Only lowercase
true
and
false
spellings are accepted
null
(none)
SQL
NULL
is a different
concept
8.14.1. JSON Input and Output Syntax
The input/output syntax for the JSON data types is as specified in RFC 7159.
The following are all valid
json
(or
jsonb
)expressions:
-- Simple scalar/primitive value
-- Primitive values can be numbers, quoted strings, true, false, or null
SELECT ’5’::json;
-- Array of zero or more elements (elements need not be of same type)
SELECT ’[1, 2, "foo", null]’::json;
-- Object containing pairs of keys and values
-- Note that object keys must always be quoted strings
SELECT ’{"bar": "baz", "balance": 7.77, "active": false}’::json;
-- Arrays and objects can be nested arbitrarily
SELECT ’{"foo": [true, "bar"], "tags": {"a": 1, "b": null}}’::json;
As previously stated, when a JSON value is input and then printed without any additional processing,
json
outputs the same text that was input, while
jsonb
does not preserve semantically-insignificant
details such as whitespace. For example, note the differences here:
SELECT ’{"bar": "baz", "balance": 7.77, "active":false}’::json;
json
-------------------------------------------------
{"bar": "baz", "balance": 7.77, "active":false}
(1 row)
SELECT ’{"bar": "baz", "balance": 7.77, "active":false}’::jsonb;
143
Chapter 8. Data Types
jsonb
--------------------------------------------------
{"bar": "baz", "active": false, "balance": 7.77}
(1 row)
Onesemantically-insignificantdetailworthnotingis that in
jsonb
,numbers willbeprinted according
to the behavior of the underlying
numeric
type. In practice this means that numbers entered with
E
notation will be printed without it, for example:
SELECT ’{"reading": 1.230e-5}’::json, ’{"reading": 1.230e-5}’::jsonb;
json
|
jsonb
-----------------------+-------------------------
{"reading": 1.230e-5} | {"reading": 0.00001230}
(1 row)
However,
jsonb
will preserve trailing fractional zeroes, as seen in this example, even though those
are semantically insignificant for purposes such as equality checks.
8.14.2. Designing JSON documents effectively
Representing data as JSON can be considerably more flexible than the traditional relational data
model, whichis compelling in environments where requirements are fluid. Itis quite possible for both
approaches to co-exist and complement each other within the same application. However, even for
applications where maximal flexibility is desired, it is still recommended that JSON documents have
asomewhat fixed structure. The structure is typically unenforced (though enforcing some business
rules declaratively is possible), but having a predictable structure makes it easier to write queries that
usefully summarize a set of “documents” (datums) in a table.
JSON data is subject to the same concurrency-control considerations as any other data type when
stored in a table. Although storing large documents is practicable, keep in mind that any update
acquires a row-level lock on the whole row. Consider limitingJSONdocuments to a manageable size
in order to decrease lock contention among updating transactions. Ideally, JSON documents should
each represent an atomic datum that business rules dictate cannot reasonably be further subdivided
into smaller datums that could be modified independently.
8.14.3.
jsonb
Containment and Existence
Testing containment is an important capability of
jsonb
.There is no parallel set of facilities for
the
json
type. Containment tests whether one
jsonb
document has contained within it another one.
These examples return true except as noted:
-- Simple scalar/primitive values contain only the identical value:
SELECT ’"foo"’::jsonb @> ’"foo"’::jsonb;
-- The array on the right side is contained within the one on the left:
SELECT ’[1, 2, 3]’::jsonb @> ’[1, 3]’::jsonb;
-- Order of array elements is not significant, so this is also true:
SELECT ’[1, 2, 3]’::jsonb @> ’[3, 1]’::jsonb;
-- Duplicate array elements don’t matter either:
SELECT ’[1, 2, 3]’::jsonb @> ’[1, 2, 2]’::jsonb;
144
Chapter 8. Data Types
-- The object with a single pair on the right side is contained
-- within the object on the left side:
SELECT ’{"product": "PostgreSQL", "version": 9.4, "jsonb":true}’::jsonb @> ’{"version":9.4}’::jsonb;
-- The array on the right side is not considered contained within the
-- array on the left, even though a similar array is nested within it:
SELECT ’[1, 2, [1, 3]]’::jsonb @> ’[1, 3]’::jsonb;
-- yields false
-- But with a layer of nesting, it is contained:
SELECT ’[1, 2, [1, 3]]’::jsonb @> ’[[1, 3]]’::jsonb;
-- Similarly, containment is not reported here:
SELECT ’{"foo": {"bar": "baz"}}’::jsonb @> ’{"bar": "baz"}’::jsonb;
-- yields false
The generalprinciple is that the contained object must match the containing object as tostructure and
data contents, possibly after discarding some non-matching array elements or object key/value pairs
from the containing object. But remember that the order of array elements is not significant when
doing a containment match, and duplicate array elements are effectively considered only once.
As a special exception to the general principle that the structures must match, an array may contain a
primitive value:
-- This array contains the primitive string value:
SELECT ’["foo", "bar"]’::jsonb @> ’"bar"’::jsonb;
-- This exception is not reciprocal -- non-containment is reported here:
SELECT ’"bar"’::jsonb @> ’["bar"]’::jsonb;
-- yields false
jsonb
also has an existence operator, which is a variation on the theme of containment: it tests
whether a string (given as a
text
value) appears as an object key or array element at the top level of
the
jsonb
value. These examples return true except as noted:
-- String exists as array element:
SELECT ’["foo", "bar", "baz"]’::jsonb ? ’bar’;
-- String exists as object key:
SELECT ’{"foo": "bar"}’::jsonb ? ’foo’;
-- Object values are not considered:
SELECT ’{"foo": "bar"}’::jsonb ? ’bar’;
-- yields false
-- As with containment, existence must match at the top level:
SELECT ’{"foo": {"bar": "baz"}}’::jsonb ? ’bar’; -- yields false
-- A string is considered to exist if it matches a primitive JSON string:
SELECT ’"foo"’::jsonb ? ’foo’;
JSON objects are better suited than arrays for testing containment or existence when there are many
keys or elements involved, because unlike arrays they are internally optimized for searching, and do
not need to be searched linearly.
Tip: Because JSON containment is nested, an appropriate query can skip explicit selection of
sub-objects. As an example, suppose that we have a
doc
column containing objects at the top
level, with most objects containing
tags
fields that contain arrays of sub-objects. This query finds
entries in which sub-objects containing both
"term":"paris"
and
"term":"food"
appear, while
ignoring any such keys outside the
tags
array:
145
Chapter 8. Data Types
SELECT doc->’site_name’ FROM websites
WHERE doc @> ’{"tags":[{"term":"paris"}, {"term":"food"}]}’;
One could accomplish the same thing with, say,
SELECT doc->’site_name’ FROM websites
WHERE doc->’tags’ @> ’[{"term":"paris"}, {"term":"food"}]’;
but that approach is less flexible, and often less efficient as well.
On the other hand, the JSON existence operator is not nested: it will only look for the specified
key or array element at top level of the JSON value.
The various containment and existence operators, along with all other JSON operators and functions
are documented in Section 9.15.
8.14.4.
jsonb
Indexing
GIN indexes can be used to efficiently search for keys or key/value pairs occurring within a large
number of
jsonb
documents (datums). Two GIN “operator classes” are provided, offering different
performance and flexibility trade-offs.
The default GIN operator class for
jsonb
supports queries with the
@>
,
?
,
?&
and
?|
operators. (For
details of the semantics that these operators implement, see Table 9-41.) An example of creating an
index with this operator class is:
CREATE INDEX idxgin ON api USING gin (jdoc);
The non-default GIN operator class
jsonb_path_ops
supports indexing the
@>
operator only. An
example of creating an index with this operator class is:
CREATE INDEX idxginp ON api USING gin (jdoc jsonb_path_ops);
Consider the exampleof a table thatstores JSON documents retrievedfrom a third-party web service,
with a documented schema definition. Atypical document is:
{
"guid": "9c36adc1-7fb5-4d5b-83b4-90356a46061a",
"name": "Angela Barton",
"is_active": true,
"company": "Magnafone",
"address": "178 Howard Place, Gulf, Washington, 702",
"registered": "2009-11-07T08:53:22 +08:00",
"latitude": 19.793713,
"longitude": 86.513373,
"tags": [
"enim",
"aliquip",
"qui"
]
}
We store these documents in a table named
api
,in a
jsonb
column named
jdoc
.If a GIN index is
created on this column, queries like the following can make use of the index:
146
Chapter 8. Data Types
-- Find documents in which the key "company" has value "Magnafone"
SELECT jdoc->’guid’, jdoc->’name’ FROM api WHERE jdoc @> ’{"company": "Magnafone"}’;
However, the indexcould not be used for queries like the following, because though the operator
?
is
indexable, it is not applied directly to the indexed column
jdoc
:
-- Find documents in which the key "tags" contains key or array element "qui"
SELECT jdoc->’guid’, jdoc->’name’ FROM api WHERE jdoc -> ’tags’ ? ’qui’;
Still, with appropriate use of expression indexes, the above query can use an index. If querying for
particular items within the
"tags"
key is common, defining an index like this may be worthwhile:
CREATE INDEX idxgintags ON api USING gin ((jdoc -> ’tags’));
Now, the
WHERE
clause
jdoc -> ’tags’ ? ’qui’
will be recognized as an application of the
indexable operator
?
to the indexed expression
jdoc -> ’tags’
.(More information onexpression
indexes can be found inSection 11.7.)
Another approach to querying is to exploit containment, for example:
-- Find documents in which the key "tags" contains array element "qui"
SELECT jdoc->’guid’, jdoc->’name’ FROM api WHERE jdoc @> ’{"tags": ["qui"]}’;
Asimple GIN index on the
jdoc
column can support this query. But note that such an index will
store copies of every key and value in the
jdoc
column, whereas the expression index of the previous
example stores only data found under the
tags
key. While the simple-index approach is far more
flexible (since it supports queries about any key), targeted expression indexes are likely to be smaller
and faster to searchthan a simple index.
Although the
jsonb_path_ops
operator class supports only queries with the
@>
operator, it has
notable performance advantages over the default operator class
jsonb_ops
.A
jsonb_path_ops
index is usually much smaller than a
jsonb_ops
index over the same data, and the specificity of
searches is better, particularly when queries containkeys thatappear frequentlyin the data. Therefore
search operations typically perform better than with the default operator class.
The technical difference betweena
jsonb_ops
anda
jsonb_path_ops
GINindex is that the former
creates independent indexitems for each keyandvalue in the data, while the latter creates indexitems
only for each value in the data.
2
Basically, each
jsonb_path_ops
index item is a hash of the value
and the key(s) leading to it; for example to index
{"foo": {"bar": "baz"}}
,a single index item
wouldbe created incorporatingallthree of
foo
,
bar
,and
baz
into the hash value. Thus acontainment
query lookingfor this structure wouldresult in an extremelyspecific indexsearch; but there is no way
at all to find out whether
foo
appears as a key. On the other hand, a
jsonb_ops
index would create
three index items representing
foo
,
bar
,and
baz
separately; then to do the containment query, it
wouldlook for rows containingall three of these items. WhileGIN indexes canperform such anAND
search fairly efficiently, it will still be less specific and slower than the equivalent
jsonb_path_ops
search, especially if there are a verylarge number of rows containing anysingle one of the three index
items.
Adisadvantage of the
jsonb_path_ops
approach is that it produces no index entries for JSON
structures not containing any values, such as
{"a": {}}
.If a search for documents containing such
astructure is requested, it will require a full-index scan, which is quite slow.
jsonb_path_ops
is
therefore ill-suited for applications that often perform such searches.
2. For this purpose, the term“value” includesarray elements, thoughJSONterminologysometimesconsiders array elements
distinct from valueswithin objects.
147
Documents you may be interested
Documents you may be interested