pdf viewer dll for c# : Add image to pdf acrobat control software platform web page html winforms web browser postgresql-9.4-A4104-part2729

Chapter 35. Extending SQL
Function
Description
Support Number
config
provide basic information about
the operator class
1
choose
determine how to insert a new
value into an inner tuple
2
picksplit
determine how to partition a set
of values
3
inner_consistent
determine which sub-partitions
need to be searched for a query
4
leaf_consistent
determine whether key satisfies
the query qualifier
5
GIN indexes requirefour support functions, with anoptional fifth, as showninTable 35-11. (For more
information see Chapter 58.)
Table 35-11. GIN Support Functions
Function
Description
Support Number
compare
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
extractValue
extract keys from a value to be
indexed
2
extractQuery
extract keys from a query
condition
3
consistent
determine whether value
matches query condition
(Boolean variant) (optional if
support function 6 is present)
4
comparePartial
compare partial key from query
and key from index, and return
an integer less than zero, zero,
or greater than zero, indicating
whether GIN should ignore this
index entry, treat the entry as a
match, or stop the index scan
(optional)
5
triConsistent
determine whether value
matches query condition
(ternary variant) (optional if
support function 4 is present)
6
Unlike search operators, support functions return whichever data type the particular index method
expects; for example in the case of the comparisonfunction for B-trees, a signed integer. The number
and types of the arguments to each support function are likewise dependent on the index method. For
B-tree and hash the comparison and hashing support functions take the same input data types as do
the operators includedin the operator class, but this is not the case for most GiST, SP-GiST, andGIN
968
Add 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
add image to pdf file acrobat; adding images to pdf forms
Add 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
how to add an image to a pdf; acrobat insert image into pdf
Chapter 35. Extending SQL
support functions.
35.14.4. An Example
Now that we have seen the ideas, here is the promised example of creating a new operator
class. (You can find a working copy of this example in
src/tutorial/complex.c
and
src/tutorial/complex.sql
in the source distribution.) The operator class encapsulates
operators that sort complex numbers in absolute value order, so we choose the name
complex_abs_ops
. First, we need a set of operators. The procedure for defining operators was
discussed in Section35.12. For an operator class on B-trees, the operators we require are:
absolute-value less-than (strategy 1)
absolute-value less-than-or-equal (strategy 2)
absolute-value equal (strategy 3)
absolute-value greater-than-or-equal (strategy 4)
absolute-value greater-than (strategy 5)
The least error-prone way to define a related set of comparison operators is to write the B-tree com-
parison support function first, and then write the other functions as one-line wrappers around the
supportfunction. This reduces theodds of getting inconsistent results for corner cases. Following this
approach, we first write:
#define Mag(c)
((c)->x
*
(c)->x + (c)->y
*
(c)->y)
static int
complex_abs_cmp_internal(Complex
*
a, Complex
*
b)
{
double
amag = Mag(a),
bmag = Mag(b);
if (amag < bmag)
return -1;
if (amag > bmag)
return 1;
return 0;
}
Now the less-than function looks like:
PG_FUNCTION_INFO_V1(complex_abs_lt);
Datum
complex_abs_lt(PG_FUNCTION_ARGS)
{
Complex
*
a = (Complex
*
) PG_GETARG_POINTER(0);
Complex
*
b = (Complex
*
) PG_GETARG_POINTER(1);
PG_RETURN_BOOL(complex_abs_cmp_internal(a, b) < 0);
}
The other four functions differ only in how they compare the internal function’s result to zero.
Next we declare the functions and the operators based on the functions to SQL:
969
.NET PDF Document Viewing, Annotation, Conversion & Processing
Convert image files to PDF. File & Page Process. Annotate & Comment. Add, insert PDF native annotations to PDF file. Support for all the print modes in Acrobat PDF
add image to pdf preview; adding an image to a pdf in preview
C# PDF Converter Library SDK to convert PDF to other file formats
without using other external third-party dependencies like Adobe Acrobat. you can easily perform file conversion from PDF document to image or document
add png to pdf preview; adding a jpg to a pdf
Chapter 35. Extending SQL
CREATE FUNCTION complex_abs_lt(complex, complex) RETURNS bool
AS ’
filename
’, ’complex_abs_lt’
LANGUAGE C IMMUTABLE STRICT;
CREATE OPERATOR < (
leftarg = complex, rightarg = complex, procedure = complex_abs_lt,
commutator = > , negator = >= ,
restrict = scalarltsel, join = scalarltjoinsel
);
It is important to specify the correct commutator and negator operators, as well as suitable restriction
and join selectivity functions, otherwise the optimizer will be unable to make effective use of the
index. Note thatthe less-than, equal, and greater-thancases should use different selectivity functions.
Other things worth noting are happening here:
There can only be one operator named, say,
=
and taking type
complex
for both operands. In this
case we don’t have any other operator
=
for
complex
,but if we were building a practical data
type we’d probably want
=
to be the ordinary equality operation for complex numbers (and not
the equality of the absolute values). In that case, we’d need to use some other operator name for
complex_abs_eq
.
Although PostgreSQL can cope with functions having the same SQL name as long as they have
different argument data types, C can only cope with one global function having a given name. So
we shouldn’t name the C function something simple like
abs_eq
.Usually it’s a good practice to
include the data type name in the C function name, so as not to conflict with functions for other
data types.
We could have made the SQL name of the function
abs_eq
,relying on PostgreSQL to distinguish
it by argument data types from any other SQL function of the same name. To keep the example
simple, we make the function have the same names at the C level and SQL level.
The next step is the registration of the support routine required by B-trees. The example C code that
implements this is in the same file that contains the operator functions. This is how we declare the
function:
CREATE FUNCTION complex_abs_cmp(complex, complex)
RETURNS integer
AS ’
filename
LANGUAGE C IMMUTABLE STRICT;
Now that we have the requiredoperators andsupportroutine, we can finally create the operator class:
CREATE OPERATOR CLASS complex_abs_ops
DEFAULT FOR TYPE complex USING btree AS
OPERATOR
1
< ,
OPERATOR
2
<= ,
OPERATOR
3
= ,
OPERATOR
4
>= ,
OPERATOR
5
> ,
FUNCTION
1
complex_abs_cmp(complex, complex);
And we’re done! It should now be possible tocreate and use B-tree indexes on
complex
columns.
970
C# Windows Viewer - Image and Document Conversion & Rendering in
without using other external third-party dependencies like Adobe Acrobat. Image and Document Conversion Supported by Windows Viewer. Convert to PDF.
adding an image to a pdf form; adding image to pdf
C# powerpoint - PowerPoint Conversion & Rendering in C#.NET
using other external third-party dependencies like Adobe Acrobat. SDK to convert PowerPoint document to PDF document code for PowerPoint to TIFF image conversion
add jpg to pdf document; add signature image to pdf acrobat
Chapter 35. Extending SQL
We could have written the operator entries more verbosely, as in:
OPERATOR
1
< (complex, complex) ,
but there is no need to do so when the operators take the same data type we are defining the operator
class for.
The aboveexample assumes that you wantto make this newoperator class the default B-tree operator
class for the
complex
data type. If you don’t, just leave out the word
DEFAULT
.
35.14.5. Operator Classes and Operator Families
So far we have implicitly assumed that an operator class deals with only one data type. While there
certainly can be only one data type in a particular index column, it is often useful to index operations
that compare an indexed column to a value of a different data type. Also, if there is use for a cross-
data-type operator in connection with an operator class, it is often the case that the other data type
has a related operator class of its own. It is helpful to make the connections between related classes
explicit, because this can aid the planner in optimizing SQL queries (particularly for B-tree operator
classes, since the planner contains a great deal of knowledge about how to work with them).
To handle these needs, PostgreSQL uses the concept of an operator family. An operator family con-
tains one or more operator classes, and can also contain indexable operators and corresponding sup-
port functions that belong to the family as a whole but not to any single class within the family. We
say that such operators and functions are “loose” within the family, as opposed to being bound into a
specific class. Typically each operator class contains single-data-type operators while cross-data-type
operators are loose in the family.
All the operators and functions in an operator family must have compatible semantics, where the
compatibility requirements are set by the index method. You might therefore wonder why bother
to single out particular subsets of the family as operator classes; and indeed for many purposes the
class divisions are irrelevant and the family is the only interesting grouping. The reason for defining
operator classes is that they specify how much of the family is needed to support any particular
index. If there is an index using an operator class, then that operator class cannot be dropped without
dropping the index — but other parts of the operator family, namely other operator classes and loose
operators, could be dropped. Thus, an operator class should be specified to contain the minimum set
of operators and functions that are reasonably needed to work with an index on a specific data type,
and then related but non-essential operators can be added as loose members of the operator family.
As anexample, PostgreSQLhas abuilt-in B-treeoperator family
integer_ops
,whichincludesoper-
ator classes
int8_ops
,
int4_ops
,and
int2_ops
for indexes on
bigint
(
int8
),
integer
(
int4
),
and
smallint
(
int2
)columns respectively. The family also contains cross-data-type comparison
operators allowing any two of these types to be compared, so that an index on one of these types
can be searched using a comparison value of another type. The family could be duplicated by these
definitions:
CREATE OPERATOR FAMILY integer_ops USING btree;
CREATE OPERATOR CLASS int8_ops
DEFAULT FOR TYPE int8 USING btree FAMILY integer_ops AS
-- standard int8 comparisons
OPERATOR 1 < ,
OPERATOR 2 <= ,
OPERATOR 3 = ,
OPERATOR 4 >= ,
OPERATOR 5 > ,
971
C# Word - Word Conversion in C#.NET
using other external third-party dependencies like Adobe Acrobat. Word SDK to convert Word document to PDF document. demo code for Word to TIFF image conversion
how to add an image to a pdf file; add picture to pdf document
VB.NET PDF: How to Create Watermark on PDF Document within
Using this VB.NET Imaging PDF Watermark Add-on, you can a watermark that consists of text or image (such as And with our PDF Watermark Creator, users need no
adding an image to a pdf; add an image to a pdf
Chapter 35. Extending SQL
FUNCTION 1 btint8cmp(int8, int8) ,
FUNCTION 2 btint8sortsupport(internal) ;
CREATE OPERATOR CLASS int4_ops
DEFAULT FOR TYPE int4 USING btree FAMILY integer_ops AS
-- standard int4 comparisons
OPERATOR 1 < ,
OPERATOR 2 <= ,
OPERATOR 3 = ,
OPERATOR 4 >= ,
OPERATOR 5 > ,
FUNCTION 1 btint4cmp(int4, int4) ,
FUNCTION 2 btint4sortsupport(internal) ;
CREATE OPERATOR CLASS int2_ops
DEFAULT FOR TYPE int2 USING btree FAMILY integer_ops AS
-- standard int2 comparisons
OPERATOR 1 < ,
OPERATOR 2 <= ,
OPERATOR 3 = ,
OPERATOR 4 >= ,
OPERATOR 5 > ,
FUNCTION 1 btint2cmp(int2, int2) ,
FUNCTION 2 btint2sortsupport(internal) ;
ALTER OPERATOR FAMILY integer_ops USING btree ADD
-- cross-type comparisons int8 vs int2
OPERATOR 1 < (int8, int2) ,
OPERATOR 2 <= (int8, int2) ,
OPERATOR 3 = (int8, int2) ,
OPERATOR 4 >= (int8, int2) ,
OPERATOR 5 > (int8, int2) ,
FUNCTION 1 btint82cmp(int8, int2) ,
-- cross-type comparisons int8 vs int4
OPERATOR 1 < (int8, int4) ,
OPERATOR 2 <= (int8, int4) ,
OPERATOR 3 = (int8, int4) ,
OPERATOR 4 >= (int8, int4) ,
OPERATOR 5 > (int8, int4) ,
FUNCTION 1 btint84cmp(int8, int4) ,
-- cross-type comparisons int4 vs int2
OPERATOR 1 < (int4, int2) ,
OPERATOR 2 <= (int4, int2) ,
OPERATOR 3 = (int4, int2) ,
OPERATOR 4 >= (int4, int2) ,
OPERATOR 5 > (int4, int2) ,
FUNCTION 1 btint42cmp(int4, int2) ,
-- cross-type comparisons int4 vs int8
OPERATOR 1 < (int4, int8) ,
OPERATOR 2 <= (int4, int8) ,
OPERATOR 3 = (int4, int8) ,
OPERATOR 4 >= (int4, int8) ,
OPERATOR 5 > (int4, int8) ,
FUNCTION 1 btint48cmp(int4, int8) ,
972
VB.NET PowerPoint: VB Code to Draw and Create Annotation on PPT
as a kind of compensation for limitations (other documents are compatible, including PDF, TIFF, MS VB.NET PPT: VB Code to Add Embedded Image Object to
how to add image to pdf reader; add image to pdf acrobat
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
how to add image to pdf in acrobat; add image in pdf using java
Chapter 35. Extending SQL
-- cross-type comparisons int2 vs int8
OPERATOR 1 < (int2, int8) ,
OPERATOR 2 <= (int2, int8) ,
OPERATOR 3 = (int2, int8) ,
OPERATOR 4 >= (int2, int8) ,
OPERATOR 5 > (int2, int8) ,
FUNCTION 1 btint28cmp(int2, int8) ,
-- cross-type comparisons int2 vs int4
OPERATOR 1 < (int2, int4) ,
OPERATOR 2 <= (int2, int4) ,
OPERATOR 3 = (int2, int4) ,
OPERATOR 4 >= (int2, int4) ,
OPERATOR 5 > (int2, int4) ,
FUNCTION 1 btint24cmp(int2, int4) ;
Notice that this definition “overloads” theoperator strategy and support function numbers: each num-
ber occurs multiple times within the family. This is allowed so long as each instance of a particular
number has distinct input data types. The instances that have both input types equal to an operator
class’s input type are the primary operators and support functions for that operator class, and in most
cases shouldbe declared as part of the operator class rather than as loose members of the family.
In a B-tree operator family, all the operators in the family must sort compatibly, meaning that the
transitive laws hold across all the data types supported by the family: “if A = B and B = C, then A =
C”, and“if A < BandB < C, then A< C”. Moreover, implicitor binary coercioncasts betweentypes
represented in the operator family must not change the associated sort ordering. For each operator in
the family there must be a support function having the same two input data types as the operator. It
is recommended that a family be complete, i.e., for each combination of data types, all operators are
included. Each operator class should include just the non-cross-type operators and support function
for its data type.
To build amultiple-data-typehashoperator family, compatible hashsupport functions mustbe created
for each data typesupportedbythefamily. Here compatibilitymeans that the functions are guaranteed
to return the same hash code for any two values that are considered equal by the family’s equality
operators, even whenthe values are of different types. This is usually difficultto accomplishwhen the
types have different physical representations, but it can be done in some cases. Furthermore, casting
avalue from one data type represented in the operator family to another data type also represented
in the operator family via an implicit or binary coercion cast must not change the computed hash
value. Notice that there is only one support function per data type, not one per equality operator. It
is recommended that a family be complete, i.e., provide an equality operator for each combination
of data types. Each operator class should include just the non-cross-type equality operator and the
support function for its data type.
GiST, SP-GiST, and GIN indexes do not have any explicit notion of cross-data-type operations. The
set of operators supported is just whatever the primary support functions for a given operator class
can handle.
Note: Prior to PostgreSQL 8.3, there was no concept of operator families, andso any cross-data-
typeoperators intendedtobeused with an index had tobebound directly intothe index’s operator
class. While this approachstill works, it is deprecated because it makes an index’s dependencies
too broad, and because the planner can handle cross-data-type comparisons more effectively
when both data types have operators in the same operator family.
973
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 photo to pdf online; add image to pdf file
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
add an image to a pdf acrobat; add multiple jpg to pdf
Chapter 35. Extending SQL
35.14.6. System Dependencies on Operator Classes
PostgreSQL uses operator classes to infer the properties of operators in more ways than just whether
they can be used with indexes. Therefore, you might want to create operator classes even if you have
no intention of indexing any columns of your data type.
In particular, there are SQL features such as
ORDER BY
and
DISTINCT
that require comparison and
sorting of values. To implement these features on a user-defined data type, PostgreSQL looks for the
default B-tree operator class for the data type. The “equals” member of this operator class defines the
system’s notionof equalityof values for
GROUP BY
and
DISTINCT
,andthe sort ordering imposed by
the operator class defines the default
ORDER BY
ordering.
Comparison of arrays of user-defined types also relies on the semantics defined by the default B-tree
operator class.
If there is no default B-tree operator class for a data type, the system will look for a default hash
operator class. But since that kind of operator class only provides equality, in practice it is only
enough tosupport array equality.
When there is no default operator class for a data type, you will get errors like “could not identify an
ordering operator” if you try to use these SQL features with the data type.
Note: In PostgreSQL versions before 7.4, sorting and grouping operations would implicitly use
operators named
=
,
<
,and
>
.The new behavior of relying on default operator classes avoids
having to make any assumption about the behavior of operators with particular names.
Another important point is that an operator that appears in a hash operator family is a candidate for
hash joins, hash aggregation, and related optimizations. The hash operator family is essential here
since it identifies the hash function(s) to use.
35.14.7. Ordering Operators
Some index access methods (currently, only GiST) support the concept of ordering operators. What
we have been discussing so far are search operators. A search operator is one for which the index
can be searched to find all rows satisfying
WHERE indexed_column operator constant
.Note
that nothing is promised about the order in which the matching rows will be returned. In contrast,
an ordering operator does not restrict the set of rows that can be returned, but instead determines
their order. An ordering operator is one for which the index can be scanned to return rows in the
order represented by
ORDER BY indexed_column operator constant
.The reason for defining
ordering operators that way is that it supports nearest-neighbor searches, if the operator is one that
measures distance. For example, a query like
SELECT
*
FROM places ORDER BY location <-> point ’(101,456)’ LIMIT 10;
finds the ten places closest to a given target point. A GiST index on the location column can do this
efficiently because
<->
is an ordering operator.
While search operators have to return Boolean results, ordering operators usually return some other
type, such as float or numeric for distances. This type is normally not the same as the data type being
indexed. To avoid hard-wiringassumptions about the behavior of differentdata types, thedefinitionof
an ordering operator is required toname a B-tree operator familythatspecifies the sort ordering of the
result data type. As was stated in the previous section, B-tree operator families define PostgreSQL’s
notion of ordering, so this is a natural representation. Since the point
<->
operator returns
float8
,
it could be specified in an operator class creation command like this:
974
Chapter 35. Extending SQL
OPERATOR 15
<-> (point, point) FOR ORDER BY float_ops
where
float_ops
is the built-inoperator family thatincludes operations on
float8
.This declaration
states that the index is able to return rows inorder of increasing values of the
<->
operator.
35.14.8. Special Features of Operator Classes
There are twospecialfeatures of operator classes that we have not discussed yet, mainlybecause they
are not useful with the most commonly usedindex methods.
Normally, declaring an operator as a member of an operator class (or family) means that the index
method can retrieve exactly the set of rows that satisfy a
WHERE
condition using the operator. For
example:
SELECT
*
FROM table WHERE integer_column < 4;
can be satisfied exactly by a B-tree index on the integer column. But there are cases where an index
is useful as an inexact guide to the matching rows. For example, if a GiST index stores only bound-
ing boxes for geometric objects, then it cannot exactly satisfy a
WHERE
condition that tests overlap
between nonrectangular objects such as polygons. Yet we could use the index to find objects whose
bounding box overlaps the bounding box of the target object, and then do the exact overlap test only
on the objects found by the index. If this scenarioapplies, the index is saidto be “lossy” for the oper-
ator. Lossy index searches are implemented by having the index method return a recheck flag when a
row might or might not really satisfy the query condition. The core system will then test the original
query condition on the retrieved row to see whether it should be returned as a valid match. This ap-
proach works if the index is guaranteed to return all the required rows, plus perhaps some additional
rows, whichcanbe eliminated by performingtheoriginaloperator invocation. Theindexmethods that
support lossy searches (currently, GiST, SP-GiST and GIN) allow the support functions of individual
operator classes to set the recheck flag, and so this is essentially an operator-class feature.
Consider again the situation where we are storing in the index only the bounding box of a complex
object suchas a polygon. In this case there’s not much value instoringthewhole polygonin the index
entry — we might as well store just a simpler object of type
box
.This situation is expressed by the
STORAGE
option in
CREATE OPERATOR CLASS
:we’d write something like:
CREATE OPERATOR CLASS polygon_ops
DEFAULT FOR TYPE polygon USING gist AS
...
STORAGE box;
At present, only the GiST and GIN index methods support a
STORAGE
type that’s different from
the column data type. The GiST
compress
and
decompress
support routines must deal with data-
type conversion when
STORAGE
is used. In GIN, the
STORAGE
type identifies the type of the “key”
values, which normally is different from the type of the indexed column — for example, an operator
class for integer-array columns might have keys that are just integers. The GIN
extractValue
and
extractQuery
support routines are responsible for extracting keys from indexed values.
35.15. Packaging Related Objects into an Extension
Auseful extension to PostgreSQL typically includes multiple SQL objects; for example, a new data
type willrequire newfunctions, newoperators, and probably newindex operator classes. It is helpful
975
Chapter 35. Extending SQL
to collect all these objects into a single package to simplify database management. PostgreSQL calls
such a package an extension. To define an extension, you need at least a script file that contains the
SQL commandsto create the extension’s objects, and acontrolfile that specifies a fewbasic properties
of the extension itself. If the extension includes C code, there will typically also be a shared library
file intowhich the C code has been built. Once you have these files, a simple CREATE EXTENSION
command loads the objects into your database.
The main advantage of using an extension, rather than just running the SQL script to load a bunch
of “loose” objects into your database, is that PostgreSQL will then understand that the objects of the
extension go together. You can drop all the objects with a single DROP EXTENSION command (no
need to maintain a separate “uninstall” script). Even more useful, pg_dump knows that it should not
dump the individual member objects of the extension — it will just include a
CREATE EXTENSION
command in dumps, instead. This vastly simplifies migration to a new version of the extension that
might contain more or different objects than the old version. Note however that you must have the
extension’s control, script, and other files available when loading such a dump into a new database.
PostgreSQL will not let you drop an individual object contained in an extension, except by dropping
the whole extension. Also, while you can change the definition of an extension member object (for
example, via
CREATE OR REPLACE FUNCTION
for afunction), bear in mind thatthemodifieddefini-
tion willnotbedumpedbypg_dump. Such a change is usually onlysensible if you concurrentlymake
the same change in the extension’s script file. (But there are special provisions for tables containing
configuration data; see below.)
The extension mechanism also has provisions for packaging modification scripts that adjust the defi-
nitions of the SQL objects contained in an extension. For example, if version 1.1 of an extension adds
one function and changes the body of another function comparedto 1.0, the extension author can pro-
vide an update scriptthatmakes justthose twochanges. The
ALTER EXTENSION UPDATE
command
can then be used to apply these changes and track which version of the extension is actually installed
in a given database.
The kinds of SQL objects that can be members of an extension are shown in the description of AL-
TER EXTENSION. Notably, objects that are database-cluster-wide, such as databases, roles, and
tablespaces, cannot be extension members since an extension is only known within one database.
(Although an extension script is not prohibited from creating such objects, if it does so they will not
be tracked as part of the extension.) Also notice that while a table can be a member of an extension,
its subsidiary objects such as indexes are not directly considered members of the extension. Another
important point is that schemas can belong to extensions, but not vice versa: an extension as such
has an unqualified name and does not exist “within” any schema. The extension’s member objects,
however, will belong to schemas whenever appropriate for their object types. It may or may not be
appropriate for an extension to own the schema(s) its member objects are within.
35.15.1. Extension Files
The CREATE EXTENSION command relies on a control file for each extension, which must be
named the same as the extension with a suffix of
.control
,and must be placed in the installation’s
SHAREDIR/extension
directory. There must also be at least one SQL script file, which follows the
naming pattern
extension
--
version
.sql
(for example,
foo--1.0.sql
for version
1.0
of exten-
sion
foo
). By default, the script file(s) are also placed in the
SHAREDIR/extension
directory; but
the control file can specify a different directory for the script file(s).
The file format for an extension control file is the same as for the
postgresql.conf
file, namely a
list of
parameter_name = value
assignments, one per line. Blank lines and comments introduced
by
#
are allowed. Be sure to quote any value that is not a single word or number.
Acontrol file can set the following parameters:
976
Chapter 35. Extending SQL
directory
(
string
)
The directory containing the extension’s SQL script file(s). Unless an absolute path is given, the
name is relative to the installation’s
SHAREDIR
directory. The default behavior is equivalent to
specifying
directory = ’extension’
.
default_version
(
string
)
The default version of the extension (the one that will be installed if no version is specified in
CREATE EXTENSION
). Although this can be omitted, that will result in
CREATE EXTENSION
failing if no
VERSION
option appears, so you generally don’t want to do that.
comment
(
string
)
Acomment (any string) about the extension. Alternatively, the comment can be set by means of
the COMMENT command in the script file.
encoding
(
string
)
The character set encoding used by the script file(s). This should be specified if the script files
contain any non-ASCII characters. Otherwise the files will be assumed to be in the database
encoding.
module_pathname
(
string
)
The value of this parameter will be substituted for each occurrence of
MODULE_PATHNAME
in the script file(s). If it is not set, no substitution is made. Typically, this is set to
$libdir/
shared_library_name
and then
MODULE_PATHNAME
is used in
CREATE FUNCTION
commands for C-language functions, so that the script files do not need to hard-wire the name
of the shared library.
requires
(
string
)
Alist of names of extensions that this extension depends on, for example
requires = ’foo,
bar’
.Those extensions must be installed before this one can be installed.
superuser
(
boolean
)
If this parameter is
true
(whichisthedefault), onlysuperusers cancreatethe extensionor update
it to a new version. If it is set to
false
,just the privileges required to execute the commands in
the installation or update script are required.
relocatable
(
boolean
)
Anextensionis relocatable if it is possible tomove its contained objects intoa different schema
after initial creation of the extension. The default is
false
,i.e. the extension is not relocatable.
See below for more information.
schema
(
string
)
This parameter canonlybe setfor non-relocatableextensions. Itforces theextensiontobe loaded
into exactly the named schema and not any other. See below for more information.
In additionto the primarycontrol file
extension
.control
,an extension can have secondarycontrol
files named in the style
extension
--
version
.control
.If supplied, these must be located in the
script file directory. Secondary control files follow the same format as the primary control file. Any
parameters setin a secondary controlfile override theprimary controlfile when installing or updating
to thatversion of the extension. However, the parameters
directory
and
default_version
cannot
be set in a secondary control file.
An extension’s SQL script files can contain any SQL commands, except for transaction control com-
mands (
BEGIN
,
COMMIT
,etc) and commands that cannot be executed inside a transaction block (such
as
VACUUM
). This is because the script files are implicitly executed within a transaction block.
977
Documents you may be interested
Documents you may be interested