All Classes and Interfaces
Class
Description
Custom implementations of Java's
Type interfaces, with methods
for a couple useful manipulations.A class recording the bindings made in a ParameterizedType to the type
parameters in a GenericDeclaration<Class>.
A class dedicated to manipulating the types of multidimensional Java
arrays, and their instances, that conform to PostgreSQL array constraints
(non-'jagged', each dimension's arrays all equal size, no intermediate
nulls).
Base for classes that implement data types over raw PostgreSQL datums.
A lightweight unchecked exception used to wrap checked ones
(often
SQLException) in settings where checked ones are a bother.Abstract supertype of array adapters.
Builder to derive properly-typed array adapters of various
dimensionalities, first obtained from an
Adapter.ArrayProto.Mixin allowing properly-typed array adapters of various dimensionalities
to be derived from an adapter for the array component type.
Superclass for adapters that fetch something and return it as a reference
type T.
Abstract superclass of primitive
boolean adapters.Abstract superclass of signed and unsigned primitive
byte
adapters.Abstract superclass of signed primitive
byte adapters.Abstract superclass of unsigned primitive
byte adapters.Abstract superclass of primitive
char adapters.Abstract superclass of primitive
double adapters.Abstract superclass of primitive
float adapters.Abstract superclass of signed and unsigned primitive
int
adapters.Abstract superclass of signed primitive
int adapters.Abstract superclass of unsigned primitive
int adapters.Abstract superclass of signed and unsigned primitive
long
adapters.Abstract superclass of signed primitive
long adapters.Abstract superclass of unsigned primitive
long adapters.Abstract superclass of signed and unsigned primitive
short
adapters.Abstract superclass of signed primitive
short adapters.Abstract superclass of unsigned primitive
short adapters.A class that is returned by the
configure method,
intended for use during an Adapter subclass's static
initialization, and must be supplied to the constructor when instances
of the class are created.Provided to serve as a superclass for a 'container' class that is used
to group several related adapters without being instantiable
as an adapter itself.
A marker interface to be extended by functional interfaces that
serve as ADT contracts.
Base for functional interfaces that serve as contracts
for array-like types.
Marker interface for contracts for simple scalar types.
Functional interface able to dispense one instance of an ADT by passing
its constituent values to a supplied
Contract and returning
whatever that returns.An
Adapter that reports it can be used on any type, but cannot
fetch anything.A permission allowing the creation of a leaf
Adapter.Ancestor class for adapters that fetch something and return it as
a Java primitive type.
Functional interface able to dispense multiple instances of an ADT
identified by a zero-based index, passing the its constituent values
to a supplied
Contract and returning whatever that returns.Specification of a service supplied by the internals module for certain
operations, such as specially instantiating array adapters based on
ArrayBuilders constructed here.Specifies, for a leaf adapter (one not composed over a lower adapter),
the form in which the value fetched from PostgreSQL will be presented to
it (or how it will produce a value to be stored to PostgreSQL).
Convenience class whose member classes will provide APIs that in some way
adjust aspects of PL/Java's behavior.
Class that collects adjustment APIs for affecting the behavior of
PL/Java's XML support.
Adjusting version of a
DOMSource.Interface with methods to adjust the restrictions on XML parsing
that are commonly considered when XML content might be from untrusted
sources.
Adjusting version of
javax.xml.transform.Result, offering
the adjustment methods of Adjusting.XML.Parsing, chiefly so that
there is a way to apply those adjustments to any implicitly-created
parser used to verify the content that will be written to the
Result.Adjusting version of a
SAXResult.Adjusting version of a
SAXSource.A functional interface fitting various
setFeature or
setProperty methods in Java XML APIs.Adjusting version of
javax.xml.transform.Source, allowing
various parser features to be configured before calling
get() to obtain the usable Source object.Specialized
Result type for setting a new PL/Java
SQLXML instance's content from an arbitrary Source
object of any of the types JDBC requires the SQLXML type
to support.Adjusting version of a
StAXSource.Adjusting version of a
StreamResult.Declares a PostgreSQL aggregate.
Declares the effect of the
finish function in a Plan.Specifies one "plan" for evaluating the aggregate; one must always be
specified (as
plan), and a second may be specified (as
movingPlan).Container for functional interfaces presenting a PostgreSQL array.
A contract whereby an array is returned flattened into a Java list,
with no attention to its specified dimensionality or index bounds.
An attribute (column), either of a known relation, or of a transient record
type.
Annotation on a PL/Java class to form a User Defined Type that will
become a new PostgreSQL base type.
The supported alignment constraints for the type's internal
representation.
The type categories that are predefined in PostgreSQL.
Character constants corresponding to the predefined categories,
for use in the
BaseUDT.category() annotation element.The supported TOAST strategies for the type's stored representation.
Container for abstract-type functional interfaces in PostgreSQL's
BITSTRING type category.The
BIT and VARBIT types' PostgreSQL semantics: the
number of bits, and the sequence of bytes they're packed into.Functional interface to obtain information from the PostgreSQL type
modifier applied to the type.
Declares a PostgreSQL
CAST.When this cast can be applied: only in explicit form, when used in
assignment context, or implicitly whenever needed.
A known conversion path when a dedicated function is not supplied:
BINARY for two types that are known to have the same internal
representation, or INOUT to invoke the first type's text-output
function followed by the second type's text-input function.Base interface representing some object in the PostgreSQL catalogs,
identified by its
oid.Interface for any catalog object with an access control list
(a list of some type of
Grant).A catalog object that has both
oid and classId specified,
and can be looked up in the PostgreSQL catalogs (where it may, or may
not, be found).Interface for an object that is regarded as a component of some, other,
addressed catalog object, and is identified by that other object's
classId and oid along with an integer subId.Interface representing any single
Grant (or ACL item), a grant
of some set of possible privileges, to some role, granted by some role.Subtype of
Grant representing the privileges that may be
granted on an attribute (or column).Subtype of
Grant representing the privileges that may be
granted on a class (or relation, table, view).Subtype of
Grant representing the privileges that may be
granted on a database.Subtype of
Grant representing the privileges that may be
granted on a namespace (or schema).Subtype of
Grant representing the grants (of membership in,
and/or privileges of, other roles) that may be made to a role.Subtype of
Grant representing the privileges that may be
granted on a configuration setting.Interface for any catalog object that has a name, which can be
an
Identifier.Simple or an
Identifier.Operator.Interface for any catalog object that has a name and also a namespace
or schema (an associated instance of
RegNamespace).Interface for any catalog object that has an owner (an associated
instance of
RegRole.Represents one of PostgreSQL's available character set encodings.
A distinguished
CharsetEncoding representing uses such as
-1 in the collencoding column of pg_collation,
indicating the collation is usable with any encoding.Model of the PostgreSQL
pg_constraint system catalog.Model of a database defined within the PostgreSQL cluster.
Container for abstract-type functional interfaces in PostgreSQL's
DATETIME type category.The
DATE type's PostgreSQL semantics: a signed number of days
since the "Postgres epoch".A reference implementation that maps to
LocalDate.The
TIME type's PostgreSQL semantics: microseconds since
midnight.A reference implementation that maps to
LocalTime.Functional interface to obtain information from the PostgreSQL type
modifier applied to the type.
The
TIMESTAMP type's PostgreSQL semantics: microseconds since
midnight of the PostgreSQL epoch, without an assumed time zone.A reference implementation that maps to
LocalDateTime.Functional interface to obtain information from the PostgreSQL type
modifier applied to the type.
The
TIMESTAMPTZ type's PostgreSQL semantics: microseconds since
midnight UTC of the PostgreSQL epoch.A reference implementation that maps to
OffsetDateTime.Functional interface to obtain information from the PostgreSQL type
modifier applied to the type.
The
TIMETZ type's PostgreSQL semantics: microseconds since
midnight, accompanied by a time zone offset expressed in seconds.A reference implementation that maps to
OffsetTime.Functional interface to obtain information from the PostgreSQL type
modifier applied to the type.
Raw access to the contents of a PostgreSQL datum.
Accessor for a
Datum located, at some offset, in
memory represented by a <B> object.An accessor for use with a 'deformed' (array-of-
Datum)
memory layout.An accessor for use with a heap-tuple styled, flattened,
memory layout.
Interface through which PL/Java code reads the content of an existing
PostgreSQL datum.
Empty superinterface of
Accessor.Deformed and
Accessor.Heap, which are erased at run time but help distinguish,
in source code, which memory layout convention an Accessor
is tailored for.Model of a PostgreSQL extension that has been installed for the current
database.
Annotates a Java method for which an SQL function declaration should be
generated into the deployment descriptor file.
The volatility
category
describing the presence or absence of side-effects constraining what
the optimizer can safely do with the function.
Whether the function is called even for null input,
or known to return null in that case and therefore not called.
Whether the function is unsafe to use in any parallel query plan at all,
or avoids certain operations and can appear in such a plan but must be
executed only in the parallel group leader, or avoids an even larger
set of operations and is safe to execute anywhere in a parallel plan.
Whether the function executes with the same identity and
permissions as the role that has invoked it (the usual case), or
with the rights of the role that defined it (such as to
offer controlled access to data the invoker would otherwise have
no access to).
Whether the function only needs limited capabilities and can
run in the "trusted" language sandbox, or has to be unsandboxed
and run in an "untrusted" language instance.
Container for abstract-type functional interfaces in PostgreSQL's
GEOMETRIC type category.The
BOX type's PostgreSQL semantics: two corner points.The
CIRCLE type's PostgreSQL semantics: center point and radius.The
LINE type's PostgreSQL semantics: coefficients of its
general equation Ax+By+C=0.The
LSEG type's PostgreSQL semantics: two endpoints.The
PATH type's PostgreSQL semantics: vertex points and whether
closed.The
POINT type's PostgreSQL semantics: a pair of float8
coordinates.The
POLYGON type's PostgreSQL semantics: vertex points and
a bounding box.Container for abstract-type functional interfaces, not quite exactly
corresponding to PostgreSQL's
INTERNAL category; there are some
fairly "internal" types that ended up in the USER category too,
for whatever reason.The
tid type's PostgreSQL semantics: a block ID and
a row index within that block.A few useful SQL lexical definitions supplied as
Pattern objects.Class representing a SQL identifier.
What is the name of an unnamed parameter or column?
Class representing an Identifier that names a PostgreSQL operator.
Displays/deparses like a
Simple identifier, but no singleton
of this class matches anything but itself, to represent
pseudo-identifiers like PUBLIC as a privilege grantee.Class representing a schema-qualified identifier.
Class representing an unqualified identifier in the form of a name
(whether a case-insensitive "regular identifier" without quotes,
or a delimited form).
Model of any notional object in PostgreSQL or PL/Java that has a definite
temporal existence, with a detectable end, and so can be used to scope the
lifetime of any PL/Java object that has corresponding native resources.
Annotation on a PL/Java class that will either map an existing PostgreSQL
type (provided its internal storage form is well understood), or create and
map a new PostgreSQL composite type
(a/k/a "structured type" in the standards).
A PostgreSQL
MemoryContext, which is usable as a PL/Java
Lifespan to scope the lifetimes of PL/Java objects
(as when they depend on native memory allocated in the underlying context).The
MONEY type's PostgreSQL semantics: an integer value, whose
scaling, display format, and currency are all determined by a
user-settable configuration setting.Container for abstract-type functional interfaces in PostgreSQL's
NETWORK type category (and MAC addresses, which, for arcane reasons,
are not in that category).The
INET and CIDR types' PostgreSQL semantics: the
family (INET or INET6), the number of network prefix
bits, and the address bytes in network byte order.The
macaddr and macaddr8 types' PostgreSQL semantics:
a byte array (6 or 8 bytes, respectively)., of which byte 0 is the one
appearing first in the text representation (and stored in the member
named a of the C struct).The
NUMERIC type's PostgreSQL semantics: a sign (or indication
that the value is NaN, + infinity, or - infinity), a display scale,
a weight, and zero or more base-ten-thousand digits.A reference implementation that maps to
BigDecimal
(but cannot represent all possible values).Label to distinguish positive, negative, and three kinds of special
values.
Functional interface to obtain information from the PostgreSQL type
modifier applied to the type.
A pool of objects of a single class.
Declares a PostgreSQL
OPERATOR.Names of several functions predefined in PostgreSQL for estimating the
selectivity of operators in restriction clauses or joins.
Interface for a procedural language on PL/Java infrastructure.
To be implemented by a language that supports inline code blocks.
The result of a
specialize call on
a Template.To be implemented by a language that supports routines (that is,
functions and/or procedures).
The result of a
prepare call on a PL/Java-based
routine.The result of a
specialize call on
a TriggerTemplate.To be implemented by a language that supports triggers.
The result of a
prepareTrigger call on
a PL/Java-based trigger function.To be implemented by a language that supports routines declared with
TRANSFORM FOR TYPE.Java
Principal representing a PostgreSQL PROCEDURAL LANGUAGE,
which has a name (a simple identifier, not schema-qualified) and is either
Sandboxed (declared with SQL CREATE TRUSTED LANGUAGE or
Unsandboxed.Java
Principal representing a PostgreSQL
PROCEDURAL LANGUAGE that was declared with the TRUSTED
keyword and can be used to declare new functions by any role that has
been granted USAGE permission on it.Java
Principal representing a PostgreSQL
PROCEDURAL LANGUAGE that was declared without the
TRUSTED keyword, and can be used to declare new functions only
by a PostgreSQL superuser.Interface for objects that are pooled and reused.
Models a PostgreSQL
Portal, an object representing the ongoing
execution of a query and capable of returning a TupleDescriptor for
the result, and fetching tuples of the result, either all at once, or in
smaller batches.Model of a PostgreSQL procedural language, including (for non-built-in
languages, like PL/Java) the handler functions used in its implementation.
A
How memo attached to a RegProcedure that represents
a PL/Java-based routine, retaining additional information useful to
a PL/Java-based language implementation.Model of PostgreSQL relations/"classes"/tables.
A more-specifically-typed subinterface of
RegClass, used in the
CLASSID static fields of interfaces in this package.Model of a registered PostgreSQL collation, consisting of a provider and
version,
collate and ctype strings meaningful to that
provider, and a CharsetEncoding (or ANY if the collation
is usable with any encoding).A PostgreSQL text search configuration.
A PostgreSQL text search dictionary.
Model of a namespace (named schema) entry in the PostgreSQL catalogs.
Model of a PostgreSQL operator as defined in the system catalogs, including
its kind (infix or prefix), operand and result types, and a number of
properties helpful in query planning.
Model of a PostgreSQL "routine" (which in late versions can include
procedures and functions of various kinds) as defined in the system catalogs,
including its parameter and result types and many other properties.
Counterpart to the PostgreSQL
FunctionCallInfoBaseData.Supplied when the routine being called is a procedure
rather than a function.
Supplied when the routine is being called as a trigger.
Counterpart to the PostgreSQL
FmgrInfo.Superinterface of memos that pertain to the internal implementation
of a
RegProcedure (how it is
implemented).Superinterface of memos that pertain to the intended use of a
RegProcedure (why it is used).Model of a PostgreSQL role.
Subinterface of
RegRole returned by methods of
CatalogObject.AccessControlled
identifying the role to which a privilege has been granted.Model of a PostgreSQL data type, as defined in the system catalogs.
Interface additionally implemented by an instance that represents a type
(such as the PostgreSQL polymorphic pseudotypes or the even wilder "any"
type) needing resolution to an actual type used at a given call site.
The representation of a PostgreSQL
ResourceOwner, usable as
a PL/Java Lifespan.An implementation of this interface is returned from functions and procedures
that are declared to return
SET OF a complex type in the form
of a ResultSet.An implementation of this interface is returned from functions and procedures
that are declared to return
SET OF a complex type.Version of
ResultSetProvider where the assignRowValues
method accepting a long row count must be implemented, and the
int version defaults to using it.Interface for a listener to be notified of the start and pre-commit, commit,
or abort of savepoints.
A Session brings together some useful methods and data for the current
database session.
The SessionManager makes the current
Session available to the
caller.A temporary test jig during TupleTableSlot development, not intended to last.
A temporary marker interface used on classes or interfaces whose
static final fields should be visible to
adapterPlease.Annotation that supplies verbatim commands to be copied into the
deployment descriptor.
Container for multiple
SQLAction annotations (in case it is
convenient to hang more than one on a given program element).Optionally annotates a Java method parameter, to supply an explicit
SQL type for use in the SQL function declaration in place of the
automatically mapped type, and/or to supply an SQL default value.
Identifies attributes to be retrieved from a set of tuples.
A
TargetList that has been bound to a source of tuples and can
execute code with the wanted attribute values available.A
TargetList in which no one attribute may appear more than once.Container for abstract-type functional interfaces in PostgreSQL's
TIMESPAN type category (which, at present, includes the single
type INTERVAL).The
INTERVAL type's PostgreSQL semantics: separate microseconds,
days, and months components, independently signed.Functional interface to obtain information from the PostgreSQL type
modifier applied to the type.
Interface for a listener to be notified of prepare, and commit, abort,
or other phase transitions, of distributed transactions.
Model of the PostgreSQL
pg_transform system catalog.Annotation, only used in
@Function(triggers=...),
to specify what trigger(s) the function will be called for.Model of a trigger entry in the PostgreSQL catalogs.
Whether the trigger is invoked before or after the specified event.
Deferrability (only applies to constraint triggers).
Types of event that can occasion a trigger.
Whether the trigger will occur only once for a statement of interest,
or once for each row affected by the statement.
The data passed to an ordinary (insert/update/delete/truncate) trigger
function.
An exception specially suited to be thrown from within a method
designated to be a trigger function.
Conceptually, a
TupleDescriptor is a list of Attribute, with
a RegType that identifies its corresponding row type.A descriptor that has been constructed on the fly and has not been
interned.
A descriptor that either describes a known composite type in the
catalogs, or has been interned in PostgreSQL's type cache, and has
a distinct
rowType that can be used to identify it
for the duration of the session.A PostgreSQL abstraction that can present a variety of underlying tuple
representations in a common way.
A form of
TupleTableSlot consisting of a number of indexable
elements all of the same type, described by the single Attribute
of a one-element TupleDescriptor.Methods that have variants on twos-complement Java types that might be signed
or unsigned.
Mixin with default signed implementations of the interface methods.
Mixin with default unsigned implementations of the interface methods.
A
Verifier verifies the proper form of content written to a
Datum.A verifier interface to be used when the
ByteBuffer API provides
the most natural interface for manipulating the content.A verifier interface to be used when the
InputStream API provides
the most natural interface for manipulating the content.