pglast.ast — Python classes representing PG parser nodes

The module implements a set of data classes, one for each C structure defined in several PostgreSQL headers, primarily those in the include/nodes/ directory.

The pglast.ast.Node (not to be confused with pglast.node.Node which is just a readonly generic wrapper) is an abstract class that implements the common behaviour of all the concrete classes. In particular any node can be compared with another instance, is able to serialize itself and can be altered.

class pglast.ast.Node(data)

Base class for all AST nodes.

__call__(depth=None, ellipsis=…, skip_none=False)

Serialize the node as a structure made of simple Python data-types.

Parameters
  • depth (None or int) – if not None, the maximum depth to reach

  • ellipsis – the marker value that will be used to replace cut-off branch

  • skip_none (bool) – whether None-valued attributes should be elided

  • enum_name (bool) – whether Enums will be rendered as their name only

Returns

a dict instance

This performs a top-down recursive visit to the whole AST tree: each Node instance becomes a dictionary with a special @ key carrying the node type, lists becomes tuples and Enum instances become dictionaries with a special # key carrying the enum name.

__eq__(other)

Compare two nodes, returning True if they are considered equivalent.

This is mainly an helper method used by tests: for this reason, two nodes are considered equal when all their attributes match, ignoring positional ones such as location, stmt_len and stmt_location.

__repr__()

Build a representation of the whole node and its subtree, for debug.

__setattr__(name, value)

Validate the given value and if acceptable assign it to the name attribute.

This tries to coerce the given value accordingly with the ctype of the attribute, raising opportune exception when that is not possible.

class pglast.ast.Value(value=None)

Abstract super class, representing PG’s Value union type.

class pglast.ast.BitString(value=None)

Implement the T_BitString variant of the Value union.

class pglast.ast.Float(value=None)

Implement the T_Float variant of the Value union.

class pglast.ast.Integer(value=None)

Implement the T_Integer variant of the Value union.

class pglast.ast.Null(value=None)

Implement the T_Null variant of the Value union.

class pglast.ast.String(value=None)

Implement the T_String variant of the Value union.

class pglast.ast.A_ArrayExpr(elements=None, location=None)

Wrapper for the homonymous parser node.

elements: tuple

Array element expressions

location: int

Token location, or -1 if unknown

class pglast.ast.A_Const(val=None, location=None)

Wrapper for the homonymous parser node.

val: Value

Value (includes type info, see value.h)

location: int

Token location, or -1 if unknown

class pglast.ast.A_Expr(kind=None, name=None, lexpr=None, rexpr=None, location=None)

Wrapper for the homonymous parser node.

kind: A_Expr_Kind
name: tuple

Possibly-qualified name of operator

lexpr: Node

Left argument, or NULL if none

rexpr: Node

Right argument, or NULL if none

location: int

Token location, or -1 if unknown

class pglast.ast.A_Indices(is_slice=None, lidx=None, uidx=None)

Wrapper for the homonymous parser node.

is_slice: bool

True if slice (i.e., colon present)

lidx: Node

Slice lower bound, if any

uidx: Node

Subscript, or slice upper bound if any

class pglast.ast.A_Indirection(arg=None, indirection=None)

Wrapper for the homonymous parser node.

arg: Node

The thing being selected from

indirection: tuple

Subscripts and/or field names and/or *

class pglast.ast.A_Star

Wrapper for the homonymous parser node.

class pglast.ast.AccessPriv(priv_name=None, cols=None)

Wrapper for the homonymous parser node.

priv_name: str

String name of privilege

cols: tuple

List of Value strings

class pglast.ast.Aggref(aggargtypes=None, aggdirectargs=None, args=None, aggorder=None, aggdistinct=None, aggfilter=None, aggstar=None, aggvariadic=None, aggkind=None, agglevelsup=None, aggsplit=None, location=None)

Wrapper for the homonymous parser node.

aggargtypes: tuple

Type Oids of direct and aggregated args

aggdirectargs: tuple

Direct arguments, if an ordered-set agg

args: tuple

Aggregated arguments and sort expressions

aggorder: tuple

ORDER BY (list of SortGroupClause)

aggdistinct: tuple

DISTINCT (list of SortGroupClause)

aggfilter: Expr*

FILTER expression, if any

aggstar: bool

True if argument list was really ‘*’

aggvariadic: bool

True if variadic arguments have been combined into an array last argument

aggkind: str

Aggregate kind (see pg_aggregate.h)

agglevelsup: Index

> 0 if agg belongs to outer query

aggsplit: AggSplit

Expected agg-splitting mode of parent Agg

location: int

Token location, or -1 if unknown

class pglast.ast.Alias(aliasname=None, colnames=None)

Wrapper for the homonymous parser node.

aliasname: str

Aliased rel name (never qualified)

colnames: tuple

Optional list of column aliases

class pglast.ast.AlterCollationStmt(collname=None)

Wrapper for the homonymous parser node.

collname: tuple
class pglast.ast.AlterDatabaseSetStmt(dbname=None, setstmt=None)

Wrapper for the homonymous parser node.

dbname: str

Database name

setstmt: VariableSetStmt*

SET or RESET subcommand

class pglast.ast.AlterDatabaseStmt(dbname=None, options=None)

Wrapper for the homonymous parser node.

dbname: str

Name of database to alter

options: tuple

List of DefElem nodes

class pglast.ast.AlterDefaultPrivilegesStmt(options=None, action=None)

Wrapper for the homonymous parser node.

options: tuple

List of DefElem

action: GrantStmt*

GRANT/REVOKE action (with objects=NIL)

class pglast.ast.AlterDomainStmt(subtype=None, typeName=None, name=None, def_=None, behavior=None, missing_ok=None)

Wrapper for the homonymous parser node.

subtype: str
  • T = alter column default

  • N = alter column drop not null

  • O = alter column set not null

  • C = add constraint

  • X = drop constraint

typeName: tuple

Domain to work on

name: str

Column or constraint name to act on

def_: Node

Definition of default or constraint

behavior: DropBehavior

RESTRICT or CASCADE for DROP cases

missing_ok: bool

Skip error if missing?

class pglast.ast.AlterEnumStmt(typeName=None, oldVal=None, newVal=None, newValNeighbor=None, newValIsAfter=None, skipIfNewValExists=None)

Wrapper for the homonymous parser node.

typeName: tuple

Qualified name (list of Value strings)

oldVal: str

Old enum value’s name, if renaming

newVal: str

New enum value’s name

newValNeighbor: str

Neighboring enum value, if specified

newValIsAfter: bool

Place new enum value after neighbor?

skipIfNewValExists: bool

No error if new already exists?

class pglast.ast.AlterEventTrigStmt(trigname=None, tgenabled=None)

Wrapper for the homonymous parser node.

trigname: str

TRIGGER’s name

tgenabled: str

Trigger’s firing configuration WRT session_replication_role

class pglast.ast.AlterExtensionContentsStmt(extname=None, action=None, objtype=None, object=None)

Wrapper for the homonymous parser node.

extname: str

Extension’s name

action: int

+1 = add object, -1 = drop object

objtype: ObjectType

Object’s type

object: Node

Qualified name of the object

class pglast.ast.AlterExtensionStmt(extname=None, options=None)

Wrapper for the homonymous parser node.

extname: str
options: tuple

List of DefElem nodes

class pglast.ast.AlterFdwStmt(fdwname=None, func_options=None, options=None)

Wrapper for the homonymous parser node.

fdwname: str

Foreign-data wrapper name

func_options: tuple

HANDLER/VALIDATOR options

options: tuple

Generic options to FDW

class pglast.ast.AlterForeignServerStmt(servername=None, version=None, options=None, has_version=None)

Wrapper for the homonymous parser node.

servername: str

Server name

version: str

Optional server version

options: tuple

Generic options to server

has_version: bool

Version specified

class pglast.ast.AlterFunctionStmt(objtype=None, func=None, actions=None)

Wrapper for the homonymous parser node.

objtype: ObjectType
func: ObjectWithArgs*

Name and args of function

actions: tuple

List of DefElem

class pglast.ast.AlterObjectDependsStmt(objectType=None, relation=None, object=None, extname=None, remove=None)

Wrapper for the homonymous parser node.

objectType: ObjectType

OBJECT_FUNCTION, OBJECT_TRIGGER, etc

relation: RangeVar*

In case a table is involved

object: Node

Name of the object

extname: Value*

Extension name

remove: bool

Set true to remove dep rather than add

class pglast.ast.AlterObjectSchemaStmt(objectType=None, relation=None, object=None, newschema=None, missing_ok=None)

Wrapper for the homonymous parser node.

objectType: ObjectType

OBJECT_TABLE, OBJECT_TYPE, etc

relation: RangeVar*

In case it’s a table

object: Node

In case it’s some other object

newschema: str

The new schema

missing_ok: bool

Skip error if missing?

class pglast.ast.AlterOpFamilyStmt(opfamilyname=None, amname=None, isDrop=None, items=None)

Wrapper for the homonymous parser node.

opfamilyname: tuple

Qualified name (list of Value strings)

amname: str

Name of index AM opfamily is for

isDrop: bool

ADD or DROP the items?

items: tuple

List of CreateOpClassItem nodes

class pglast.ast.AlterOperatorStmt(opername=None, options=None)

Wrapper for the homonymous parser node.

opername: ObjectWithArgs*

Operator name and argument types

options: tuple

List of DefElem nodes

class pglast.ast.AlterOwnerStmt(objectType=None, relation=None, object=None, newowner=None)

Wrapper for the homonymous parser node.

objectType: ObjectType

OBJECT_TABLE, OBJECT_TYPE, etc

relation: RangeVar*

In case it’s a table

object: Node

In case it’s some other object

newowner: RoleSpec*

The new owner

class pglast.ast.AlterPolicyStmt(policy_name=None, table=None, roles=None, qual=None, with_check=None)

Wrapper for the homonymous parser node.

policy_name: str

Policy’s name

table: RangeVar*

The table name the policy applies to

roles: tuple

The roles associated with the policy

qual: Node

The policy’s condition

with_check: Node

The policy’s WITH CHECK condition.

class pglast.ast.AlterPublicationStmt(pubname=None, options=None, tables=None, for_all_tables=None, tableAction=None)

Wrapper for the homonymous parser node.

pubname: str

Name of the publication

options: tuple

List of DefElem nodes

tables: tuple

List of tables to add/drop

for_all_tables: bool

Special publication for all tables in db

tableAction: DefElemAction

What action to perform with the tables

class pglast.ast.AlterRoleSetStmt(role=None, database=None, setstmt=None)

Wrapper for the homonymous parser node.

role: RoleSpec*

Role

database: str

Database name, or NULL

setstmt: VariableSetStmt*

SET or RESET subcommand

class pglast.ast.AlterRoleStmt(role=None, options=None, action=None)

Wrapper for the homonymous parser node.

role: RoleSpec*

Role

options: tuple

List of DefElem nodes

action: int

+1 = add members, -1 = drop members

class pglast.ast.AlterSeqStmt(sequence=None, options=None, for_identity=None, missing_ok=None)

Wrapper for the homonymous parser node.

sequence: RangeVar*

The sequence to alter

options: tuple
for_identity: bool
missing_ok: bool

Skip error if a role is missing?

class pglast.ast.AlterStatsStmt(defnames=None, stxstattarget=None, missing_ok=None)

Wrapper for the homonymous parser node.

defnames: tuple

Qualified name (list of Value strings)

stxstattarget: int

Statistics target

missing_ok: bool

Skip error if statistics object is missing

class pglast.ast.AlterSubscriptionStmt(kind=None, subname=None, conninfo=None, publication=None, options=None)

Wrapper for the homonymous parser node.

kind: AlterSubscriptionType

ALTER_SUBSCRIPTION_OPTIONS, etc

subname: str

Name of the subscription

conninfo: str

Connection string to publisher

publication: tuple

One or more publication to subscribe to

options: tuple

List of DefElem nodes

class pglast.ast.AlterSystemStmt(setstmt=None)

Wrapper for the homonymous parser node.

setstmt: VariableSetStmt*

SET subcommand

class pglast.ast.AlterTSConfigurationStmt(kind=None, cfgname=None, tokentype=None, dicts=None, override=None, replace=None, missing_ok=None)

Wrapper for the homonymous parser node.

kind: AlterTSConfigType

ALTER_TSCONFIG_ADD_MAPPING, etc

cfgname: tuple

Qualified name (list of Value strings)

tokentype: tuple

List of Value strings

dicts: tuple

List of list of Value strings

override: bool

If true - remove old variant

replace: bool

If true - replace dictionary by another

missing_ok: bool

For DROP - skip error if missing?

class pglast.ast.AlterTSDictionaryStmt(dictname=None, options=None)

Wrapper for the homonymous parser node.

dictname: tuple

Qualified name (list of Value strings)

options: tuple

List of DefElem nodes

class pglast.ast.AlterTableCmd(subtype=None, name=None, num=None, newowner=None, def_=None, behavior=None, missing_ok=None)

Wrapper for the homonymous parser node.

subtype: AlterTableType

Type of table alteration to apply

name: str

Column, constraint, or trigger to act on, or tablespace

num: int16

Attribute number for columns referenced by number

newowner: RoleSpec*
def_: Node

Definition of new column, index, constraint, or parent table

behavior: DropBehavior

RESTRICT or CASCADE for DROP cases

missing_ok: bool

Skip error if missing?

class pglast.ast.AlterTableMoveAllStmt(orig_tablespacename=None, objtype=None, roles=None, new_tablespacename=None, nowait=None)

Wrapper for the homonymous parser node.

orig_tablespacename: str
objtype: ObjectType

Object type to move

roles: tuple

List of roles to move objects of

new_tablespacename: str
nowait: bool
class pglast.ast.AlterTableSpaceOptionsStmt(tablespacename=None, options=None, isReset=None)

Wrapper for the homonymous parser node.

tablespacename: str
options: tuple
isReset: bool
class pglast.ast.AlterTableStmt(relation=None, cmds=None, relkind=None, missing_ok=None)

Wrapper for the homonymous parser node.

relation: RangeVar*

Table to work on

cmds: tuple

List of subcommands

relkind: ObjectType

Type of object

missing_ok: bool

Skip error if table missing

class pglast.ast.AlterTypeStmt(typeName=None, options=None)

Wrapper for the homonymous parser node.

typeName: tuple

Type name (possibly qualified)

options: tuple

List of DefElem nodes

class pglast.ast.AlterUserMappingStmt(user=None, servername=None, options=None)

Wrapper for the homonymous parser node.

user: RoleSpec*

User role

servername: str

Server name

options: tuple

Generic options to server

class pglast.ast.AlternativeSubPlan(subplans=None)

Wrapper for the homonymous parser node.

subplans: tuple

SubPlan(s) with equivalent results

class pglast.ast.ArrayCoerceExpr(arg=None, elemexpr=None, resulttypmod=None, coerceformat=None, location=None)

Wrapper for the homonymous parser node.

arg: Expr*

Input expression (yields an array)

elemexpr: Expr*

Expression representing per-element work

resulttypmod: int32

Output typmod (also element typmod)

coerceformat: CoercionForm

How to display this node

location: int

Token location, or -1 if unknown

class pglast.ast.ArrayExpr(elements=None, multidims=None, location=None)

Wrapper for the homonymous parser node.

elements: tuple

The array elements or sub-arrays

multidims: bool

True if elements are sub-arrays

location: int

Token location, or -1 if unknown

class pglast.ast.BoolExpr(boolop=None, args=None, location=None)

Wrapper for the homonymous parser node.

boolop: BoolExprType
args: tuple

Arguments to this expression

location: int

Token location, or -1 if unknown

class pglast.ast.BooleanTest(arg=None, booltesttype=None, location=None)

Wrapper for the homonymous parser node.

arg: Expr*

Input expression

booltesttype: BoolTestType

Test type

location: int

Token location, or -1 if unknown

class pglast.ast.CallContext(atomic=None)

Wrapper for the homonymous parser node.

atomic: bool
class pglast.ast.CallStmt(funccall=None, funcexpr=None)

Wrapper for the homonymous parser node.

funccall: FuncCall*

From the parser

funcexpr: FuncExpr*

Transformed

class pglast.ast.CaseExpr(arg=None, args=None, defresult=None, location=None)

Wrapper for the homonymous parser node.

arg: Expr*

Implicit equality comparison argument

args: tuple

The arguments (list of WHEN clauses)

defresult: Expr*

The default result (ELSE clause)

location: int

Token location, or -1 if unknown

class pglast.ast.CaseTestExpr(typeMod=None)

Wrapper for the homonymous parser node.

typeMod: int32

Typemod for substituted value

class pglast.ast.CaseWhen(expr=None, result=None, location=None)

Wrapper for the homonymous parser node.

expr: Expr*

Condition expression

result: Expr*

Substitution result

location: int

Token location, or -1 if unknown

class pglast.ast.CheckPointStmt

Wrapper for the homonymous parser node.

class pglast.ast.ClosePortalStmt(portalname=None)

Wrapper for the homonymous parser node.

portalname: str

Name of the portal (cursor)

class pglast.ast.ClusterStmt(relation=None, indexname=None, options=None)

Wrapper for the homonymous parser node.

relation: RangeVar*

Relation being indexed, or NULL if all

indexname: str

Original index defined

options: int

OR of ClusterOption flags

class pglast.ast.CoalesceExpr(args=None, location=None)

Wrapper for the homonymous parser node.

args: tuple

The arguments

location: int

Token location, or -1 if unknown

class pglast.ast.CoerceToDomain(arg=None, resulttypmod=None, coercionformat=None, location=None)

Wrapper for the homonymous parser node.

arg: Expr*

Input expression

resulttypmod: int32

Output typmod (currently always -1)

coercionformat: CoercionForm

How to display this node

location: int

Token location, or -1 if unknown

class pglast.ast.CoerceToDomainValue(typeMod=None, location=None)

Wrapper for the homonymous parser node.

typeMod: int32

Typemod for substituted value

location: int

Token location, or -1 if unknown

class pglast.ast.CoerceViaIO(arg=None, coerceformat=None, location=None)

Wrapper for the homonymous parser node.

arg: Expr*

Input expression

coerceformat: CoercionForm

How to display this node

location: int

Token location, or -1 if unknown

class pglast.ast.CollateClause(arg=None, collname=None, location=None)

Wrapper for the homonymous parser node.

arg: Node

Input expression

collname: tuple

Possibly-qualified collation name

location: int

Token location, or -1 if unknown

class pglast.ast.CollateExpr(arg=None, location=None)

Wrapper for the homonymous parser node.

arg: Expr*

Input expression

location: int

Token location, or -1 if unknown

class pglast.ast.ColumnDef(colname=None, typeName=None, inhcount=None, is_local=None, is_not_null=None, is_from_type=None, storage=None, raw_default=None, cooked_default=None, identity=None, identitySequence=None, generated=None, collClause=None, constraints=None, fdwoptions=None, location=None)

Wrapper for the homonymous parser node.

colname: str

Name of column

typeName: TypeName*

Type of column

inhcount: int

Number of times column is inherited

is_local: bool

Column has local (non-inherited) def’n

is_not_null: bool

NOT NULL constraint specified?

is_from_type: bool

Column definition came from table type

storage: str

Attstorage setting, or 0 for default

raw_default: Node

Default value (untransformed parse tree)

cooked_default: Node

Default value (transformed expr tree)

identity: str

Attidentity setting

identitySequence: RangeVar*

To store identity sequence name for ALTER TABLE … ADD COLUMN

generated: str

Attgenerated setting

collClause: CollateClause*

Untransformed COLLATE spec, if any

constraints: tuple

Other constraints on column

fdwoptions: tuple

Per-column FDW options

location: int

Parse location, or -1 if none/unknown

class pglast.ast.ColumnRef(fields=None, location=None)

Wrapper for the homonymous parser node.

fields: tuple

Field names (Value strings) or A_Star

location: int

Token location, or -1 if unknown

class pglast.ast.CommentStmt(objtype=None, object=None, comment=None)

Wrapper for the homonymous parser node.

objtype: ObjectType

Object’s type

object: Node

Qualified name of the object

comment: str

Comment to insert, or NULL to remove

class pglast.ast.CommonTableExpr(ctename=None, aliascolnames=None, ctematerialized=None, ctequery=None, location=None, cterecursive=None, cterefcount=None, ctecolnames=None, ctecoltypes=None, ctecoltypmods=None, ctecolcollations=None)

Wrapper for the homonymous parser node.

ctename: str

Query name (never qualified)

aliascolnames: tuple

Optional list of column names

ctematerialized: CTEMaterialize

Is this an optimization fence?

ctequery: Node

The CTE’s subquery

location: int

Token location, or -1 if unknown

cterecursive: bool

Is this CTE actually recursive?

cterefcount: int

Number of RTEs referencing this CTE (excluding internal self-references)

ctecolnames: tuple

List of output column names

ctecoltypes: tuple

OID list of output column type OIDs

ctecoltypmods: tuple

Integer list of output column typmods

ctecolcollations: tuple

OID list of column collation OIDs

class pglast.ast.CompositeTypeStmt(typevar=None, coldeflist=None)

Wrapper for the homonymous parser node.

typevar: RangeVar*

The composite type to be created

coldeflist: tuple

List of ColumnDef nodes

class pglast.ast.Constraint(contype=None, conname=None, deferrable=None, initdeferred=None, location=None, is_no_inherit=None, raw_expr=None, cooked_expr=None, generated_when=None, keys=None, including=None, exclusions=None, options=None, indexname=None, indexspace=None, reset_default_tblspc=None, access_method=None, where_clause=None, pktable=None, fk_attrs=None, pk_attrs=None, fk_matchtype=None, fk_upd_action=None, fk_del_action=None, old_conpfeqop=None, skip_validation=None, initially_valid=None)

Wrapper for the homonymous parser node.

contype: ConstrType
conname: str

Constraint name, or NULL if unnamed

deferrable: bool

DEFERRABLE?

initdeferred: bool

INITIALLY DEFERRED?

location: int

Token location, or -1 if unknown

is_no_inherit: bool

Is constraint non-inheritable?

raw_expr: Node

Expr, as untransformed parse tree

cooked_expr: str

Expr, as nodeToString representation

generated_when: str

ALWAYS or BY DEFAULT

keys: tuple

String nodes naming referenced key column(s)

including: tuple

String nodes naming referenced nonkey column(s)

exclusions: tuple

List of (IndexElem, operator name) pairs

options: tuple

Options from WITH clause

indexname: str

Existing index to use; otherwise NULL

indexspace: str

Index tablespace; NULL for default

reset_default_tblspc: bool

Reset default_tablespace prior to creating the index

access_method: str

Index access method; NULL for default

where_clause: Node

Partial index predicate

pktable: RangeVar*

Primary key table

fk_attrs: tuple

Attributes of foreign key

pk_attrs: tuple

Corresponding attrs in PK table

fk_matchtype: str

FULL, PARTIAL, SIMPLE

fk_upd_action: str

ON UPDATE action

fk_del_action: str

ON DELETE action

old_conpfeqop: tuple

Pg_constraint.conpfeqop of my former self

skip_validation: bool

Skip validation of existing rows?

initially_valid: bool

Mark the new constraint as valid?

class pglast.ast.ConstraintsSetStmt(constraints=None, deferred=None)

Wrapper for the homonymous parser node.

constraints: tuple

List of names as RangeVars

deferred: bool
class pglast.ast.ConvertRowtypeExpr(arg=None, convertformat=None, location=None)

Wrapper for the homonymous parser node.

arg: Expr*

Input expression

convertformat: CoercionForm

How to display this node

location: int

Token location, or -1 if unknown

class pglast.ast.CopyStmt(relation=None, query=None, attlist=None, is_from=None, is_program=None, filename=None, options=None, whereClause=None)

Wrapper for the homonymous parser node.

relation: RangeVar*

The relation to copy

query: Node

The query (SELECT or DML statement with RETURNING) to copy, as a raw parse tree

attlist: tuple

List of column names (as Strings), or NIL for all columns

is_from: bool

TO or FROM

is_program: bool

Is ‘filename’ a program to popen?

filename: str

Filename, or NULL for STDIN/STDOUT

options: tuple

List of DefElem nodes

whereClause: Node

WHERE condition (or NULL)

class pglast.ast.CreateAmStmt(amname=None, handler_name=None, amtype=None)

Wrapper for the homonymous parser node.

amname: str

Access method name

handler_name: tuple

Handler function name

amtype: str

Type of access method

class pglast.ast.CreateCastStmt(sourcetype=None, targettype=None, func=None, context=None, inout=None)

Wrapper for the homonymous parser node.

sourcetype: TypeName*
targettype: TypeName*
func: ObjectWithArgs*
context: CoercionContext
inout: bool
class pglast.ast.CreateConversionStmt(conversion_name=None, for_encoding_name=None, to_encoding_name=None, func_name=None, def_=None)

Wrapper for the homonymous parser node.

conversion_name: tuple

Name of the conversion

for_encoding_name: str

Source encoding name

to_encoding_name: str

Destination encoding name

func_name: tuple

Qualified conversion function name

def_: bool

Is this a default conversion?

class pglast.ast.CreateDomainStmt(domainname=None, typeName=None, collClause=None, constraints=None)

Wrapper for the homonymous parser node.

domainname: tuple

Qualified name (list of Value strings)

typeName: TypeName*

The base type

collClause: CollateClause*

Untransformed COLLATE spec, if any

constraints: tuple

Constraints (list of Constraint nodes)

class pglast.ast.CreateEnumStmt(typeName=None, vals=None)

Wrapper for the homonymous parser node.

typeName: tuple

Qualified name (list of Value strings)

vals: tuple

Enum values (list of Value strings)

class pglast.ast.CreateEventTrigStmt(trigname=None, eventname=None, whenclause=None, funcname=None)

Wrapper for the homonymous parser node.

trigname: str

TRIGGER’s name

eventname: str

Event’s identifier

whenclause: tuple

List of DefElems indicating filtering

funcname: tuple

Qual. name of function to call

class pglast.ast.CreateExtensionStmt(extname=None, if_not_exists=None, options=None)

Wrapper for the homonymous parser node.

extname: str
if_not_exists: bool

Just do nothing if it already exists?

options: tuple

List of DefElem nodes

class pglast.ast.CreateFdwStmt(fdwname=None, func_options=None, options=None)

Wrapper for the homonymous parser node.

fdwname: str

Foreign-data wrapper name

func_options: tuple

HANDLER/VALIDATOR options

options: tuple

Generic options to FDW

class pglast.ast.CreateForeignServerStmt(servername=None, servertype=None, version=None, fdwname=None, if_not_exists=None, options=None)

Wrapper for the homonymous parser node.

servername: str

Server name

servertype: str

Optional server type

version: str

Optional server version

fdwname: str

FDW name

if_not_exists: bool

Just do nothing if it already exists?

options: tuple

Generic options to server

class pglast.ast.CreateForeignTableStmt(base=None, servername=None, options=None)

Wrapper for the homonymous parser node.

base: CreateStmt
servername: str
options: tuple
class pglast.ast.CreateFunctionStmt(is_procedure=None, replace=None, funcname=None, parameters=None, returnType=None, options=None)

Wrapper for the homonymous parser node.

is_procedure: bool

It’s really CREATE PROCEDURE

replace: bool

T => replace if already exists

funcname: tuple

Qualified name of function to create

parameters: tuple

A list of FunctionParameter

returnType: TypeName*

The return type

options: tuple

A list of DefElem

class pglast.ast.CreateOpClassItem(itemtype=None, name=None, number=None, order_family=None, class_args=None, storedtype=None)

Wrapper for the homonymous parser node.

itemtype: int

See codes above

name: ObjectWithArgs*

Operator or function name and args

number: int

Strategy num or support proc num

order_family: tuple

Only used for ordering operators

class_args: tuple

Amproclefttype/amprocrighttype or amoplefttype/amoprighttype

storedtype: TypeName*

Datatype stored in index

class pglast.ast.CreateOpClassStmt(opclassname=None, opfamilyname=None, amname=None, datatype=None, items=None, isDefault=None)

Wrapper for the homonymous parser node.

opclassname: tuple

Qualified name (list of Value strings)

opfamilyname: tuple

Qualified name (ditto); NIL if omitted

amname: str

Name of index AM opclass is for

datatype: TypeName*

Datatype of indexed column

items: tuple

List of CreateOpClassItem nodes

isDefault: bool

Should be marked as default for type?

class pglast.ast.CreateOpFamilyStmt(opfamilyname=None, amname=None)

Wrapper for the homonymous parser node.

opfamilyname: tuple

Qualified name (list of Value strings)

amname: str

Name of index AM opfamily is for

class pglast.ast.CreatePLangStmt(replace=None, plname=None, plhandler=None, plinline=None, plvalidator=None, pltrusted=None)

Wrapper for the homonymous parser node.

replace: bool

T => replace if already exists

plname: str

PL name

plhandler: tuple

PL call handler function (qual. name)

plinline: tuple

Optional inline function (qual. name)

plvalidator: tuple

Optional validator function (qual. name)

pltrusted: bool

PL is trusted

class pglast.ast.CreatePolicyStmt(policy_name=None, table=None, cmd_name=None, permissive=None, roles=None, qual=None, with_check=None)

Wrapper for the homonymous parser node.

policy_name: str

Policy’s name

table: RangeVar*

The table name the policy applies to

cmd_name: str

The command name the policy applies to

permissive: bool

Restrictive or permissive policy

roles: tuple

The roles associated with the policy

qual: Node

The policy’s condition

with_check: Node

The policy’s WITH CHECK condition.

class pglast.ast.CreatePublicationStmt(pubname=None, options=None, tables=None, for_all_tables=None)

Wrapper for the homonymous parser node.

pubname: str

Name of the publication

options: tuple

List of DefElem nodes

tables: tuple

Optional list of tables to add

for_all_tables: bool

Special publication for all tables in db

class pglast.ast.CreateRangeStmt(typeName=None, params=None)

Wrapper for the homonymous parser node.

typeName: tuple

Qualified name (list of Value strings)

params: tuple

Range parameters (list of DefElem)

class pglast.ast.CreateRoleStmt(stmt_type=None, role=None, options=None)

Wrapper for the homonymous parser node.

stmt_type: RoleStmtType

ROLE/USER/GROUP

role: str

Role name

options: tuple

List of DefElem nodes

class pglast.ast.CreateSchemaStmt(schemaname=None, authrole=None, schemaElts=None, if_not_exists=None)

Wrapper for the homonymous parser node.

schemaname: str

The name of the schema to create

authrole: RoleSpec*

The owner of the created schema

schemaElts: tuple

Schema components (list of parsenodes)

if_not_exists: bool

Just do nothing if schema already exists?

class pglast.ast.CreateSeqStmt(sequence=None, options=None, for_identity=None, if_not_exists=None)

Wrapper for the homonymous parser node.

sequence: RangeVar*

The sequence to create

options: tuple
for_identity: bool
if_not_exists: bool

Just do nothing if it already exists?

class pglast.ast.CreateStatsStmt(defnames=None, stat_types=None, exprs=None, relations=None, stxcomment=None, if_not_exists=None)

Wrapper for the homonymous parser node.

defnames: tuple

Qualified name (list of Value strings)

stat_types: tuple

Stat types (list of Value strings)

exprs: tuple

Expressions to build statistics on

relations: tuple

Rels to build stats on (list of RangeVar)

stxcomment: str

Comment to apply to stats, or NULL

if_not_exists: bool

Do nothing if stats name already exists

class pglast.ast.CreateStmt(relation=None, tableElts=None, inhRelations=None, partbound=None, partspec=None, ofTypename=None, constraints=None, options=None, oncommit=None, tablespacename=None, accessMethod=None, if_not_exists=None)

Wrapper for the homonymous parser node.

relation: RangeVar*

Relation to create

tableElts: tuple

Column definitions (list of ColumnDef)

inhRelations: tuple

Relations to inherit from (list of inhRelation)

partbound: PartitionBoundSpec*

FOR VALUES clause

partspec: PartitionSpec*

PARTITION BY clause

ofTypename: TypeName*

OF typename

constraints: tuple

Constraints (list of Constraint nodes)

options: tuple

Options from WITH clause

oncommit: OnCommitAction

What do we do at COMMIT?

tablespacename: str

Table space to use, or NULL

accessMethod: str

Table access method

if_not_exists: bool

Just do nothing if it already exists?

class pglast.ast.CreateSubscriptionStmt(subname=None, conninfo=None, publication=None, options=None)

Wrapper for the homonymous parser node.

subname: str

Name of the subscription

conninfo: str

Connection string to publisher

publication: tuple

One or more publication to subscribe to

options: tuple

List of DefElem nodes

class pglast.ast.CreateTableAsStmt(query=None, into=None, relkind=None, is_select_into=None, if_not_exists=None)

Wrapper for the homonymous parser node.

query: Node

The query (see comments above)

into: IntoClause*

Destination table

relkind: ObjectType

OBJECT_TABLE or OBJECT_MATVIEW

is_select_into: bool

It was written as SELECT INTO

if_not_exists: bool

Just do nothing if it already exists?

class pglast.ast.CreateTableSpaceStmt(tablespacename=None, owner=None, location=None, options=None)

Wrapper for the homonymous parser node.

tablespacename: str
owner: RoleSpec*
location: str
options: tuple
class pglast.ast.CreateTransformStmt(replace=None, type_name=None, lang=None, fromsql=None, tosql=None)

Wrapper for the homonymous parser node.

replace: bool
type_name: TypeName*
lang: str
fromsql: ObjectWithArgs*
tosql: ObjectWithArgs*
class pglast.ast.CreateTrigStmt(trigname=None, relation=None, funcname=None, args=None, row=None, timing=None, events=None, columns=None, whenClause=None, isconstraint=None, transitionRels=None, deferrable=None, initdeferred=None, constrrel=None)

Wrapper for the homonymous parser node.

trigname: str

TRIGGER’s name

relation: RangeVar*

Relation trigger is on

funcname: tuple

Qual. name of function to call

args: tuple

List of (T_String) Values or NIL

row: bool

ROW/STATEMENT

timing: int16

BEFORE, AFTER, or INSTEAD

events: int16

“OR” of INSERT/UPDATE/DELETE/TRUNCATE

columns: tuple

Column names, or NIL for all columns

whenClause: Node

Qual expression, or NULL if none

isconstraint: bool

This is a constraint trigger

transitionRels: tuple

TriggerTransition nodes, or NIL if none

deferrable: bool

[NOT] DEFERRABLE

initdeferred: bool

INITIALLY {DEFERRED|IMMEDIATE}

constrrel: RangeVar*

Opposite relation, if RI trigger

class pglast.ast.CreateUserMappingStmt(user=None, servername=None, if_not_exists=None, options=None)

Wrapper for the homonymous parser node.

user: RoleSpec*

User role

servername: str

Server name

if_not_exists: bool

Just do nothing if it already exists?

options: tuple

Generic options to server

class pglast.ast.CreatedbStmt(dbname=None, options=None)

Wrapper for the homonymous parser node.

dbname: str

Name of database to create

options: tuple

List of DefElem nodes

class pglast.ast.CurrentOfExpr(cvarno=None, cursor_name=None, cursor_param=None)

Wrapper for the homonymous parser node.

cvarno: Index

RT index of target relation

cursor_name: str

Name of referenced cursor, or NULL

cursor_param: int

Refcursor parameter number, or 0

class pglast.ast.DeallocateStmt(name=None)

Wrapper for the homonymous parser node.

name: str

The name of the plan to remove

class pglast.ast.DeclareCursorStmt(portalname=None, options=None, query=None)

Wrapper for the homonymous parser node.

portalname: str

Name of the portal (cursor)

options: int

Bitmask of options (see above)

query: Node

The query (see comments above)

class pglast.ast.DefElem(defnamespace=None, defname=None, arg=None, defaction=None, location=None)

Wrapper for the homonymous parser node.

defnamespace: str

NULL if unqualified name

defname: str
arg: Node

A (Value *) or a (TypeName *)

defaction: DefElemAction

Unspecified action, or SET/ADD/DROP

location: int

Token location, or -1 if unknown

class pglast.ast.DefineStmt(kind=None, oldstyle=None, defnames=None, args=None, definition=None, if_not_exists=None, replace=None)

Wrapper for the homonymous parser node.

kind: ObjectType

Aggregate, operator, type

oldstyle: bool

Hack to signal old CREATE AGG syntax

defnames: tuple

Qualified name (list of Value strings)

args: tuple

A list of TypeName (if needed)

definition: tuple

A list of DefElem

if_not_exists: bool

Just do nothing if it already exists?

replace: bool

Replace if already exists?

class pglast.ast.DeleteStmt(relation=None, usingClause=None, whereClause=None, returningList=None, withClause=None)

Wrapper for the homonymous parser node.

relation: RangeVar*

Relation to delete from

usingClause: tuple

Optional using clause for more tables

whereClause: Node

Qualifications

returningList: tuple

List of expressions to return

withClause: WithClause*

WITH clause

class pglast.ast.DiscardStmt(target=None)

Wrapper for the homonymous parser node.

target: DiscardMode
class pglast.ast.DoStmt(args=None)

Wrapper for the homonymous parser node.

args: tuple

List of DefElem nodes

class pglast.ast.DropOwnedStmt(roles=None, behavior=None)

Wrapper for the homonymous parser node.

roles: tuple
behavior: DropBehavior
class pglast.ast.DropRoleStmt(roles=None, missing_ok=None)

Wrapper for the homonymous parser node.

roles: tuple

List of roles to remove

missing_ok: bool

Skip error if a role is missing?

class pglast.ast.DropStmt(objects=None, removeType=None, behavior=None, missing_ok=None, concurrent=None)

Wrapper for the homonymous parser node.

objects: tuple

List of names

removeType: ObjectType

Object type

behavior: DropBehavior

RESTRICT or CASCADE behavior

missing_ok: bool

Skip error if object is missing?

concurrent: bool

Drop index concurrently?

class pglast.ast.DropSubscriptionStmt(subname=None, missing_ok=None, behavior=None)

Wrapper for the homonymous parser node.

subname: str

Name of the subscription

missing_ok: bool

Skip error if missing?

behavior: DropBehavior

RESTRICT or CASCADE behavior

class pglast.ast.DropTableSpaceStmt(tablespacename=None, missing_ok=None)

Wrapper for the homonymous parser node.

tablespacename: str
missing_ok: bool

Skip error if missing?

class pglast.ast.DropUserMappingStmt(user=None, servername=None, missing_ok=None)

Wrapper for the homonymous parser node.

user: RoleSpec*

User role

servername: str

Server name

missing_ok: bool

Ignore missing mappings

class pglast.ast.DropdbStmt(dbname=None, missing_ok=None, options=None)

Wrapper for the homonymous parser node.

dbname: str

Database to drop

missing_ok: bool

Skip error if db is missing?

options: tuple

Currently only FORCE is supported

class pglast.ast.ExecuteStmt(name=None, params=None)

Wrapper for the homonymous parser node.

name: str

The name of the plan to execute

params: tuple

Values to assign to parameters

class pglast.ast.ExplainStmt(query=None, options=None)

Wrapper for the homonymous parser node.

query: Node

The query (see comments above)

options: tuple

List of DefElem nodes

class pglast.ast.FetchStmt(direction=None, howMany=None, portalname=None, ismove=None)

Wrapper for the homonymous parser node.

direction: FetchDirection
howMany: long

Number of rows, or position argument

portalname: str

Name of portal (cursor)

ismove: bool

True if MOVE

class pglast.ast.FieldSelect(arg=None, fieldnum=None, resulttypmod=None)

Wrapper for the homonymous parser node.

arg: Expr*

Input expression

fieldnum: AttrNumber

Attribute number of field to extract

resulttypmod: int32

Output typmod (usually -1)

class pglast.ast.FieldStore(arg=None, newvals=None, fieldnums=None)

Wrapper for the homonymous parser node.

arg: Expr*

Input tuple value

newvals: tuple

New value(s) for field(s)

fieldnums: tuple

Integer list of field attnums

class pglast.ast.FromExpr(fromlist=None, quals=None)

Wrapper for the homonymous parser node.

fromlist: tuple

List of join subtrees

quals: Node

Qualifiers on join, if any

class pglast.ast.FuncCall(funcname=None, args=None, agg_order=None, agg_filter=None, agg_within_group=None, agg_star=None, agg_distinct=None, func_variadic=None, over=None, location=None)

Wrapper for the homonymous parser node.

funcname: tuple

Qualified name of function

args: tuple

The arguments (list of exprs)

agg_order: tuple

ORDER BY (list of SortBy)

agg_filter: Node

FILTER clause, if any

agg_within_group: bool

ORDER BY appeared in WITHIN GROUP

agg_star: bool

Argument was really ‘*’

agg_distinct: bool

Arguments were labeled DISTINCT

func_variadic: bool

Last argument was labeled VARIADIC

over: WindowDef*

OVER clause, if any

location: int

Token location, or -1 if unknown

class pglast.ast.FuncExpr(funcretset=None, funcvariadic=None, funcformat=None, args=None, location=None)

Wrapper for the homonymous parser node.

funcretset: bool

True if function returns set

funcvariadic: bool

True if variadic arguments have been combined into an array last argument

funcformat: CoercionForm

How to display this function call

args: tuple

Arguments to the function

location: int

Token location, or -1 if unknown

class pglast.ast.FunctionParameter(name=None, argType=None, mode=None, defexpr=None)

Wrapper for the homonymous parser node.

name: str

Parameter name, or NULL if not given

argType: TypeName*

TypeName for parameter type

mode: FunctionParameterMode

IN/OUT/etc

defexpr: Node

Raw default expr, or NULL if not given

class pglast.ast.GrantRoleStmt(granted_roles=None, grantee_roles=None, is_grant=None, admin_opt=None, grantor=None, behavior=None)

Wrapper for the homonymous parser node.

granted_roles: tuple

List of roles to be granted/revoked

grantee_roles: tuple

List of member roles to add/delete

is_grant: bool

True = GRANT, false = REVOKE

admin_opt: bool

With admin option

grantor: RoleSpec*

Set grantor to other than current role

behavior: DropBehavior

Drop behavior (for REVOKE)

class pglast.ast.GrantStmt(is_grant=None, targtype=None, objtype=None, objects=None, privileges=None, grantees=None, grant_option=None, behavior=None)

Wrapper for the homonymous parser node.

is_grant: bool

True = GRANT, false = REVOKE

targtype: GrantTargetType

Type of the grant target

objtype: ObjectType

Kind of object being operated on

objects: tuple

List of RangeVar nodes, ObjectWithArgs nodes, or plain names (as Value strings)

privileges: tuple

List of AccessPriv nodes

grantees: tuple

List of RoleSpec nodes

grant_option: bool

Grant or revoke grant option

behavior: DropBehavior

Drop behavior (for REVOKE)

class pglast.ast.GroupingFunc(args=None, refs=None, cols=None, agglevelsup=None, location=None)

Wrapper for the homonymous parser node.

args: tuple

Arguments, not evaluated but kept for benefit of EXPLAIN etc.

refs: tuple

Ressortgrouprefs of arguments

cols: tuple

Actual column positions set by planner

agglevelsup: Index

Same as Aggref.agglevelsup

location: int

Token location

class pglast.ast.GroupingSet(kind=None, content=None, location=None)

Wrapper for the homonymous parser node.

kind: GroupingSetKind
content: tuple
location: int
class pglast.ast.ImportForeignSchemaStmt(server_name=None, remote_schema=None, local_schema=None, list_type=None, table_list=None, options=None)

Wrapper for the homonymous parser node.

server_name: str

FDW server name

remote_schema: str

Remote schema name to query

local_schema: str

Local schema to create objects in

list_type: ImportForeignSchemaType

Type of table list

table_list: tuple

List of RangeVar

options: tuple

List of options to pass to FDW

class pglast.ast.IndexElem(name=None, expr=None, indexcolname=None, collation=None, opclass=None, opclassopts=None, ordering=None, nulls_ordering=None)

Wrapper for the homonymous parser node.

name: str

Name of attribute to index, or NULL

expr: Node

Expression to index, or NULL

indexcolname: str

Name for index column; NULL = default

collation: tuple

Name of collation; NIL = default

opclass: tuple

Name of desired opclass; NIL = default

opclassopts: tuple

Opclass-specific options, or NIL

ordering: SortByDir

ASC/DESC/default

nulls_ordering: SortByNulls

FIRST/LAST/default

class pglast.ast.IndexStmt(idxname=None, relation=None, accessMethod=None, tableSpace=None, indexParams=None, indexIncludingParams=None, options=None, whereClause=None, excludeOpNames=None, idxcomment=None, oldCreateSubid=None, oldFirstRelfilenodeSubid=None, unique=None, primary=None, isconstraint=None, deferrable=None, initdeferred=None, transformed=None, concurrent=None, if_not_exists=None, reset_default_tblspc=None)

Wrapper for the homonymous parser node.

idxname: str

Name of new index, or NULL for default

relation: RangeVar*

Relation to build index on

accessMethod: str

Name of access method (eg. btree)

tableSpace: str

Tablespace, or NULL for default

indexParams: tuple

Columns to index: a list of IndexElem

indexIncludingParams: tuple

Additional columns to index: a list of IndexElem

options: tuple

WITH clause options: a list of DefElem

whereClause: Node

Qualification (partial-index predicate)

excludeOpNames: tuple

Exclusion operator names, or NIL if none

idxcomment: str

Comment to apply to index, or NULL

oldCreateSubid: SubTransactionId

Rd_createSubid of oldNode

oldFirstRelfilenodeSubid: SubTransactionId

Rd_firstRelfilenodeSubid of oldNode

unique: bool

Is index unique?

primary: bool

Is index a primary key?

isconstraint: bool

Is it for a pkey/unique constraint?

deferrable: bool

Is the constraint DEFERRABLE?

initdeferred: bool

Is the constraint INITIALLY DEFERRED?

transformed: bool

True when transformIndexStmt is finished

concurrent: bool

Should this be a concurrent index build?

if_not_exists: bool

Just do nothing if index already exists?

reset_default_tblspc: bool

Reset default_tablespace prior to executing

class pglast.ast.InferClause(indexElems=None, whereClause=None, conname=None, location=None)

Wrapper for the homonymous parser node.

indexElems: tuple

IndexElems to infer unique index

whereClause: Node

Qualification (partial-index predicate)

conname: str

Constraint name, or NULL if unnamed

location: int

Token location, or -1 if unknown

class pglast.ast.InferenceElem(expr=None)

Wrapper for the homonymous parser node.

expr: Node

Expression to infer from, or NULL

class pglast.ast.InlineCodeBlock(source_text=None, langIsTrusted=None, atomic=None)

Wrapper for the homonymous parser node.

source_text: str

Source text of anonymous code block

langIsTrusted: bool

Trusted property of the language

atomic: bool

Atomic execution context

class pglast.ast.InsertStmt(relation=None, cols=None, selectStmt=None, onConflictClause=None, returningList=None, withClause=None, override=None)

Wrapper for the homonymous parser node.

relation: RangeVar*

Relation to insert into

cols: tuple

Optional: names of the target columns

selectStmt: Node

The source SELECT/VALUES, or NULL

onConflictClause: OnConflictClause*

ON CONFLICT clause

returningList: tuple

List of expressions to return

withClause: WithClause*

WITH clause

override: OverridingKind

OVERRIDING clause

class pglast.ast.IntoClause(rel=None, colNames=None, accessMethod=None, options=None, onCommit=None, tableSpaceName=None, viewQuery=None, skipData=None)

Wrapper for the homonymous parser node.

rel: RangeVar*

Target relation name

colNames: tuple

Column names to assign, or NIL

accessMethod: str

Table access method

options: tuple

Options from WITH clause

onCommit: OnCommitAction

What do we do at COMMIT?

tableSpaceName: str

Table space to use, or NULL

viewQuery: Node

Materialized view’s SELECT query

skipData: bool

True for WITH NO DATA

class pglast.ast.JoinExpr(jointype=None, isNatural=None, larg=None, rarg=None, usingClause=None, quals=None, alias=None, rtindex=None)

Wrapper for the homonymous parser node.

jointype: JoinType

Type of join

isNatural: bool

Natural join? Will need to shape table

larg: Node

Left subtree

rarg: Node

Right subtree

usingClause: tuple

USING clause, if any (list of String)

quals: Node

Qualifiers on join, if any

alias: Alias*

User-written alias clause, if any

rtindex: int

RT index assigned for join, or 0

class pglast.ast.ListenStmt(conditionname=None)

Wrapper for the homonymous parser node.

conditionname: str

Condition name to listen on

class pglast.ast.LoadStmt(filename=None)

Wrapper for the homonymous parser node.

filename: str

File to load

class pglast.ast.LockStmt(relations=None, mode=None, nowait=None)

Wrapper for the homonymous parser node.

relations: tuple

Relations to lock

mode: int

Lock mode

nowait: bool

No wait mode

class pglast.ast.LockingClause(lockedRels=None, strength=None, waitPolicy=None)

Wrapper for the homonymous parser node.

lockedRels: tuple

FOR [KEY] UPDATE/SHARE relations

strength: LockClauseStrength
waitPolicy: LockWaitPolicy

NOWAIT and SKIP LOCKED

class pglast.ast.MinMaxExpr(op=None, args=None, location=None)

Wrapper for the homonymous parser node.

op: MinMaxOp

Function to execute

args: tuple

The arguments

location: int

Token location, or -1 if unknown

class pglast.ast.MultiAssignRef(source=None, colno=None, ncolumns=None)

Wrapper for the homonymous parser node.

source: Node

The row-valued expression

colno: int

Column number for this target (1..n)

ncolumns: int

Number of targets in the construct

class pglast.ast.NamedArgExpr(arg=None, name=None, argnumber=None, location=None)

Wrapper for the homonymous parser node.

arg: Expr*

The argument expression

name: str

The name

argnumber: int

Argument’s number in positional notation

location: int

Argument name location, or -1 if unknown

class pglast.ast.NotifyStmt(conditionname=None, payload=None)

Wrapper for the homonymous parser node.

conditionname: str

Condition name to notify

payload: str

The payload string, or NULL if none

class pglast.ast.NullTest(arg=None, nulltesttype=None, argisrow=None, location=None)

Wrapper for the homonymous parser node.

arg: Expr*

Input expression

nulltesttype: NullTestType

IS NULL, IS NOT NULL

argisrow: bool

T to perform field-by-field null checks

location: int

Token location, or -1 if unknown

class pglast.ast.ObjectWithArgs(objname=None, objargs=None, args_unspecified=None)

Wrapper for the homonymous parser node.

objname: tuple

Qualified name of function/operator

objargs: tuple

List of Typename nodes

args_unspecified: bool

Argument list was omitted, so name must be unique (note that objargs == NIL means zero args)

class pglast.ast.OnConflictClause(action=None, infer=None, targetList=None, whereClause=None, location=None)

Wrapper for the homonymous parser node.

action: OnConflictAction

DO NOTHING or UPDATE?

infer: InferClause*

Optional index inference clause

targetList: tuple

The target list (of ResTarget)

whereClause: Node

Qualifications

location: int

Token location, or -1 if unknown

class pglast.ast.OnConflictExpr(action=None, arbiterElems=None, arbiterWhere=None, onConflictSet=None, onConflictWhere=None, exclRelIndex=None, exclRelTlist=None)

Wrapper for the homonymous parser node.

action: OnConflictAction

DO NOTHING or UPDATE?

arbiterElems: tuple

Unique index arbiter list (of InferenceElem’s)

arbiterWhere: Node

Unique index arbiter WHERE clause

onConflictSet: tuple

List of ON CONFLICT SET TargetEntrys

onConflictWhere: Node

Qualifiers to restrict UPDATE to

exclRelIndex: int

RT index of ‘excluded’ relation

exclRelTlist: tuple

Tlist of the EXCLUDED pseudo relation

class pglast.ast.OpExpr(opretset=None, args=None, location=None)

Wrapper for the homonymous parser node.

opretset: bool

True if operator returns set

args: tuple

Arguments to the operator (1 or 2)

location: int

Token location, or -1 if unknown

class pglast.ast.Param(paramkind=None, paramid=None, paramtypmod=None, location=None)

Wrapper for the homonymous parser node.

paramkind: ParamKind

Kind of parameter. See above

paramid: int

Numeric ID for parameter

paramtypmod: int32

Typmod value, if known

location: int

Token location, or -1 if unknown

class pglast.ast.ParamRef(number=None, location=None)

Wrapper for the homonymous parser node.

number: int

The number of the parameter

location: int

Token location, or -1 if unknown

class pglast.ast.PartitionBoundSpec(strategy=None, is_default=None, modulus=None, remainder=None, listdatums=None, lowerdatums=None, upperdatums=None, location=None)

Wrapper for the homonymous parser node.

strategy: str

See PARTITION_STRATEGY codes above

is_default: bool

Is it a default partition bound?

modulus: int
remainder: int
listdatums: tuple

List of Consts (or A_Consts in raw tree)

lowerdatums: tuple

List of PartitionRangeDatums

upperdatums: tuple

List of PartitionRangeDatums

location: int

Token location, or -1 if unknown

class pglast.ast.PartitionCmd(name=None, bound=None)

Wrapper for the homonymous parser node.

name: RangeVar*

Name of partition to attach/detach

bound: PartitionBoundSpec*

FOR VALUES, if attaching

class pglast.ast.PartitionElem(name=None, expr=None, collation=None, opclass=None, location=None)

Wrapper for the homonymous parser node.

name: str

Name of column to partition on, or NULL

expr: Node

Expression to partition on, or NULL

collation: tuple

Name of collation; NIL = default

opclass: tuple

Name of desired opclass; NIL = default

location: int

Token location, or -1 if unknown

class pglast.ast.PartitionRangeDatum(kind=None, value=None, location=None)

Wrapper for the homonymous parser node.

kind: PartitionRangeDatumKind
value: Node

Const (or A_Const in raw tree), if kind is PARTITION_RANGE_DATUM_VALUE, else NULL

location: int

Token location, or -1 if unknown

class pglast.ast.PartitionSpec(strategy=None, partParams=None, location=None)

Wrapper for the homonymous parser node.

strategy: str

Partitioning strategy (‘hash’, ‘list’ or ‘range’)

partParams: tuple

List of PartitionElems

location: int

Token location, or -1 if unknown

class pglast.ast.PrepareStmt(name=None, argtypes=None, query=None)

Wrapper for the homonymous parser node.

name: str

Name of plan, arbitrary

argtypes: tuple

Types of parameters (List of TypeName)

query: Node

The query itself (as a raw parsetree)

class pglast.ast.Query(commandType=None, querySource=None, queryId=None, canSetTag=None, utilityStmt=None, resultRelation=None, hasAggs=None, hasWindowFuncs=None, hasTargetSRFs=None, hasSubLinks=None, hasDistinctOn=None, hasRecursive=None, hasModifyingCTE=None, hasForUpdate=None, hasRowSecurity=None, cteList=None, rtable=None, jointree=None, targetList=None, override=None, onConflict=None, returningList=None, groupClause=None, groupingSets=None, havingQual=None, windowClause=None, distinctClause=None, sortClause=None, limitOffset=None, limitCount=None, limitOption=None, rowMarks=None, setOperations=None, constraintDeps=None, withCheckOptions=None, stmt_location=None, stmt_len=None)

Wrapper for the homonymous parser node.

commandType: CmdType

Select|insert|update|delete|utility

querySource: QuerySource

Where did I come from?

queryId: uint64

Query identifier (can be set by plugins)

canSetTag: bool

Do I set the command result tag?

utilityStmt: Node

Non-null if commandType == CMD_UTILITY

resultRelation: int

Rtable index of target relation for INSERT/UPDATE/DELETE; 0 for SELECT

hasAggs: bool

Has aggregates in tlist or havingQual

hasWindowFuncs: bool

Has window functions in tlist

hasTargetSRFs: bool

Has set-returning functions in tlist

Has subquery SubLink

hasDistinctOn: bool

DistinctClause is from DISTINCT ON

hasRecursive: bool

WITH RECURSIVE was specified

hasModifyingCTE: bool

Has INSERT/UPDATE/DELETE in WITH

hasForUpdate: bool

FOR [KEY] UPDATE/SHARE was specified

hasRowSecurity: bool

Rewriter has applied some RLS policy

cteList: tuple

WITH list (of CommonTableExpr’s)

rtable: tuple

List of range table entries

jointree: FromExpr*

Table join tree (FROM and WHERE clauses)

targetList: tuple

Target list (of TargetEntry)

override: OverridingKind

OVERRIDING clause

onConflict: OnConflictExpr*

ON CONFLICT DO [NOTHING | UPDATE]

returningList: tuple

Return-values list (of TargetEntry)

groupClause: tuple

A list of SortGroupClause’s

groupingSets: tuple

A list of GroupingSet’s if present

havingQual: Node

Qualifications applied to groups

windowClause: tuple

A list of WindowClause’s

distinctClause: tuple

A list of SortGroupClause’s

sortClause: tuple

A list of SortGroupClause’s

limitOffset: Node

# of result tuples to skip (int8 expr)

limitCount: Node

# of result tuples to return (int8 expr)

limitOption: LimitOption

Limit type

rowMarks: tuple

A list of RowMarkClause’s

setOperations: Node

Set-operation tree if this is top level of a UNION/INTERSECT/EXCEPT query

constraintDeps: tuple

A list of pg_constraint OIDs that the query depends on to be semantically valid

withCheckOptions: tuple

A list of WithCheckOption’s (added during rewrite)

stmt_location: int

Start location, or -1 if unknown

stmt_len: int

Length in bytes; 0 means “rest of string”

class pglast.ast.RangeFunction(lateral=None, ordinality=None, is_rowsfrom=None, functions=None, alias=None, coldeflist=None)

Wrapper for the homonymous parser node.

lateral: bool

Does it have LATERAL prefix?

ordinality: bool

Does it have WITH ORDINALITY suffix?

is_rowsfrom: bool

Is result of ROWS FROM() syntax?

functions: tuple

Per-function information, see above

alias: Alias*

Table alias & optional column aliases

coldeflist: tuple

List of ColumnDef nodes to describe result of function returning RECORD

class pglast.ast.RangeSubselect(lateral=None, subquery=None, alias=None)

Wrapper for the homonymous parser node.

lateral: bool

Does it have LATERAL prefix?

subquery: Node

The untransformed sub-select clause

alias: Alias*

Table alias & optional column aliases

class pglast.ast.RangeTableFunc(lateral=None, docexpr=None, rowexpr=None, namespaces=None, columns=None, alias=None, location=None)

Wrapper for the homonymous parser node.

lateral: bool

Does it have LATERAL prefix?

docexpr: Node

Document expression

rowexpr: Node

Row generator expression

namespaces: tuple

List of namespaces as ResTarget

columns: tuple

List of RangeTableFuncCol

alias: Alias*

Table alias & optional column aliases

location: int

Token location, or -1 if unknown

class pglast.ast.RangeTableFuncCol(colname=None, typeName=None, for_ordinality=None, is_not_null=None, colexpr=None, coldefexpr=None, location=None)

Wrapper for the homonymous parser node.

colname: str

Name of generated column

typeName: TypeName*

Type of generated column

for_ordinality: bool

Does it have FOR ORDINALITY?

is_not_null: bool

Does it have NOT NULL?

colexpr: Node

Column filter expression

coldefexpr: Node

Column default value expression

location: int

Token location, or -1 if unknown

class pglast.ast.RangeTableSample(relation=None, method=None, args=None, repeatable=None, location=None)

Wrapper for the homonymous parser node.

relation: Node

Relation to be sampled

method: tuple

Sampling method name (possibly qualified)

args: tuple

Argument(s) for sampling method

repeatable: Node

REPEATABLE expression, or NULL if none

location: int

Method name location, or -1 if unknown

class pglast.ast.RangeTblEntry(rtekind=None, relkind=None, rellockmode=None, tablesample=None, subquery=None, security_barrier=None, jointype=None, joinmergedcols=None, joinaliasvars=None, joinleftcols=None, joinrightcols=None, functions=None, funcordinality=None, tablefunc=None, values_lists=None, ctename=None, ctelevelsup=None, self_reference=None, coltypes=None, coltypmods=None, colcollations=None, enrname=None, enrtuples=None, alias=None, eref=None, lateral=None, inh=None, inFromCl=None, requiredPerms=None, selectedCols=None, insertedCols=None, updatedCols=None, extraUpdatedCols=None, securityQuals=None)

Wrapper for the homonymous parser node.

rtekind: RTEKind
relkind: str

Relation kind (see pg_class.relkind)

rellockmode: int

Lock level that query requires on the rel

tablesample: TableSampleClause*

Sampling info, or NULL

subquery: Query*

The sub-query

security_barrier: bool

Is from security_barrier view?

jointype: JoinType

Type of join

joinmergedcols: int

Number of merged (JOIN USING) columns

joinaliasvars: tuple

List of alias-var expansions

joinleftcols: tuple

Left-side input column numbers

joinrightcols: tuple

Right-side input column numbers

functions: tuple

List of RangeTblFunction nodes

funcordinality: bool

Is this called WITH ORDINALITY?

tablefunc: TableFunc*
values_lists: tuple

List of expression lists

ctename: str

Name of the WITH list item

ctelevelsup: Index

Number of query levels up

self_reference: bool

Is this a recursive self-reference?

coltypes: tuple

OID list of column type OIDs

coltypmods: tuple

Integer list of column typmods

colcollations: tuple

OID list of column collation OIDs

enrname: str

Name of ephemeral named relation

enrtuples: double

Estimated or actual from caller

alias: Alias*

User-written alias clause, if any

eref: Alias*

Expanded reference names

lateral: bool

Subquery, function, or values is LATERAL?

inh: bool

Inheritance requested?

inFromCl: bool

Present in FROM clause?

requiredPerms: AclMode

Bitmask of required access permissions

selectedCols: Bitmapset*

Columns needing SELECT permission

insertedCols: Bitmapset*

Columns needing INSERT permission

updatedCols: Bitmapset*

Columns needing UPDATE permission

extraUpdatedCols: Bitmapset*

Generated columns being updated

securityQuals: tuple

Security barrier quals to apply, if any

class pglast.ast.RangeTblFunction(funcexpr=None, funccolcount=None, funccolnames=None, funccoltypes=None, funccoltypmods=None, funccolcollations=None, funcparams=None)

Wrapper for the homonymous parser node.

funcexpr: Node

Expression tree for func call

funccolcount: int

Number of columns it contributes to RTE

funccolnames: tuple

Column names (list of String)

funccoltypes: tuple

OID list of column type OIDs

funccoltypmods: tuple

Integer list of column typmods

funccolcollations: tuple

OID list of column collation OIDs

funcparams: Bitmapset*

PARAM_EXEC Param IDs affecting this func

class pglast.ast.RangeTblRef(rtindex=None)

Wrapper for the homonymous parser node.

rtindex: int
class pglast.ast.RangeVar(catalogname=None, schemaname=None, relname=None, inh=None, relpersistence=None, alias=None, location=None)

Wrapper for the homonymous parser node.

catalogname: str

The catalog (database) name, or NULL

schemaname: str

The schema name, or NULL

relname: str

The relation/sequence name

inh: bool

Expand rel by inheritance? recursively act on children?

relpersistence: str

See RELPERSISTENCE_* in pg_class.h

alias: Alias*

Table alias & optional column aliases

location: int

Token location, or -1 if unknown

class pglast.ast.RawStmt(stmt=None, stmt_location=None, stmt_len=None)

Wrapper for the homonymous parser node.

stmt: Node

Raw parse tree

stmt_location: int

Start location, or -1 if unknown

stmt_len: int

Length in bytes; 0 means “rest of string”

class pglast.ast.ReassignOwnedStmt(roles=None, newrole=None)

Wrapper for the homonymous parser node.

roles: tuple
newrole: RoleSpec*
class pglast.ast.RefreshMatViewStmt(concurrent=None, skipData=None, relation=None)

Wrapper for the homonymous parser node.

concurrent: bool

Allow concurrent access?

skipData: bool

True for WITH NO DATA

relation: RangeVar*

Relation to insert into

class pglast.ast.ReindexStmt(kind=None, relation=None, name=None, options=None, concurrent=None)

Wrapper for the homonymous parser node.

kind: ReindexObjectType

REINDEX_OBJECT_INDEX, REINDEX_OBJECT_TABLE, etc.

relation: RangeVar*

Table or index to reindex

name: str

Name of database to reindex

options: int

Reindex options flags

concurrent: bool

Reindex concurrently?

class pglast.ast.RelabelType(arg=None, resulttypmod=None, relabelformat=None, location=None)

Wrapper for the homonymous parser node.

arg: Expr*

Input expression

resulttypmod: int32

Output typmod (usually -1)

relabelformat: CoercionForm

How to display this node

location: int

Token location, or -1 if unknown

class pglast.ast.RenameStmt(renameType=None, relationType=None, relation=None, object=None, subname=None, newname=None, behavior=None, missing_ok=None)

Wrapper for the homonymous parser node.

renameType: ObjectType

OBJECT_TABLE, OBJECT_COLUMN, etc

relationType: ObjectType

If column name, associated relation type

relation: RangeVar*

In case it’s a table

object: Node

In case it’s some other object

subname: str

Name of contained object (column, rule, trigger, etc)

newname: str

The new name

behavior: DropBehavior

RESTRICT or CASCADE behavior

missing_ok: bool

Skip error if missing?

class pglast.ast.ReplicaIdentityStmt(identity_type=None, name=None)

Wrapper for the homonymous parser node.

identity_type: str
name: str
class pglast.ast.ResTarget(name=None, indirection=None, val=None, location=None)

Wrapper for the homonymous parser node.

name: str

Column name or NULL

indirection: tuple

Subscripts, field names, and ‘*’, or NIL

val: Node

The value expression to compute or assign

location: int

Token location, or -1 if unknown

class pglast.ast.RoleSpec(roletype=None, rolename=None, location=None)

Wrapper for the homonymous parser node.

roletype: RoleSpecType

Type of this rolespec

rolename: str

Filled only for ROLESPEC_CSTRING

location: int

Token location, or -1 if unknown

class pglast.ast.RowCompareExpr(rctype=None, opnos=None, opfamilies=None, inputcollids=None, largs=None, rargs=None)

Wrapper for the homonymous parser node.

rctype: RowCompareType

LT LE GE or GT, never EQ or NE

opnos: tuple

OID list of pairwise comparison ops

opfamilies: tuple

OID list of containing operator families

inputcollids: tuple

OID list of collations for comparisons

largs: tuple

The left-hand input arguments

rargs: tuple

The right-hand input arguments

class pglast.ast.RowExpr(args=None, row_format=None, colnames=None, location=None)

Wrapper for the homonymous parser node.

args: tuple

The fields

row_format: CoercionForm

How to display this node

colnames: tuple

List of String, or NIL

location: int

Token location, or -1 if unknown

class pglast.ast.RowMarkClause(rti=None, strength=None, waitPolicy=None, pushedDown=None)

Wrapper for the homonymous parser node.

rti: Index

Range table index of target relation

strength: LockClauseStrength
waitPolicy: LockWaitPolicy

NOWAIT and SKIP LOCKED

pushedDown: bool

Pushed down from higher query level?

class pglast.ast.RuleStmt(relation=None, rulename=None, whereClause=None, event=None, instead=None, actions=None, replace=None)

Wrapper for the homonymous parser node.

relation: RangeVar*

Relation the rule is for

rulename: str

Name of the rule

whereClause: Node

Qualifications

event: CmdType

SELECT, INSERT, etc

instead: bool

Is a ‘do instead’?

actions: tuple

The action statements

replace: bool

OR REPLACE

class pglast.ast.SQLValueFunction(op=None, typmod=None, location=None)

Wrapper for the homonymous parser node.

op: SQLValueFunctionOp

Which function this is

typmod: int32
location: int

Token location, or -1 if unknown

class pglast.ast.ScalarArrayOpExpr(useOr=None, args=None, location=None)

Wrapper for the homonymous parser node.

useOr: bool

True for ANY, false for ALL

args: tuple

The scalar and array operands

location: int

Token location, or -1 if unknown

class pglast.ast.SecLabelStmt(objtype=None, object=None, provider=None, label=None)

Wrapper for the homonymous parser node.

objtype: ObjectType

Object’s type

object: Node

Qualified name of the object

provider: str

Label provider (or NULL)

label: str

New security label to be assigned

class pglast.ast.SelectStmt(distinctClause=None, intoClause=None, targetList=None, fromClause=None, whereClause=None, groupClause=None, havingClause=None, windowClause=None, valuesLists=None, sortClause=None, limitOffset=None, limitCount=None, limitOption=None, lockingClause=None, withClause=None, op=None, all=None, larg=None, rarg=None)

Wrapper for the homonymous parser node.

distinctClause: tuple

NULL, list of DISTINCT ON exprs, or lcons(NIL,NIL) for all (SELECT DISTINCT)

intoClause: IntoClause*

Target for SELECT INTO

targetList: tuple

The target list (of ResTarget)

fromClause: tuple

The FROM clause

whereClause: Node

WHERE qualification

groupClause: tuple

GROUP BY clauses

havingClause: Node

HAVING conditional-expression

windowClause: tuple

WINDOW window_name AS (…), …

valuesLists: tuple

Untransformed list of expression lists

sortClause: tuple

Sort clause (a list of SortBy’s)

limitOffset: Node

# of result tuples to skip

limitCount: Node

# of result tuples to return

limitOption: LimitOption

Limit type

lockingClause: tuple

FOR UPDATE (list of LockingClause’s)

withClause: WithClause*

WITH clause

op: SetOperation

Type of set op

all: bool

ALL specified?

larg: SelectStmt*

Left child

rarg: SelectStmt*

Right child

class pglast.ast.SetOperationStmt(op=None, all=None, larg=None, rarg=None, colTypes=None, colTypmods=None, colCollations=None, groupClauses=None)

Wrapper for the homonymous parser node.

op: SetOperation

Type of set op

all: bool

ALL specified?

larg: Node

Left child

rarg: Node

Right child

colTypes: tuple

OID list of output column type OIDs

colTypmods: tuple

Integer list of output column typmods

colCollations: tuple

OID list of output column collation OIDs

groupClauses: tuple

A list of SortGroupClause’s

class pglast.ast.SetToDefault(typeMod=None, location=None)

Wrapper for the homonymous parser node.

typeMod: int32

Typemod for substituted value

location: int

Token location, or -1 if unknown

class pglast.ast.SortBy(node=None, sortby_dir=None, sortby_nulls=None, useOp=None, location=None)

Wrapper for the homonymous parser node.

node: Node

Expression to sort on

sortby_dir: SortByDir

ASC/DESC/USING/default

sortby_nulls: SortByNulls

NULLS FIRST/LAST

useOp: tuple

Name of op to use, if SORTBY_USING

location: int

Operator location, or -1 if none/unknown

class pglast.ast.SortGroupClause(tleSortGroupRef=None, nulls_first=None, hashable=None)

Wrapper for the homonymous parser node.

tleSortGroupRef: Index

Reference into targetlist

nulls_first: bool

Do NULLs come before normal values?

hashable: bool

Can eqop be implemented by hashing?

Wrapper for the homonymous parser node.

subLinkType: SubLinkType
subLinkId: int

ID (1..n); 0 if not MULTIEXPR

testexpr: Node

Outer-query test for ALL/ANY/ROWCOMPARE

operName: tuple

Originally specified operator name

subselect: Node

Subselect as Query* or raw parsetree

location: int

Token location, or -1 if unknown

class pglast.ast.SubPlan(subLinkType=None, testexpr=None, paramIds=None, plan_id=None, plan_name=None, firstColTypmod=None, useHashTable=None, unknownEqFalse=None, parallel_safe=None, setParam=None, parParam=None, args=None, startup_cost=None, per_call_cost=None)

Wrapper for the homonymous parser node.

subLinkType: SubLinkType
testexpr: Node

OpExpr or RowCompareExpr expression tree

paramIds: tuple

IDs of Params embedded in the above

plan_id: int

Index (from 1) in PlannedStmt.subplans

plan_name: str

A name assigned during planning

firstColTypmod: int32

Typmod of first column of subplan result

useHashTable: bool

True to store subselect output in a hash table (implies we are doing “IN”)

unknownEqFalse: bool

True if it’s okay to return FALSE when the spec result is UNKNOWN; this allows much simpler handling of null values

parallel_safe: bool

Is the subplan parallel-safe?

setParam: tuple

Initplan subqueries have to set these Params for parent plan

parParam: tuple

Indices of input Params from parent plan

args: tuple

Exprs to pass as parParam values

startup_cost: Cost

One-time setup cost

per_call_cost: Cost

Cost for each subplan evaluation

class pglast.ast.SubscriptingRef(reftypmod=None, refupperindexpr=None, reflowerindexpr=None, refexpr=None, refassgnexpr=None)

Wrapper for the homonymous parser node.

reftypmod: int32

Typmod of the container (and elements too)

refupperindexpr: tuple

Expressions that evaluate to upper container indexes

reflowerindexpr: tuple

Expressions that evaluate to lower container indexes, or NIL for single container element

refexpr: Expr*

The expression that evaluates to a container value

refassgnexpr: Expr*

Expression for the source value, or NULL if fetch

class pglast.ast.TableFunc(ns_uris=None, ns_names=None, docexpr=None, rowexpr=None, colnames=None, coltypes=None, coltypmods=None, colcollations=None, colexprs=None, coldefexprs=None, notnulls=None, ordinalitycol=None, location=None)

Wrapper for the homonymous parser node.

ns_uris: tuple

List of namespace URI expressions

ns_names: tuple

List of namespace names or NULL

docexpr: Node

Input document expression

rowexpr: Node

Row filter expression

colnames: tuple

Column names (list of String)

coltypes: tuple

OID list of column type OIDs

coltypmods: tuple

Integer list of column typmods

colcollations: tuple

OID list of column collation OIDs

colexprs: tuple

List of column filter expressions

coldefexprs: tuple

List of column default expressions

notnulls: Bitmapset*

Nullability flag for each output column

ordinalitycol: int

Counts from 0; -1 if none specified

location: int

Token location, or -1 if unknown

class pglast.ast.TableLikeClause(relation=None, options=None)

Wrapper for the homonymous parser node.

relation: RangeVar*
options: bits32

OR of TableLikeOption flags

class pglast.ast.TableSampleClause(args=None, repeatable=None)

Wrapper for the homonymous parser node.

args: tuple

Tablesample argument expression(s)

repeatable: Expr*

REPEATABLE expression, or NULL if none

class pglast.ast.TargetEntry(expr=None, resno=None, resname=None, ressortgroupref=None, resorigcol=None, resjunk=None)

Wrapper for the homonymous parser node.

expr: Expr*

Expression to evaluate

resno: AttrNumber

Attribute number (see notes above)

resname: str

Name of the column (could be NULL)

ressortgroupref: Index

Nonzero if referenced by a sort/group clause

resorigcol: AttrNumber

Column’s number in source table

resjunk: bool

Set to true to eliminate the attribute from final target list

class pglast.ast.TransactionStmt(kind=None, options=None, savepoint_name=None, gid=None, chain=None)

Wrapper for the homonymous parser node.

kind: TransactionStmtKind
options: tuple

For BEGIN/START commands

savepoint_name: str

For savepoint commands

gid: str

For two-phase-commit related commands

chain: bool

AND CHAIN option

class pglast.ast.TriggerTransition(name=None, isNew=None, isTable=None)

Wrapper for the homonymous parser node.

name: str
isNew: bool
isTable: bool
class pglast.ast.TruncateStmt(relations=None, restart_seqs=None, behavior=None)

Wrapper for the homonymous parser node.

relations: tuple

Relations (RangeVars) to be truncated

restart_seqs: bool

Restart owned sequences?

behavior: DropBehavior

RESTRICT or CASCADE behavior

class pglast.ast.TypeCast(arg=None, typeName=None, location=None)

Wrapper for the homonymous parser node.

arg: Node

The expression being casted

typeName: TypeName*

The target type

location: int

Token location, or -1 if unknown

class pglast.ast.TypeName(names=None, setof=None, pct_type=None, typmods=None, typemod=None, arrayBounds=None, location=None)

Wrapper for the homonymous parser node.

names: tuple

Qualified name (list of Value strings)

setof: bool

Is a set?

pct_type: bool

%TYPE specified?

typmods: tuple

Type modifier expression(s)

typemod: int32

Prespecified type modifier

arrayBounds: tuple

Array bounds

location: int

Token location, or -1 if unknown

class pglast.ast.UnlistenStmt(conditionname=None)

Wrapper for the homonymous parser node.

conditionname: str

Name to unlisten on, or NULL for all

class pglast.ast.UpdateStmt(relation=None, targetList=None, whereClause=None, fromClause=None, returningList=None, withClause=None)

Wrapper for the homonymous parser node.

relation: RangeVar*

Relation to update

targetList: tuple

The target list (of ResTarget)

whereClause: Node

Qualifications

fromClause: tuple

Optional from clause for more tables

returningList: tuple

List of expressions to return

withClause: WithClause*

WITH clause

class pglast.ast.VacuumRelation(relation=None, va_cols=None)

Wrapper for the homonymous parser node.

relation: RangeVar*

Table name to process, or NULL

va_cols: tuple

List of column names, or NIL for all

class pglast.ast.VacuumStmt(options=None, rels=None, is_vacuumcmd=None)

Wrapper for the homonymous parser node.

options: tuple

List of DefElem nodes

rels: tuple

List of VacuumRelation, or NIL for all

is_vacuumcmd: bool

True for VACUUM, false for ANALYZE

class pglast.ast.Var(varno=None, varattno=None, vartypmod=None, varlevelsup=None, varnosyn=None, varattnosyn=None, location=None)

Wrapper for the homonymous parser node.

varno: Index

Index of this var’s relation in the range table, or INNER_VAR/OUTER_VAR/INDEX_VAR

varattno: AttrNumber

Attribute number of this var, or zero for all attrs (“whole-row Var”)

vartypmod: int32

Pg_attribute typmod value

varlevelsup: Index

For subquery variables referencing outer relations; 0 in a normal var, >0 means N levels up

varnosyn: Index

Syntactic relation index (0 if unknown)

varattnosyn: AttrNumber

Syntactic attribute number

location: int

Token location, or -1 if unknown

class pglast.ast.VariableSetStmt(kind=None, name=None, args=None, is_local=None)

Wrapper for the homonymous parser node.

kind: VariableSetKind
name: str

Variable to be set

args: tuple

List of A_Const nodes

is_local: bool

SET LOCAL?

class pglast.ast.VariableShowStmt(name=None)

Wrapper for the homonymous parser node.

name: str
class pglast.ast.ViewStmt(view=None, aliases=None, query=None, replace=None, options=None, withCheckOption=None)

Wrapper for the homonymous parser node.

view: RangeVar*

The view to be created

aliases: tuple

Target column names

query: Node

The SELECT query (as a raw parse tree)

replace: bool

Replace an existing view?

options: tuple

Options from WITH clause

withCheckOption: ViewCheckOption

WITH CHECK OPTION

class pglast.ast.WindowClause(name=None, refname=None, partitionClause=None, orderClause=None, frameOptions=None, startOffset=None, endOffset=None, inRangeAsc=None, inRangeNullsFirst=None, winref=None, copiedOrder=None)

Wrapper for the homonymous parser node.

name: str

Window name (NULL in an OVER clause)

refname: str

Referenced window name, if any

partitionClause: tuple

PARTITION BY list

orderClause: tuple

ORDER BY list

frameOptions: int

Frame_clause options, see WindowDef

startOffset: Node

Expression for starting bound, if any

endOffset: Node

Expression for ending bound, if any

inRangeAsc: bool

Use ASC sort order for in_range tests?

inRangeNullsFirst: bool

Nulls sort first for in_range tests?

winref: Index

ID referenced by window functions

copiedOrder: bool

Did we copy orderClause from refname?

class pglast.ast.WindowDef(name=None, refname=None, partitionClause=None, orderClause=None, frameOptions=None, startOffset=None, endOffset=None, location=None)

Wrapper for the homonymous parser node.

name: str

Window’s own name

refname: str

Referenced window name, if any

partitionClause: tuple

PARTITION BY expression list

orderClause: tuple

ORDER BY (list of SortBy)

frameOptions: int

Frame_clause options, see below

startOffset: Node

Expression for starting bound, if any

endOffset: Node

Expression for ending bound, if any

location: int

Parse location, or -1 if none/unknown

class pglast.ast.WindowFunc(args=None, aggfilter=None, winref=None, winstar=None, winagg=None, location=None)

Wrapper for the homonymous parser node.

args: tuple

Arguments to the window function

aggfilter: Expr*

FILTER expression, if any

winref: Index

Index of associated WindowClause

winstar: bool

True if argument list was really ‘*’

winagg: bool

Is function a simple aggregate?

location: int

Token location, or -1 if unknown

class pglast.ast.WithCheckOption(kind=None, relname=None, polname=None, qual=None, cascaded=None)

Wrapper for the homonymous parser node.

kind: WCOKind

Kind of WCO

relname: str

Name of relation that specified the WCO

polname: str

Name of RLS policy being checked

qual: Node

Constraint qual to check

cascaded: bool

True for a cascaded WCO on a view

class pglast.ast.WithClause(ctes=None, recursive=None, location=None)

Wrapper for the homonymous parser node.

ctes: tuple

List of CommonTableExprs

recursive: bool

True = WITH RECURSIVE

location: int

Token location, or -1 if unknown

class pglast.ast.XmlExpr(op=None, name=None, named_args=None, arg_names=None, args=None, xmloption=None, typmod=None, location=None)

Wrapper for the homonymous parser node.

op: XmlExprOp

Xml function ID

name: str

Name in xml(NAME foo …) syntaxes

named_args: tuple

Non-XML expressions for xml_attributes

arg_names: tuple

Parallel list of Value strings

args: tuple

List of expressions

xmloption: XmlOptionType

DOCUMENT or CONTENT

typmod: int32
location: int

Token location, or -1 if unknown

class pglast.ast.XmlSerialize(xmloption=None, expr=None, typeName=None, location=None)

Wrapper for the homonymous parser node.

xmloption: XmlOptionType

DOCUMENT or CONTENT

expr: Node
typeName: TypeName*
location: int

Token location, or -1 if unknown