pg

package
v1.5.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Aug 5, 2020 License: MIT Imports: 1 Imported by: 0

Documentation ¶

Index ¶

Constants ¶

This section is empty.

Variables ¶

This section is empty.

Functions ¶

This section is empty.

Types ¶

type A_ArrayExpr ¶ 

type A_ArrayExpr struct {
	Elements *ast.List
	Location int
}

func (*A_ArrayExpr) Pos ¶ 

func (n *A_ArrayExpr) Pos() int

type A_Const ¶ 

type A_Const struct {
	Val      ast.Node
	Location int
}

func (*A_Const) Pos ¶ 

func (n *A_Const) Pos() int

type A_Expr ¶ 

type A_Expr struct {
	Kind     A_Expr_Kind
	Name     *ast.List
	Lexpr    ast.Node
	Rexpr    ast.Node
	Location int
}

func (*A_Expr) Pos ¶ 

func (n *A_Expr) Pos() int

type A_Expr_Kind ¶ 

type A_Expr_Kind uint

func (*A_Expr_Kind) Pos ¶ 

func (n *A_Expr_Kind) Pos() int

type A_Indices ¶ 

type A_Indices struct {
	IsSlice bool
	Lidx    ast.Node
	Uidx    ast.Node
}

func (*A_Indices) Pos ¶ 

func (n *A_Indices) Pos() int

type A_Indirection ¶ 

type A_Indirection struct {
	Arg         ast.Node
	Indirection *ast.List
}

func (*A_Indirection) Pos ¶ 

func (n *A_Indirection) Pos() int

type A_Star ¶ 

type A_Star struct {
}

func (*A_Star) Pos ¶ 

func (n *A_Star) Pos() int

type AccessPriv ¶ 

type AccessPriv struct {
	PrivName *string
	Cols     *ast.List
}

func (*AccessPriv) Pos ¶ 

func (n *AccessPriv) Pos() int

type AclMode ¶ 

type AclMode uint32

func (*AclMode) Pos ¶ 

func (n *AclMode) Pos() int

type AggSplit ¶ 

type AggSplit uint

func (*AggSplit) Pos ¶ 

func (n *AggSplit) Pos() int

type AggStrategy ¶ 

type AggStrategy uint

func (*AggStrategy) Pos ¶ 

func (n *AggStrategy) Pos() int

type Aggref ¶ 

type Aggref struct {
	Xpr           ast.Node
	Aggfnoid      Oid
	Aggtype       Oid
	Aggcollid     Oid
	Inputcollid   Oid
	Aggtranstype  Oid
	Aggargtypes   *ast.List
	Aggdirectargs *ast.List
	Args          *ast.List
	Aggorder      *ast.List
	Aggdistinct   *ast.List
	Aggfilter     ast.Node
	Aggstar       bool
	Aggvariadic   bool
	Aggkind       byte
	Agglevelsup   Index
	Aggsplit      AggSplit
	Location      int
}

func (*Aggref) Pos ¶ 

func (n *Aggref) Pos() int

type Alias ¶ 

type Alias struct {
	Aliasname *string
	Colnames  *ast.List
}

func (*Alias) Pos ¶ 

func (n *Alias) Pos() int

type AlterCollationStmt ¶ 

type AlterCollationStmt struct {
	Collname *ast.List
}

func (*AlterCollationStmt) Pos ¶ 

func (n *AlterCollationStmt) Pos() int

type AlterDatabaseSetStmt ¶ 

type AlterDatabaseSetStmt struct {
	Dbname  *string
	Setstmt *VariableSetStmt
}

func (*AlterDatabaseSetStmt) Pos ¶ 

func (n *AlterDatabaseSetStmt) Pos() int

type AlterDatabaseStmt ¶ 

type AlterDatabaseStmt struct {
	Dbname  *string
	Options *ast.List
}

func (*AlterDatabaseStmt) Pos ¶ 

func (n *AlterDatabaseStmt) Pos() int

type AlterDefaultPrivilegesStmt ¶ 

type AlterDefaultPrivilegesStmt struct {
	Options *ast.List
	Action  *GrantStmt
}

func (*AlterDefaultPrivilegesStmt) Pos ¶ 

func (n *AlterDefaultPrivilegesStmt) Pos() int

type AlterDomainStmt ¶ 

type AlterDomainStmt struct {
	Subtype   byte
	TypeName  *ast.List
	Name      *string
	Def       ast.Node
	Behavior  DropBehavior
	MissingOk bool
}

func (*AlterDomainStmt) Pos ¶ 

func (n *AlterDomainStmt) Pos() int

type AlterEnumStmt ¶ 

type AlterEnumStmt struct {
	TypeName           *ast.List
	OldVal             *string
	NewVal             *string
	NewValNeighbor     *string
	NewValIsAfter      bool
	SkipIfNewValExists bool
}

func (*AlterEnumStmt) Pos ¶ 

func (n *AlterEnumStmt) Pos() int

type AlterEventTrigStmt ¶ 

type AlterEventTrigStmt struct {
	Trigname  *string
	Tgenabled byte
}

func (*AlterEventTrigStmt) Pos ¶ 

func (n *AlterEventTrigStmt) Pos() int

type AlterExtensionContentsStmt ¶ 

type AlterExtensionContentsStmt struct {
	Extname *string
	Action  int
	Objtype ObjectType
	Object  ast.Node
}

func (*AlterExtensionContentsStmt) Pos ¶ 

func (n *AlterExtensionContentsStmt) Pos() int

type AlterExtensionStmt ¶ 

type AlterExtensionStmt struct {
	Extname *string
	Options *ast.List
}

func (*AlterExtensionStmt) Pos ¶ 

func (n *AlterExtensionStmt) Pos() int

type AlterFdwStmt ¶ 

type AlterFdwStmt struct {
	Fdwname     *string
	FuncOptions *ast.List
	Options     *ast.List
}

func (*AlterFdwStmt) Pos ¶ 

func (n *AlterFdwStmt) Pos() int

type AlterForeignServerStmt ¶ 

type AlterForeignServerStmt struct {
	Servername *string
	Version    *string
	Options    *ast.List
	HasVersion bool
}

func (*AlterForeignServerStmt) Pos ¶ 

func (n *AlterForeignServerStmt) Pos() int

type AlterFunctionStmt ¶ 

type AlterFunctionStmt struct {
	Func    *ObjectWithArgs
	Actions *ast.List
}

func (*AlterFunctionStmt) Pos ¶ 

func (n *AlterFunctionStmt) Pos() int

type AlterObjectDependsStmt ¶ 

type AlterObjectDependsStmt struct {
	ObjectType ObjectType
	Relation   *RangeVar
	Object     ast.Node
	Extname    ast.Node
}

func (*AlterObjectDependsStmt) Pos ¶ 

func (n *AlterObjectDependsStmt) Pos() int

type AlterObjectSchemaStmt ¶ 

type AlterObjectSchemaStmt struct {
	ObjectType ObjectType
	Relation   *RangeVar
	Object     ast.Node
	Newschema  *string
	MissingOk  bool
}

func (*AlterObjectSchemaStmt) Pos ¶ 

func (n *AlterObjectSchemaStmt) Pos() int

type AlterOpFamilyStmt ¶ 

type AlterOpFamilyStmt struct {
	Opfamilyname *ast.List
	Amname       *string
	IsDrop       bool
	Items        *ast.List
}

func (*AlterOpFamilyStmt) Pos ¶ 

func (n *AlterOpFamilyStmt) Pos() int

type AlterOperatorStmt ¶ 

type AlterOperatorStmt struct {
	Opername *ObjectWithArgs
	Options  *ast.List
}

func (*AlterOperatorStmt) Pos ¶ 

func (n *AlterOperatorStmt) Pos() int

type AlterOwnerStmt ¶ 

type AlterOwnerStmt struct {
	ObjectType ObjectType
	Relation   *RangeVar
	Object     ast.Node
	Newowner   *RoleSpec
}

func (*AlterOwnerStmt) Pos ¶ 

func (n *AlterOwnerStmt) Pos() int

type AlterPolicyStmt ¶ 

type AlterPolicyStmt struct {
	PolicyName *string
	Table      *RangeVar
	Roles      *ast.List
	Qual       ast.Node
	WithCheck  ast.Node
}

func (*AlterPolicyStmt) Pos ¶ 

func (n *AlterPolicyStmt) Pos() int

type AlterPublicationStmt ¶ 

type AlterPublicationStmt struct {
	Pubname      *string
	Options      *ast.List
	Tables       *ast.List
	ForAllTables bool
	TableAction  DefElemAction
}

func (*AlterPublicationStmt) Pos ¶ 

func (n *AlterPublicationStmt) Pos() int

type AlterRoleSetStmt ¶ 

type AlterRoleSetStmt struct {
	Role     *RoleSpec
	Database *string
	Setstmt  *VariableSetStmt
}

func (*AlterRoleSetStmt) Pos ¶ 

func (n *AlterRoleSetStmt) Pos() int

type AlterRoleStmt ¶ 

type AlterRoleStmt struct {
	Role    *RoleSpec
	Options *ast.List
	Action  int
}

func (*AlterRoleStmt) Pos ¶ 

func (n *AlterRoleStmt) Pos() int

type AlterSeqStmt ¶ 

type AlterSeqStmt struct {
	Sequence    *RangeVar
	Options     *ast.List
	ForIdentity bool
	MissingOk   bool
}

func (*AlterSeqStmt) Pos ¶ 

func (n *AlterSeqStmt) Pos() int

type AlterSubscriptionStmt ¶ 

type AlterSubscriptionStmt struct {
	Kind        AlterSubscriptionType
	Subname     *string
	Conninfo    *string
	Publication *ast.List
	Options     *ast.List
}

func (*AlterSubscriptionStmt) Pos ¶ 

func (n *AlterSubscriptionStmt) Pos() int

type AlterSubscriptionType ¶ 

type AlterSubscriptionType uint

func (*AlterSubscriptionType) Pos ¶ 

func (n *AlterSubscriptionType) Pos() int

type AlterSystemStmt ¶ 

type AlterSystemStmt struct {
	Setstmt *VariableSetStmt
}

func (*AlterSystemStmt) Pos ¶ 

func (n *AlterSystemStmt) Pos() int

type AlterTSConfigType ¶ 

type AlterTSConfigType uint

func (*AlterTSConfigType) Pos ¶ 

func (n *AlterTSConfigType) Pos() int

type AlterTSConfigurationStmt ¶ 

type AlterTSConfigurationStmt struct {
	Kind      AlterTSConfigType
	Cfgname   *ast.List
	Tokentype *ast.List
	Dicts     *ast.List
	Override  bool
	Replace   bool
	MissingOk bool
}

func (*AlterTSConfigurationStmt) Pos ¶ 

func (n *AlterTSConfigurationStmt) Pos() int

type AlterTSDictionaryStmt ¶ 

type AlterTSDictionaryStmt struct {
	Dictname *ast.List
	Options  *ast.List
}

func (*AlterTSDictionaryStmt) Pos ¶ 

func (n *AlterTSDictionaryStmt) Pos() int

type AlterTableCmd ¶ 

type AlterTableCmd struct {
	Subtype   AlterTableType
	Name      *string
	Newowner  *RoleSpec
	Def       ast.Node
	Behavior  DropBehavior
	MissingOk bool
}

func (*AlterTableCmd) Pos ¶ 

func (n *AlterTableCmd) Pos() int

type AlterTableMoveAllStmt ¶ 

type AlterTableMoveAllStmt struct {
	OrigTablespacename *string
	Objtype            ObjectType
	Roles              *ast.List
	NewTablespacename  *string
	Nowait             bool
}

func (*AlterTableMoveAllStmt) Pos ¶ 

func (n *AlterTableMoveAllStmt) Pos() int

type AlterTableSpaceOptionsStmt ¶ 

type AlterTableSpaceOptionsStmt struct {
	Tablespacename *string
	Options        *ast.List
	IsReset        bool
}

func (*AlterTableSpaceOptionsStmt) Pos ¶ 

func (n *AlterTableSpaceOptionsStmt) Pos() int

type AlterTableStmt ¶ 

type AlterTableStmt struct {
	Relation  *RangeVar
	Cmds      *ast.List
	Relkind   ObjectType
	MissingOk bool
}

func (*AlterTableStmt) Pos ¶ 

func (n *AlterTableStmt) Pos() int

type AlterTableType ¶ 

type AlterTableType uint

func (*AlterTableType) Pos ¶ 

func (n *AlterTableType) Pos() int

type AlterUserMappingStmt ¶ 

type AlterUserMappingStmt struct {
	User       *RoleSpec
	Servername *string
	Options    *ast.List
}

func (*AlterUserMappingStmt) Pos ¶ 

func (n *AlterUserMappingStmt) Pos() int

type AlternativeSubPlan ¶ 

type AlternativeSubPlan struct {
	Xpr      ast.Node
	Subplans *ast.List
}

func (*AlternativeSubPlan) Pos ¶ 

func (n *AlternativeSubPlan) Pos() int

type ArrayCoerceExpr ¶ 

type ArrayCoerceExpr struct {
	Xpr          ast.Node
	Arg          ast.Node
	Elemfuncid   Oid
	Resulttype   Oid
	Resulttypmod int32
	Resultcollid Oid
	IsExplicit   bool
	Coerceformat CoercionForm
	Location     int
}

func (*ArrayCoerceExpr) Pos ¶ 

func (n *ArrayCoerceExpr) Pos() int

type ArrayExpr ¶ 

type ArrayExpr struct {
	Xpr           ast.Node
	ArrayTypeid   Oid
	ArrayCollid   Oid
	ElementTypeid Oid
	Elements      *ast.List
	Multidims     bool
	Location      int
}

func (*ArrayExpr) Pos ¶ 

func (n *ArrayExpr) Pos() int

type ArrayRef ¶ 

type ArrayRef struct {
	Xpr             ast.Node
	Refarraytype    Oid
	Refelemtype     Oid
	Reftypmod       int32
	Refcollid       Oid
	Refupperindexpr *ast.List
	Reflowerindexpr *ast.List
	Refexpr         ast.Node
	Refassgnexpr    ast.Node
}

func (*ArrayRef) Pos ¶ 

func (n *ArrayRef) Pos() int

type AttrNumber ¶ 

type AttrNumber int16

func (*AttrNumber) Pos ¶ 

func (n *AttrNumber) Pos() int

type BitString ¶ 

type BitString struct {
	Str string
}

func (*BitString) Pos ¶ 

func (n *BitString) Pos() int

type BlockId ¶ 

type BlockId BlockIdData

func (*BlockId) Pos ¶ 

func (n *BlockId) Pos() int

type BlockIdData ¶ 

type BlockIdData struct {
	BiHi uint16
	BiLo uint16
}

func (*BlockIdData) Pos ¶ 

func (n *BlockIdData) Pos() int

type BlockNumber ¶ 

type BlockNumber uint32

func (*BlockNumber) Pos ¶ 

func (n *BlockNumber) Pos() int

type BoolExpr ¶ 

type BoolExpr struct {
	Xpr      ast.Node
	Boolop   BoolExprType
	Args     *ast.List
	Location int
}

func (*BoolExpr) Pos ¶ 

func (n *BoolExpr) Pos() int

type BoolExprType ¶ 

type BoolExprType uint

func (*BoolExprType) Pos ¶ 

func (n *BoolExprType) Pos() int

type BoolTestType ¶ 

type BoolTestType uint

func (*BoolTestType) Pos ¶ 

func (n *BoolTestType) Pos() int

type BooleanTest ¶ 

type BooleanTest struct {
	Xpr          ast.Node
	Arg          ast.Node
	Booltesttype BoolTestType
	Location     int
}

func (*BooleanTest) Pos ¶ 

func (n *BooleanTest) Pos() int

type CaseExpr ¶ 

type CaseExpr struct {
	Xpr        ast.Node
	Casetype   Oid
	Casecollid Oid
	Arg        ast.Node
	Args       *ast.List
	Defresult  ast.Node
	Location   int
}

func (*CaseExpr) Pos ¶ 

func (n *CaseExpr) Pos() int

type CaseTestExpr ¶ 

type CaseTestExpr struct {
	Xpr       ast.Node
	TypeId    Oid
	TypeMod   int32
	Collation Oid
}

func (*CaseTestExpr) Pos ¶ 

func (n *CaseTestExpr) Pos() int

type CaseWhen ¶ 

type CaseWhen struct {
	Xpr      ast.Node
	Expr     ast.Node
	Result   ast.Node
	Location int
}

func (*CaseWhen) Pos ¶ 

func (n *CaseWhen) Pos() int

type CheckPointStmt ¶ 

type CheckPointStmt struct {
}

func (*CheckPointStmt) Pos ¶ 

func (n *CheckPointStmt) Pos() int

type ClosePortalStmt ¶ 

type ClosePortalStmt struct {
	Portalname *string
}

func (*ClosePortalStmt) Pos ¶ 

func (n *ClosePortalStmt) Pos() int

type ClusterStmt ¶ 

type ClusterStmt struct {
	Relation  *RangeVar
	Indexname *string
	Verbose   bool
}

func (*ClusterStmt) Pos ¶ 

func (n *ClusterStmt) Pos() int

type CmdType ¶ 

type CmdType uint

func (*CmdType) Pos ¶ 

func (n *CmdType) Pos() int

type CoalesceExpr ¶ 

type CoalesceExpr struct {
	Xpr            ast.Node
	Coalescetype   Oid
	Coalescecollid Oid
	Args           *ast.List
	Location       int
}

func (*CoalesceExpr) Pos ¶ 

func (n *CoalesceExpr) Pos() int

type CoerceToDomain ¶ 

type CoerceToDomain struct {
	Xpr            ast.Node
	Arg            ast.Node
	Resulttype     Oid
	Resulttypmod   int32
	Resultcollid   Oid
	Coercionformat CoercionForm
	Location       int
}

func (*CoerceToDomain) Pos ¶ 

func (n *CoerceToDomain) Pos() int

type CoerceToDomainValue ¶ 

type CoerceToDomainValue struct {
	Xpr       ast.Node
	TypeId    Oid
	TypeMod   int32
	Collation Oid
	Location  int
}

func (*CoerceToDomainValue) Pos ¶ 

func (n *CoerceToDomainValue) Pos() int

type CoerceViaIO ¶ 

type CoerceViaIO struct {
	Xpr          ast.Node
	Arg          ast.Node
	Resulttype   Oid
	Resultcollid Oid
	Coerceformat CoercionForm
	Location     int
}

func (*CoerceViaIO) Pos ¶ 

func (n *CoerceViaIO) Pos() int

type CoercionContext ¶ 

type CoercionContext uint

func (*CoercionContext) Pos ¶ 

func (n *CoercionContext) Pos() int

type CoercionForm ¶ 

type CoercionForm uint

func (*CoercionForm) Pos ¶ 

func (n *CoercionForm) Pos() int

type CollateClause ¶ 

type CollateClause struct {
	Arg      ast.Node
	Collname *ast.List
	Location int
}

func (*CollateClause) Pos ¶ 

func (n *CollateClause) Pos() int

type CollateExpr ¶ 

type CollateExpr struct {
	Xpr      ast.Node
	Arg      ast.Node
	CollOid  Oid
	Location int
}

func (*CollateExpr) Pos ¶ 

func (n *CollateExpr) Pos() int

type ColumnDef ¶ 

type ColumnDef struct {
	Colname       *string
	TypeName      *TypeName
	Inhcount      int
	IsLocal       bool
	IsNotNull     bool
	IsFromType    bool
	IsFromParent  bool
	Storage       byte
	RawDefault    ast.Node
	CookedDefault ast.Node
	Identity      byte
	CollClause    *CollateClause
	CollOid       Oid
	Constraints   *ast.List
	Fdwoptions    *ast.List
	Location      int
}

func (*ColumnDef) Pos ¶ 

func (n *ColumnDef) Pos() int

type ColumnRef ¶ 

type ColumnRef struct {
	Fields   *ast.List
	Location int
}

func (*ColumnRef) Pos ¶ 

func (n *ColumnRef) Pos() int

type CommandId ¶ 

type CommandId uint32

func (*CommandId) Pos ¶ 

func (n *CommandId) Pos() int

type CommentStmt ¶ 

type CommentStmt struct {
	Objtype ObjectType
	Object  ast.Node
	Comment *string
}

func (*CommentStmt) Pos ¶ 

func (n *CommentStmt) Pos() int

type CommonTableExpr ¶ 

type CommonTableExpr struct {
	Ctename          *string
	Aliascolnames    *ast.List
	Ctequery         ast.Node
	Location         int
	Cterecursive     bool
	Cterefcount      int
	Ctecolnames      *ast.List
	Ctecoltypes      *ast.List
	Ctecoltypmods    *ast.List
	Ctecolcollations *ast.List
}

func (*CommonTableExpr) Pos ¶ 

func (n *CommonTableExpr) Pos() int

type CompositeTypeStmt ¶ 

type CompositeTypeStmt struct {
	Typevar    *RangeVar
	Coldeflist *ast.List
}

func (*CompositeTypeStmt) Pos ¶ 

func (n *CompositeTypeStmt) Pos() int

type Const ¶ 

type Const struct {
	Xpr         ast.Node
	Consttype   Oid
	Consttypmod int32
	Constcollid Oid
	Constlen    int
	Constvalue  Datum
	Constisnull bool
	Constbyval  bool
	Location    int
}

func (*Const) Pos ¶ 

func (n *Const) Pos() int

type ConstrType ¶ 

type ConstrType uint

func (*ConstrType) Pos ¶ 

func (n *ConstrType) Pos() int

type Constraint ¶ 

type Constraint struct {
	Contype        ConstrType
	Conname        *string
	Deferrable     bool
	Initdeferred   bool
	Location       int
	IsNoInherit    bool
	RawExpr        ast.Node
	CookedExpr     *string
	GeneratedWhen  byte
	Keys           *ast.List
	Exclusions     *ast.List
	Options        *ast.List
	Indexname      *string
	Indexspace     *string
	AccessMethod   *string
	WhereClause    ast.Node
	Pktable        *RangeVar
	FkAttrs        *ast.List
	PkAttrs        *ast.List
	FkMatchtype    byte
	FkUpdAction    byte
	FkDelAction    byte
	OldConpfeqop   *ast.List
	OldPktableOid  Oid
	SkipValidation bool
	InitiallyValid bool
}

func (*Constraint) Pos ¶ 

func (n *Constraint) Pos() int

type ConstraintsSetStmt ¶ 

type ConstraintsSetStmt struct {
	Constraints *ast.List
	Deferred    bool
}

func (*ConstraintsSetStmt) Pos ¶ 

func (n *ConstraintsSetStmt) Pos() int

type ConvertRowtypeExpr ¶ 

type ConvertRowtypeExpr struct {
	Xpr           ast.Node
	Arg           ast.Node
	Resulttype    Oid
	Convertformat CoercionForm
	Location      int
}

func (*ConvertRowtypeExpr) Pos ¶ 

func (n *ConvertRowtypeExpr) Pos() int

type CopyStmt ¶ 

type CopyStmt struct {
	Relation  *RangeVar
	Query     ast.Node
	Attlist   *ast.List
	IsFrom    bool
	IsProgram bool
	Filename  *string
	Options   *ast.List
}

func (*CopyStmt) Pos ¶ 

func (n *CopyStmt) Pos() int

type Cost ¶ 

type Cost float64

func (*Cost) Pos ¶ 

func (n *Cost) Pos() int

type CreateAmStmt ¶ 

type CreateAmStmt struct {
	Amname      *string
	HandlerName *ast.List
	Amtype      byte
}

func (*CreateAmStmt) Pos ¶ 

func (n *CreateAmStmt) Pos() int

type CreateCastStmt ¶ 

type CreateCastStmt struct {
	Sourcetype *TypeName
	Targettype *TypeName
	Func       *ObjectWithArgs
	Context    CoercionContext
	Inout      bool
}

func (*CreateCastStmt) Pos ¶ 

func (n *CreateCastStmt) Pos() int

type CreateConversionStmt ¶ 

type CreateConversionStmt struct {
	ConversionName  *ast.List
	ForEncodingName *string
	ToEncodingName  *string
	FuncName        *ast.List
	Def             bool
}

func (*CreateConversionStmt) Pos ¶ 

func (n *CreateConversionStmt) Pos() int

type CreateDomainStmt ¶ 

type CreateDomainStmt struct {
	Domainname  *ast.List
	TypeName    *TypeName
	CollClause  *CollateClause
	Constraints *ast.List
}

func (*CreateDomainStmt) Pos ¶ 

func (n *CreateDomainStmt) Pos() int

type CreateEnumStmt ¶ 

type CreateEnumStmt struct {
	TypeName *ast.List
	Vals     *ast.List
}

func (*CreateEnumStmt) Pos ¶ 

func (n *CreateEnumStmt) Pos() int

type CreateEventTrigStmt ¶ 

type CreateEventTrigStmt struct {
	Trigname   *string
	Eventname  *string
	Whenclause *ast.List
	Funcname   *ast.List
}

func (*CreateEventTrigStmt) Pos ¶ 

func (n *CreateEventTrigStmt) Pos() int

type CreateExtensionStmt ¶ 

type CreateExtensionStmt struct {
	Extname     *string
	IfNotExists bool
	Options     *ast.List
}

func (*CreateExtensionStmt) Pos ¶ 

func (n *CreateExtensionStmt) Pos() int

type CreateFdwStmt ¶ 

type CreateFdwStmt struct {
	Fdwname     *string
	FuncOptions *ast.List
	Options     *ast.List
}

func (*CreateFdwStmt) Pos ¶ 

func (n *CreateFdwStmt) Pos() int

type CreateForeignServerStmt ¶ 

type CreateForeignServerStmt struct {
	Servername  *string
	Servertype  *string
	Version     *string
	Fdwname     *string
	IfNotExists bool
	Options     *ast.List
}

func (*CreateForeignServerStmt) Pos ¶ 

func (n *CreateForeignServerStmt) Pos() int

type CreateForeignTableStmt ¶ 

type CreateForeignTableStmt struct {
	Base       *CreateStmt
	Servername *string
	Options    *ast.List
}

func (*CreateForeignTableStmt) Pos ¶ 

func (n *CreateForeignTableStmt) Pos() int

type CreateFunctionStmt ¶ 

type CreateFunctionStmt struct {
	Replace    bool
	Funcname   *ast.List
	Parameters *ast.List
	ReturnType *TypeName
	Options    *ast.List
	WithClause *ast.List
}

func (*CreateFunctionStmt) Pos ¶ 

func (n *CreateFunctionStmt) Pos() int

type CreateOpClassItem ¶ 

type CreateOpClassItem struct {
	Itemtype    int
	Name        *ObjectWithArgs
	Number      int
	OrderFamily *ast.List
	ClassArgs   *ast.List
	Storedtype  *TypeName
}

func (*CreateOpClassItem) Pos ¶ 

func (n *CreateOpClassItem) Pos() int

type CreateOpClassStmt ¶ 

type CreateOpClassStmt struct {
	Opclassname  *ast.List
	Opfamilyname *ast.List
	Amname       *string
	Datatype     *TypeName
	Items        *ast.List
	IsDefault    bool
}

func (*CreateOpClassStmt) Pos ¶ 

func (n *CreateOpClassStmt) Pos() int

type CreateOpFamilyStmt ¶ 

type CreateOpFamilyStmt struct {
	Opfamilyname *ast.List
	Amname       *string
}

func (*CreateOpFamilyStmt) Pos ¶ 

func (n *CreateOpFamilyStmt) Pos() int

type CreatePLangStmt ¶ 

type CreatePLangStmt struct {
	Replace     bool
	Plname      *string
	Plhandler   *ast.List
	Plinline    *ast.List
	Plvalidator *ast.List
	Pltrusted   bool
}

func (*CreatePLangStmt) Pos ¶ 

func (n *CreatePLangStmt) Pos() int

type CreatePolicyStmt ¶ 

type CreatePolicyStmt struct {
	PolicyName *string
	Table      *RangeVar
	CmdName    *string
	Permissive bool
	Roles      *ast.List
	Qual       ast.Node
	WithCheck  ast.Node
}

func (*CreatePolicyStmt) Pos ¶ 

func (n *CreatePolicyStmt) Pos() int

type CreatePublicationStmt ¶ 

type CreatePublicationStmt struct {
	Pubname      *string
	Options      *ast.List
	Tables       *ast.List
	ForAllTables bool
}

func (*CreatePublicationStmt) Pos ¶ 

func (n *CreatePublicationStmt) Pos() int

type CreateRangeStmt ¶ 

type CreateRangeStmt struct {
	TypeName *ast.List
	Params   *ast.List
}

func (*CreateRangeStmt) Pos ¶ 

func (n *CreateRangeStmt) Pos() int

type CreateRoleStmt ¶ 

type CreateRoleStmt struct {
	StmtType RoleStmtType
	Role     *string
	Options  *ast.List
}

func (*CreateRoleStmt) Pos ¶ 

func (n *CreateRoleStmt) Pos() int

type CreateSchemaStmt ¶ 

type CreateSchemaStmt struct {
	Schemaname  *string
	Authrole    *RoleSpec
	SchemaElts  *ast.List
	IfNotExists bool
}

func (*CreateSchemaStmt) Pos ¶ 

func (n *CreateSchemaStmt) Pos() int

type CreateSeqStmt ¶ 

type CreateSeqStmt struct {
	Sequence    *RangeVar
	Options     *ast.List
	OwnerId     Oid
	ForIdentity bool
	IfNotExists bool
}

func (*CreateSeqStmt) Pos ¶ 

func (n *CreateSeqStmt) Pos() int

type CreateStatsStmt ¶ 

type CreateStatsStmt struct {
	Defnames    *ast.List
	StatTypes   *ast.List
	Exprs       *ast.List
	Relations   *ast.List
	IfNotExists bool
}

func (*CreateStatsStmt) Pos ¶ 

func (n *CreateStatsStmt) Pos() int

type CreateStmt ¶ 

type CreateStmt struct {
	Relation       *RangeVar
	TableElts      *ast.List
	InhRelations   *ast.List
	Partbound      *PartitionBoundSpec
	Partspec       *PartitionSpec
	OfTypename     *TypeName
	Constraints    *ast.List
	Options        *ast.List
	Oncommit       OnCommitAction
	Tablespacename *string
	IfNotExists    bool
}

func (*CreateStmt) Pos ¶ 

func (n *CreateStmt) Pos() int

type CreateSubscriptionStmt ¶ 

type CreateSubscriptionStmt struct {
	Subname     *string
	Conninfo    *string
	Publication *ast.List
	Options     *ast.List
}

func (*CreateSubscriptionStmt) Pos ¶ 

func (n *CreateSubscriptionStmt) Pos() int

type CreateTableAsStmt ¶ 

type CreateTableAsStmt struct {
	Query        ast.Node
	Into         *IntoClause
	Relkind      ObjectType
	IsSelectInto bool
	IfNotExists  bool
}

func (*CreateTableAsStmt) Pos ¶ 

func (n *CreateTableAsStmt) Pos() int

type CreateTableSpaceStmt ¶ 

type CreateTableSpaceStmt struct {
	Tablespacename *string
	Owner          *RoleSpec
	Location       *string
	Options        *ast.List
}

func (*CreateTableSpaceStmt) Pos ¶ 

func (n *CreateTableSpaceStmt) Pos() int

type CreateTransformStmt ¶ 

type CreateTransformStmt struct {
	Replace  bool
	TypeName *TypeName
	Lang     *string
	Fromsql  *ObjectWithArgs
	Tosql    *ObjectWithArgs
}

func (*CreateTransformStmt) Pos ¶ 

func (n *CreateTransformStmt) Pos() int

type CreateTrigStmt ¶ 

type CreateTrigStmt struct {
	Trigname       *string
	Relation       *RangeVar
	Funcname       *ast.List
	Args           *ast.List
	Row            bool
	Timing         int16
	Events         int16
	Columns        *ast.List
	WhenClause     ast.Node
	Isconstraint   bool
	TransitionRels *ast.List
	Deferrable     bool
	Initdeferred   bool
	Constrrel      *RangeVar
}

func (*CreateTrigStmt) Pos ¶ 

func (n *CreateTrigStmt) Pos() int

type CreateUserMappingStmt ¶ 

type CreateUserMappingStmt struct {
	User        *RoleSpec
	Servername  *string
	IfNotExists bool
	Options     *ast.List
}

func (*CreateUserMappingStmt) Pos ¶ 

func (n *CreateUserMappingStmt) Pos() int

type CreatedbStmt ¶ 

type CreatedbStmt struct {
	Dbname  *string
	Options *ast.List
}

func (*CreatedbStmt) Pos ¶ 

func (n *CreatedbStmt) Pos() int

type CurrentOfExpr ¶ 

type CurrentOfExpr struct {
	Xpr         ast.Node
	Cvarno      Index
	CursorName  *string
	CursorParam int
}

func (*CurrentOfExpr) Pos ¶ 

func (n *CurrentOfExpr) Pos() int

type Datum ¶ 

type Datum uintptr

func (*Datum) Pos ¶ 

func (n *Datum) Pos() int

type DatumPtr ¶ 

type DatumPtr Datum

func (*DatumPtr) Pos ¶ 

func (n *DatumPtr) Pos() int

type DeallocateStmt ¶ 

type DeallocateStmt struct {
	Name *string
}

func (*DeallocateStmt) Pos ¶ 

func (n *DeallocateStmt) Pos() int

type DeclareCursorStmt ¶ 

type DeclareCursorStmt struct {
	Portalname *string
	Options    int
	Query      ast.Node
}

func (*DeclareCursorStmt) Pos ¶ 

func (n *DeclareCursorStmt) Pos() int

type DefElem ¶ 

type DefElem struct {
	Defnamespace *string
	Defname      *string
	Arg          ast.Node
	Defaction    DefElemAction
	Location     int
}

func (*DefElem) Pos ¶ 

func (n *DefElem) Pos() int

type DefElemAction ¶ 

type DefElemAction uint

func (*DefElemAction) Pos ¶ 

func (n *DefElemAction) Pos() int

type DefineStmt ¶ 

type DefineStmt struct {
	Kind        ObjectType
	Oldstyle    bool
	Defnames    *ast.List
	Args        *ast.List
	Definition  *ast.List
	IfNotExists bool
}

func (*DefineStmt) Pos ¶ 

func (n *DefineStmt) Pos() int

type DeleteStmt ¶ 

type DeleteStmt struct {
	Relation      *RangeVar
	UsingClause   *ast.List
	WhereClause   ast.Node
	ReturningList *ast.List
	WithClause    *WithClause
}

func (*DeleteStmt) Pos ¶ 

func (n *DeleteStmt) Pos() int

type DiscardMode ¶ 

type DiscardMode uint

func (*DiscardMode) Pos ¶ 

func (n *DiscardMode) Pos() int

type DiscardStmt ¶ 

type DiscardStmt struct {
	Target DiscardMode
}

func (*DiscardStmt) Pos ¶ 

func (n *DiscardStmt) Pos() int

type DistinctExpr ¶ 

type DistinctExpr OpExpr

func (*DistinctExpr) Pos ¶ 

func (n *DistinctExpr) Pos() int

type DoStmt ¶ 

type DoStmt struct {
	Args *ast.List
}

func (*DoStmt) Pos ¶ 

func (n *DoStmt) Pos() int

type DropBehavior ¶ 

type DropBehavior uint

func (*DropBehavior) Pos ¶ 

func (n *DropBehavior) Pos() int

type DropOwnedStmt ¶ 

type DropOwnedStmt struct {
	Roles    *ast.List
	Behavior DropBehavior
}

func (*DropOwnedStmt) Pos ¶ 

func (n *DropOwnedStmt) Pos() int

type DropRoleStmt ¶ 

type DropRoleStmt struct {
	Roles     *ast.List
	MissingOk bool
}

func (*DropRoleStmt) Pos ¶ 

func (n *DropRoleStmt) Pos() int

type DropStmt ¶ 

type DropStmt struct {
	Objects    *ast.List
	RemoveType ObjectType
	Behavior   DropBehavior
	MissingOk  bool
	Concurrent bool
}

func (*DropStmt) Pos ¶ 

func (n *DropStmt) Pos() int

type DropSubscriptionStmt ¶ 

type DropSubscriptionStmt struct {
	Subname   *string
	MissingOk bool
	Behavior  DropBehavior
}

func (*DropSubscriptionStmt) Pos ¶ 

func (n *DropSubscriptionStmt) Pos() int

type DropTableSpaceStmt ¶ 

type DropTableSpaceStmt struct {
	Tablespacename *string
	MissingOk      bool
}

func (*DropTableSpaceStmt) Pos ¶ 

func (n *DropTableSpaceStmt) Pos() int

type DropUserMappingStmt ¶ 

type DropUserMappingStmt struct {
	User       *RoleSpec
	Servername *string
	MissingOk  bool
}

func (*DropUserMappingStmt) Pos ¶ 

func (n *DropUserMappingStmt) Pos() int

type DropdbStmt ¶ 

type DropdbStmt struct {
	Dbname    *string
	MissingOk bool
}

func (*DropdbStmt) Pos ¶ 

func (n *DropdbStmt) Pos() int

type ExecuteStmt ¶ 

type ExecuteStmt struct {
	Name   *string
	Params *ast.List
}

func (*ExecuteStmt) Pos ¶ 

func (n *ExecuteStmt) Pos() int

type ExplainStmt ¶ 

type ExplainStmt struct {
	Query   ast.Node
	Options *ast.List
}

func (*ExplainStmt) Pos ¶ 

func (n *ExplainStmt) Pos() int

type Expr ¶ 

type Expr struct {
}

func (*Expr) Pos ¶ 

func (n *Expr) Pos() int

type FetchDirection ¶ 

type FetchDirection uint

func (*FetchDirection) Pos ¶ 

func (n *FetchDirection) Pos() int

type FetchStmt ¶ 

type FetchStmt struct {
	Direction  FetchDirection
	HowMany    int64
	Portalname *string
	Ismove     bool
}

func (*FetchStmt) Pos ¶ 

func (n *FetchStmt) Pos() int

type FieldSelect ¶ 

type FieldSelect struct {
	Xpr          ast.Node
	Arg          ast.Node
	Fieldnum     AttrNumber
	Resulttype   Oid
	Resulttypmod int32
	Resultcollid Oid
}

func (*FieldSelect) Pos ¶ 

func (n *FieldSelect) Pos() int

type FieldStore ¶ 

type FieldStore struct {
	Xpr        ast.Node
	Arg        ast.Node
	Newvals    *ast.List
	Fieldnums  *ast.List
	Resulttype Oid
}

func (*FieldStore) Pos ¶ 

func (n *FieldStore) Pos() int

type Float ¶ 

type Float struct {
	Str string
}

func (*Float) Pos ¶ 

func (n *Float) Pos() int

type FromExpr ¶ 

type FromExpr struct {
	Fromlist *ast.List
	Quals    ast.Node
}

func (*FromExpr) Pos ¶ 

func (n *FromExpr) Pos() int

type FuncExpr ¶ 

type FuncExpr struct {
	Xpr            ast.Node
	Funcid         Oid
	Funcresulttype Oid
	Funcretset     bool
	Funcvariadic   bool
	Funcformat     CoercionForm
	Funccollid     Oid
	Inputcollid    Oid
	Args           *ast.List
	Location       int
}

func (*FuncExpr) Pos ¶ 

func (n *FuncExpr) Pos() int

type FunctionParameter ¶ 

type FunctionParameter struct {
	Name    *string
	ArgType *TypeName
	Mode    FunctionParameterMode
	Defexpr ast.Node
}

func (*FunctionParameter) Pos ¶ 

func (n *FunctionParameter) Pos() int

type FunctionParameterMode ¶ 

type FunctionParameterMode uint

func (*FunctionParameterMode) Pos ¶ 

func (n *FunctionParameterMode) Pos() int

type GrantObjectType ¶ 

type GrantObjectType uint

func (*GrantObjectType) Pos ¶ 

func (n *GrantObjectType) Pos() int

type GrantRoleStmt ¶ 

type GrantRoleStmt struct {
	GrantedRoles *ast.List
	GranteeRoles *ast.List
	IsGrant      bool
	AdminOpt     bool
	Grantor      *RoleSpec
	Behavior     DropBehavior
}

func (*GrantRoleStmt) Pos ¶ 

func (n *GrantRoleStmt) Pos() int

type GrantStmt ¶ 

type GrantStmt struct {
	IsGrant     bool
	Targtype    GrantTargetType
	Objtype     GrantObjectType
	Objects     *ast.List
	Privileges  *ast.List
	Grantees    *ast.List
	GrantOption bool
	Behavior    DropBehavior
}

func (*GrantStmt) Pos ¶ 

func (n *GrantStmt) Pos() int

type GrantTargetType ¶ 

type GrantTargetType uint

func (*GrantTargetType) Pos ¶ 

func (n *GrantTargetType) Pos() int

type GroupingFunc ¶ 

type GroupingFunc struct {
	Xpr         ast.Node
	Args        *ast.List
	Refs        *ast.List
	Cols        *ast.List
	Agglevelsup Index
	Location    int
}

func (*GroupingFunc) Pos ¶ 

func (n *GroupingFunc) Pos() int

type GroupingSet ¶ 

type GroupingSet struct {
	Kind     GroupingSetKind
	Content  *ast.List
	Location int
}

func (*GroupingSet) Pos ¶ 

func (n *GroupingSet) Pos() int

type GroupingSetKind ¶ 

type GroupingSetKind uint

func (*GroupingSetKind) Pos ¶ 

func (n *GroupingSetKind) Pos() int

type ImportForeignSchemaStmt ¶ 

type ImportForeignSchemaStmt struct {
	ServerName   *string
	RemoteSchema *string
	LocalSchema  *string
	ListType     ImportForeignSchemaType
	TableList    *ast.List
	Options      *ast.List
}

func (*ImportForeignSchemaStmt) Pos ¶ 

func (n *ImportForeignSchemaStmt) Pos() int

type ImportForeignSchemaType ¶ 

type ImportForeignSchemaType uint

func (*ImportForeignSchemaType) Pos ¶ 

func (n *ImportForeignSchemaType) Pos() int

type Index ¶ 

type Index uint64

func (*Index) Pos ¶ 

func (n *Index) Pos() int

type IndexElem ¶ 

type IndexElem struct {
	Name          *string
	Expr          ast.Node
	Indexcolname  *string
	Collation     *ast.List
	Opclass       *ast.List
	Ordering      SortByDir
	NullsOrdering SortByNulls
}

func (*IndexElem) Pos ¶ 

func (n *IndexElem) Pos() int

type IndexStmt ¶ 

type IndexStmt struct {
	Idxname        *string
	Relation       *RangeVar
	AccessMethod   *string
	TableSpace     *string
	IndexParams    *ast.List
	Options        *ast.List
	WhereClause    ast.Node
	ExcludeOpNames *ast.List
	Idxcomment     *string
	IndexOid       Oid
	OldNode        Oid
	Unique         bool
	Primary        bool
	Isconstraint   bool
	Deferrable     bool
	Initdeferred   bool
	Transformed    bool
	Concurrent     bool
	IfNotExists    bool
}

func (*IndexStmt) Pos ¶ 

func (n *IndexStmt) Pos() int

type InferClause ¶ 

type InferClause struct {
	IndexElems  *ast.List
	WhereClause ast.Node
	Conname     *string
	Location    int
}

func (*InferClause) Pos ¶ 

func (n *InferClause) Pos() int

type InferenceElem ¶ 

type InferenceElem struct {
	Xpr          ast.Node
	Expr         ast.Node
	Infercollid  Oid
	Inferopclass Oid
}

func (*InferenceElem) Pos ¶ 

func (n *InferenceElem) Pos() int

type InlineCodeBlock ¶ 

type InlineCodeBlock struct {
	SourceText    *string
	LangOid       Oid
	LangIsTrusted bool
}

func (*InlineCodeBlock) Pos ¶ 

func (n *InlineCodeBlock) Pos() int

type InsertStmt ¶ 

type InsertStmt struct {
	Relation         *RangeVar
	Cols             *ast.List
	SelectStmt       ast.Node
	OnConflictClause *OnConflictClause
	ReturningList    *ast.List
	WithClause       *WithClause
	Override         OverridingKind
}

func (*InsertStmt) Pos ¶ 

func (n *InsertStmt) Pos() int

type Integer ¶ 

type Integer struct {
	Ival int64
}

func (*Integer) Pos ¶ 

func (n *Integer) Pos() int

type IntoClause ¶ 

type IntoClause struct {
	Rel            *RangeVar
	ColNames       *ast.List
	Options        *ast.List
	OnCommit       OnCommitAction
	TableSpaceName *string
	ViewQuery      ast.Node
	SkipData       bool
}

func (*IntoClause) Pos ¶ 

func (n *IntoClause) Pos() int

type JoinExpr ¶ 

type JoinExpr struct {
	Jointype    JoinType
	IsNatural   bool
	Larg        ast.Node
	Rarg        ast.Node
	UsingClause *ast.List
	Quals       ast.Node
	Alias       *Alias
	Rtindex     int
}

func (*JoinExpr) Pos ¶ 

func (n *JoinExpr) Pos() int

type JoinType ¶ 

type JoinType uint

func (*JoinType) Pos ¶ 

func (n *JoinType) Pos() int

type ListenStmt ¶ 

type ListenStmt struct {
	Conditionname *string
}

func (*ListenStmt) Pos ¶ 

func (n *ListenStmt) Pos() int

type LoadStmt ¶ 

type LoadStmt struct {
	Filename *string
}

func (*LoadStmt) Pos ¶ 

func (n *LoadStmt) Pos() int

type LocalTransactionId ¶ 

type LocalTransactionId uint32

func (*LocalTransactionId) Pos ¶ 

func (n *LocalTransactionId) Pos() int

type LockClauseStrength ¶ 

type LockClauseStrength uint

func (*LockClauseStrength) Pos ¶ 

func (n *LockClauseStrength) Pos() int

type LockStmt ¶ 

type LockStmt struct {
	Relations *ast.List
	Mode      int
	Nowait    bool
}

func (*LockStmt) Pos ¶ 

func (n *LockStmt) Pos() int

type LockWaitPolicy ¶ 

type LockWaitPolicy uint

func (*LockWaitPolicy) Pos ¶ 

func (n *LockWaitPolicy) Pos() int

type LockingClause ¶ 

type LockingClause struct {
	LockedRels *ast.List
	Strength   LockClauseStrength
	WaitPolicy LockWaitPolicy
}

func (*LockingClause) Pos ¶ 

func (n *LockingClause) Pos() int

type MinMaxExpr ¶ 

type MinMaxExpr struct {
	Xpr          ast.Node
	Minmaxtype   Oid
	Minmaxcollid Oid
	Inputcollid  Oid
	Op           MinMaxOp
	Args         *ast.List
	Location     int
}

func (*MinMaxExpr) Pos ¶ 

func (n *MinMaxExpr) Pos() int

type MinMaxOp ¶ 

type MinMaxOp uint

func (*MinMaxOp) Pos ¶ 

func (n *MinMaxOp) Pos() int

type MultiAssignRef ¶ 

type MultiAssignRef struct {
	Source   ast.Node
	Colno    int
	Ncolumns int
}

func (*MultiAssignRef) Pos ¶ 

func (n *MultiAssignRef) Pos() int

type MultiXactId ¶ 

type MultiXactId TransactionId

func (*MultiXactId) Pos ¶ 

func (n *MultiXactId) Pos() int

type MultiXactOffset ¶ 

type MultiXactOffset uint32

func (*MultiXactOffset) Pos ¶ 

func (n *MultiXactOffset) Pos() int

type NamedArgExpr ¶ 

type NamedArgExpr struct {
	Xpr       ast.Node
	Arg       ast.Node
	Name      *string
	Argnumber int
	Location  int
}

func (*NamedArgExpr) Pos ¶ 

func (n *NamedArgExpr) Pos() int

type NextValueExpr ¶ 

type NextValueExpr struct {
	Xpr    ast.Node
	Seqid  Oid
	TypeId Oid
}

func (*NextValueExpr) Pos ¶ 

func (n *NextValueExpr) Pos() int

type NotifyStmt ¶ 

type NotifyStmt struct {
	Conditionname *string
	Payload       *string
}

func (*NotifyStmt) Pos ¶ 

func (n *NotifyStmt) Pos() int

type Null ¶ 

type Null struct {
}

func (*Null) Pos ¶ 

func (n *Null) Pos() int

type NullIfExpr ¶ 

type NullIfExpr OpExpr

func (*NullIfExpr) Pos ¶ 

func (n *NullIfExpr) Pos() int

type NullTest ¶ 

type NullTest struct {
	Xpr          ast.Node
	Arg          ast.Node
	Nulltesttype NullTestType
	Argisrow     bool
	Location     int
}

func (*NullTest) Pos ¶ 

func (n *NullTest) Pos() int

type NullTestType ¶ 

type NullTestType uint

func (*NullTestType) Pos ¶ 

func (n *NullTestType) Pos() int

type ObjectType ¶ 

type ObjectType uint

func (*ObjectType) Pos ¶ 

func (n *ObjectType) Pos() int

type ObjectWithArgs ¶ 

type ObjectWithArgs struct {
	Objname         *ast.List
	Objargs         *ast.List
	ArgsUnspecified bool
}

func (*ObjectWithArgs) Pos ¶ 

func (n *ObjectWithArgs) Pos() int

type Offset ¶ 

type Offset int64

func (*Offset) Pos ¶ 

func (n *Offset) Pos() int

type Oid ¶ 

type Oid uint64

func (*Oid) Pos ¶ 

func (n *Oid) Pos() int

type OnCommitAction ¶ 

type OnCommitAction uint

func (*OnCommitAction) Pos ¶ 

func (n *OnCommitAction) Pos() int

type OnConflictAction ¶ 

type OnConflictAction uint

func (*OnConflictAction) Pos ¶ 

func (n *OnConflictAction) Pos() int

type OnConflictClause ¶ 

type OnConflictClause struct {
	Action      OnConflictAction
	Infer       *InferClause
	TargetList  *ast.List
	WhereClause ast.Node
	Location    int
}

func (*OnConflictClause) Pos ¶ 

func (n *OnConflictClause) Pos() int

type OnConflictExpr ¶ 

type OnConflictExpr struct {
	Action          OnConflictAction
	ArbiterElems    *ast.List
	ArbiterWhere    ast.Node
	Constraint      Oid
	OnConflictSet   *ast.List
	OnConflictWhere ast.Node
	ExclRelIndex    int
	ExclRelTlist    *ast.List
}

func (*OnConflictExpr) Pos ¶ 

func (n *OnConflictExpr) Pos() int

type OpExpr ¶ 

type OpExpr struct {
	Xpr          ast.Node
	Opno         Oid
	Opfuncid     Oid
	Opresulttype Oid
	Opretset     bool
	Opcollid     Oid
	Inputcollid  Oid
	Args         *ast.List
	Location     int
}

func (*OpExpr) Pos ¶ 

func (n *OpExpr) Pos() int

type OverridingKind ¶ 

type OverridingKind uint

func (*OverridingKind) Pos ¶ 

func (n *OverridingKind) Pos() int

type Param ¶ 

type Param struct {
	Xpr         ast.Node
	Paramkind   ParamKind
	Paramid     int
	Paramtype   Oid
	Paramtypmod int32
	Paramcollid Oid
	Location    int
}

func (*Param) Pos ¶ 

func (n *Param) Pos() int

type ParamExecData ¶ 

type ParamExecData struct {
	ExecPlan interface{}
	Value    Datum
	Isnull   bool
}

func (*ParamExecData) Pos ¶ 

func (n *ParamExecData) Pos() int

type ParamExternData ¶ 

type ParamExternData struct {
	Value  Datum
	Isnull bool
	Pflags uint16
	Ptype  Oid
}

func (*ParamExternData) Pos ¶ 

func (n *ParamExternData) Pos() int

type ParamKind ¶ 

type ParamKind uint

func (*ParamKind) Pos ¶ 

func (n *ParamKind) Pos() int

type ParamListInfo ¶ 

type ParamListInfo ParamListInfoData

func (*ParamListInfo) Pos ¶ 

func (n *ParamListInfo) Pos() int

type ParamListInfoData ¶ 

type ParamListInfoData struct {
	ParamFetchArg  interface{}
	ParserSetupArg interface{}
	NumParams      int
	ParamMask      []uint32
}

func (*ParamListInfoData) Pos ¶ 

func (n *ParamListInfoData) Pos() int

type ParamRef ¶ 

type ParamRef struct {
	Number   int
	Location int
}

func (*ParamRef) Pos ¶ 

func (n *ParamRef) Pos() int

type PartitionBoundSpec ¶ 

type PartitionBoundSpec struct {
	Strategy    byte
	Listdatums  *ast.List
	Lowerdatums *ast.List
	Upperdatums *ast.List
	Location    int
}

func (*PartitionBoundSpec) Pos ¶ 

func (n *PartitionBoundSpec) Pos() int

type PartitionCmd ¶ 

type PartitionCmd struct {
	Name  *RangeVar
	Bound *PartitionBoundSpec
}

func (*PartitionCmd) Pos ¶ 

func (n *PartitionCmd) Pos() int

type PartitionElem ¶ 

type PartitionElem struct {
	Name      *string
	Expr      ast.Node
	Collation *ast.List
	Opclass   *ast.List
	Location  int
}

func (*PartitionElem) Pos ¶ 

func (n *PartitionElem) Pos() int

type PartitionRangeDatum ¶ 

type PartitionRangeDatum struct {
	Kind     PartitionRangeDatumKind
	Value    ast.Node
	Location int
}

func (*PartitionRangeDatum) Pos ¶ 

func (n *PartitionRangeDatum) Pos() int

type PartitionRangeDatumKind ¶ 

type PartitionRangeDatumKind uint

func (*PartitionRangeDatumKind) Pos ¶ 

func (n *PartitionRangeDatumKind) Pos() int

type PartitionSpec ¶ 

type PartitionSpec struct {
	Strategy   *string
	PartParams *ast.List
	Location   int
}

func (*PartitionSpec) Pos ¶ 

func (n *PartitionSpec) Pos() int

type Pointer ¶ 

type Pointer byte

func (*Pointer) Pos ¶ 

func (n *Pointer) Pos() int

type PrepareStmt ¶ 

type PrepareStmt struct {
	Name     *string
	Argtypes *ast.List
	Query    ast.Node
}

func (*PrepareStmt) Pos ¶ 

func (n *PrepareStmt) Pos() int

type Query ¶ 

type Query struct {
	CommandType      CmdType
	QuerySource      QuerySource
	QueryId          uint32
	CanSetTag        bool
	UtilityStmt      ast.Node
	ResultRelation   int
	HasAggs          bool
	HasWindowFuncs   bool
	HasTargetSrfs    bool
	HasSubLinks      bool
	HasDistinctOn    bool
	HasRecursive     bool
	HasModifyingCte  bool
	HasForUpdate     bool
	HasRowSecurity   bool
	CteList          *ast.List
	Rtable           *ast.List
	Jointree         *FromExpr
	TargetList       *ast.List
	Override         OverridingKind
	OnConflict       *OnConflictExpr
	ReturningList    *ast.List
	GroupClause      *ast.List
	GroupingSets     *ast.List
	HavingQual       ast.Node
	WindowClause     *ast.List
	DistinctClause   *ast.List
	SortClause       *ast.List
	LimitOffset      ast.Node
	LimitCount       ast.Node
	RowMarks         *ast.List
	SetOperations    ast.Node
	ConstraintDeps   *ast.List
	WithCheckOptions *ast.List
	StmtLocation     int
	StmtLen          int
}

func (*Query) Pos ¶ 

func (n *Query) Pos() int

type QuerySource ¶ 

type QuerySource uint

func (*QuerySource) Pos ¶ 

func (n *QuerySource) Pos() int

type RTEKind ¶ 

type RTEKind uint

func (*RTEKind) Pos ¶ 

func (n *RTEKind) Pos() int

type RangeFunction ¶ 

type RangeFunction struct {
	Lateral    bool
	Ordinality bool
	IsRowsfrom bool
	Functions  *ast.List
	Alias      *Alias
	Coldeflist *ast.List
}

func (*RangeFunction) Pos ¶ 

func (n *RangeFunction) Pos() int

type RangeSubselect ¶ 

type RangeSubselect struct {
	Lateral  bool
	Subquery ast.Node
	Alias    *Alias
}

func (*RangeSubselect) Pos ¶ 

func (n *RangeSubselect) Pos() int

type RangeTableFunc ¶ 

type RangeTableFunc struct {
	Lateral    bool
	Docexpr    ast.Node
	Rowexpr    ast.Node
	Namespaces *ast.List
	Columns    *ast.List
	Alias      *Alias
	Location   int
}

func (*RangeTableFunc) Pos ¶ 

func (n *RangeTableFunc) Pos() int

type RangeTableFuncCol ¶ 

type RangeTableFuncCol struct {
	Colname       *string
	TypeName      *TypeName
	ForOrdinality bool
	IsNotNull     bool
	Colexpr       ast.Node
	Coldefexpr    ast.Node
	Location      int
}

func (*RangeTableFuncCol) Pos ¶ 

func (n *RangeTableFuncCol) Pos() int

type RangeTableSample ¶ 

type RangeTableSample struct {
	Relation   ast.Node
	Method     *ast.List
	Args       *ast.List
	Repeatable ast.Node
	Location   int
}

func (*RangeTableSample) Pos ¶ 

func (n *RangeTableSample) Pos() int

type RangeTblEntry ¶ 

type RangeTblEntry struct {
	Rtekind         RTEKind
	Relid           Oid
	Relkind         byte
	Tablesample     *TableSampleClause
	Subquery        *Query
	SecurityBarrier bool
	Jointype        JoinType
	Joinaliasvars   *ast.List
	Functions       *ast.List
	Funcordinality  bool
	Tablefunc       *TableFunc
	ValuesLists     *ast.List
	Ctename         *string
	Ctelevelsup     Index
	SelfReference   bool
	Coltypes        *ast.List
	Coltypmods      *ast.List
	Colcollations   *ast.List
	Enrname         *string
	Enrtuples       float64
	Alias           *Alias
	Eref            *Alias
	Lateral         bool
	Inh             bool
	InFromCl        bool
	RequiredPerms   AclMode
	CheckAsUser     Oid
	SelectedCols    []uint32
	InsertedCols    []uint32
	UpdatedCols     []uint32
	SecurityQuals   *ast.List
}

func (*RangeTblEntry) Pos ¶ 

func (n *RangeTblEntry) Pos() int

type RangeTblFunction ¶ 

type RangeTblFunction struct {
	Funcexpr          ast.Node
	Funccolcount      int
	Funccolnames      *ast.List
	Funccoltypes      *ast.List
	Funccoltypmods    *ast.List
	Funccolcollations *ast.List
	Funcparams        []uint32
}

func (*RangeTblFunction) Pos ¶ 

func (n *RangeTblFunction) Pos() int

type RangeTblRef ¶ 

type RangeTblRef struct {
	Rtindex int
}

func (*RangeTblRef) Pos ¶ 

func (n *RangeTblRef) Pos() int

type RangeVar ¶ 

type RangeVar struct {
	Catalogname    *string
	Schemaname     *string
	Relname        *string
	Inh            bool
	Relpersistence byte
	Alias          *Alias
	Location       int
}

func (*RangeVar) Pos ¶ 

func (n *RangeVar) Pos() int

type RawStmt ¶ 

type RawStmt struct {
	Stmt         ast.Node
	StmtLocation int
	StmtLen      int
}

func (*RawStmt) Pos ¶ 

func (n *RawStmt) Pos() int

type ReassignOwnedStmt ¶ 

type ReassignOwnedStmt struct {
	Roles   *ast.List
	Newrole *RoleSpec
}

func (*ReassignOwnedStmt) Pos ¶ 

func (n *ReassignOwnedStmt) Pos() int

type RefreshMatViewStmt ¶ 

type RefreshMatViewStmt struct {
	Concurrent bool
	SkipData   bool
	Relation   *RangeVar
}

func (*RefreshMatViewStmt) Pos ¶ 

func (n *RefreshMatViewStmt) Pos() int

type RegProcedure ¶ 

type RegProcedure regproc

func (*RegProcedure) Pos ¶ 

func (n *RegProcedure) Pos() int

type ReindexObjectType ¶ 

type ReindexObjectType uint

func (*ReindexObjectType) Pos ¶ 

func (n *ReindexObjectType) Pos() int

type ReindexStmt ¶ 

type ReindexStmt struct {
	Kind     ReindexObjectType
	Relation *RangeVar
	Name     *string
	Options  int
}

func (*ReindexStmt) Pos ¶ 

func (n *ReindexStmt) Pos() int

type RelabelType ¶ 

type RelabelType struct {
	Xpr           ast.Node
	Arg           ast.Node
	Resulttype    Oid
	Resulttypmod  int32
	Resultcollid  Oid
	Relabelformat CoercionForm
	Location      int
}

func (*RelabelType) Pos ¶ 

func (n *RelabelType) Pos() int

type RenameStmt ¶ 

type RenameStmt struct {
	RenameType   ObjectType
	RelationType ObjectType
	Relation     *RangeVar
	Object       ast.Node
	Subname      *string
	Newname      *string
	Behavior     DropBehavior
	MissingOk    bool
}

func (*RenameStmt) Pos ¶ 

func (n *RenameStmt) Pos() int

type ReplicaIdentityStmt ¶ 

type ReplicaIdentityStmt struct {
	IdentityType byte
	Name         *string
}

func (*ReplicaIdentityStmt) Pos ¶ 

func (n *ReplicaIdentityStmt) Pos() int

type ResTarget ¶ 

type ResTarget struct {
	Name        *string
	Indirection *ast.List
	Val         ast.Node
	Location    int
}

func (*ResTarget) Pos ¶ 

func (n *ResTarget) Pos() int

type RoleSpec ¶ 

type RoleSpec struct {
	Roletype RoleSpecType
	Rolename *string
	Location int
}

func (*RoleSpec) Pos ¶ 

func (n *RoleSpec) Pos() int

type RoleSpecType ¶ 

type RoleSpecType uint

func (*RoleSpecType) Pos ¶ 

func (n *RoleSpecType) Pos() int

type RoleStmtType ¶ 

type RoleStmtType uint

func (*RoleStmtType) Pos ¶ 

func (n *RoleStmtType) Pos() int

type RowCompareExpr ¶ 

type RowCompareExpr struct {
	Xpr          ast.Node
	Rctype       RowCompareType
	Opnos        *ast.List
	Opfamilies   *ast.List
	Inputcollids *ast.List
	Largs        *ast.List
	Rargs        *ast.List
}

func (*RowCompareExpr) Pos ¶ 

func (n *RowCompareExpr) Pos() int

type RowCompareType ¶ 

type RowCompareType uint

func (*RowCompareType) Pos ¶ 

func (n *RowCompareType) Pos() int

type RowExpr ¶ 

type RowExpr struct {
	Xpr       ast.Node
	Args      *ast.List
	RowTypeid Oid
	RowFormat CoercionForm
	Colnames  *ast.List
	Location  int
}

func (*RowExpr) Pos ¶ 

func (n *RowExpr) Pos() int

type RowMarkClause ¶ 

type RowMarkClause struct {
	Rti        Index
	Strength   LockClauseStrength
	WaitPolicy LockWaitPolicy
	PushedDown bool
}

func (*RowMarkClause) Pos ¶ 

func (n *RowMarkClause) Pos() int

type RuleStmt ¶ 

type RuleStmt struct {
	Relation    *RangeVar
	Rulename    *string
	WhereClause ast.Node
	Event       CmdType
	Instead     bool
	Actions     *ast.List
	Replace     bool
}

func (*RuleStmt) Pos ¶ 

func (n *RuleStmt) Pos() int

type SQLValueFunction ¶ 

type SQLValueFunction struct {
	Xpr      ast.Node
	Op       SQLValueFunctionOp
	Type     Oid
	Typmod   int32
	Location int
}

func (*SQLValueFunction) Pos ¶ 

func (n *SQLValueFunction) Pos() int

type SQLValueFunctionOp ¶ 

type SQLValueFunctionOp uint

func (*SQLValueFunctionOp) Pos ¶ 

func (n *SQLValueFunctionOp) Pos() int

type ScalarArrayOpExpr ¶ 

type ScalarArrayOpExpr struct {
	Xpr         ast.Node
	Opno        Oid
	Opfuncid    Oid
	UseOr       bool
	Inputcollid Oid
	Args        *ast.List
	Location    int
}

func (*ScalarArrayOpExpr) Pos ¶ 

func (n *ScalarArrayOpExpr) Pos() int

type ScanDirection ¶ 

type ScanDirection uint

func (*ScanDirection) Pos ¶ 

func (n *ScanDirection) Pos() int

type SecLabelStmt ¶ 

type SecLabelStmt struct {
	Objtype  ObjectType
	Object   ast.Node
	Provider *string
	Label    *string
}

func (*SecLabelStmt) Pos ¶ 

func (n *SecLabelStmt) Pos() int

type SelectStmt ¶ 

type SelectStmt struct {
	DistinctClause *ast.List
	IntoClause     *IntoClause
	TargetList     *ast.List
	FromClause     *ast.List
	WhereClause    ast.Node
	GroupClause    *ast.List
	HavingClause   ast.Node
	WindowClause   *ast.List
	ValuesLists    *ast.List
	SortClause     *ast.List
	LimitOffset    ast.Node
	LimitCount     ast.Node
	LockingClause  *ast.List
	WithClause     *WithClause
	Op             SetOperation
	All            bool
	Larg           *SelectStmt
	Rarg           *SelectStmt
}

func (*SelectStmt) Pos ¶ 

func (n *SelectStmt) Pos() int

type Selectivity ¶ 

type Selectivity float64

func (*Selectivity) Pos ¶ 

func (n *Selectivity) Pos() int

type SetOpCmd ¶ 

type SetOpCmd uint

func (*SetOpCmd) Pos ¶ 

func (n *SetOpCmd) Pos() int

type SetOpStrategy ¶ 

type SetOpStrategy uint

func (*SetOpStrategy) Pos ¶ 

func (n *SetOpStrategy) Pos() int

type SetOperation ¶ 

type SetOperation uint

func (*SetOperation) Pos ¶ 

func (n *SetOperation) Pos() int

type SetOperationStmt ¶ 

type SetOperationStmt struct {
	Op            SetOperation
	All           bool
	Larg          ast.Node
	Rarg          ast.Node
	ColTypes      *ast.List
	ColTypmods    *ast.List
	ColCollations *ast.List
	GroupClauses  *ast.List
}

func (*SetOperationStmt) Pos ¶ 

func (n *SetOperationStmt) Pos() int

type SetToDefault ¶ 

type SetToDefault struct {
	Xpr       ast.Node
	TypeId    Oid
	TypeMod   int32
	Collation Oid
	Location  int
}

func (*SetToDefault) Pos ¶ 

func (n *SetToDefault) Pos() int

type SortBy ¶ 

type SortBy struct {
	Node        ast.Node
	SortbyDir   SortByDir
	SortbyNulls SortByNulls
	UseOp       *ast.List
	Location    int
}

func (*SortBy) Pos ¶ 

func (n *SortBy) Pos() int

type SortByDir ¶ 

type SortByDir uint

func (*SortByDir) Pos ¶ 

func (n *SortByDir) Pos() int

type SortByNulls ¶ 

type SortByNulls uint

func (*SortByNulls) Pos ¶ 

func (n *SortByNulls) Pos() int

type SortGroupClause ¶ 

type SortGroupClause struct {
	TleSortGroupRef Index
	Eqop            Oid
	Sortop          Oid
	NullsFirst      bool
	Hashable        bool
}

func (*SortGroupClause) Pos ¶ 

func (n *SortGroupClause) Pos() int

type String ¶ 

type String struct {
	Str string
}

func (*String) Pos ¶ 

func (n *String) Pos() int
type SubLink struct {
	Xpr         ast.Node
	SubLinkType SubLinkType
	SubLinkId   int
	Testexpr    ast.Node
	OperName    *ast.List
	Subselect   ast.Node
	Location    int
}

func (*SubLink) Pos ¶ 

func (n *SubLink) Pos() int

type SubLinkType ¶ 

type SubLinkType uint
const (
	EXISTS_SUBLINK SubLinkType = iota
	ALL_SUBLINK
	ANY_SUBLINK
	ROWCOMPARE_SUBLINK
	EXPR_SUBLINK
	MULTIEXPR_SUBLINK
	ARRAY_SUBLINK
	CTE_SUBLINK /* for SubPlans only */
)

type SubPlan ¶ 

type SubPlan struct {
	Xpr               ast.Node
	SubLinkType       SubLinkType
	Testexpr          ast.Node
	ParamIds          *ast.List
	PlanId            int
	PlanName          *string
	FirstColType      Oid
	FirstColTypmod    int32
	FirstColCollation Oid
	UseHashTable      bool
	UnknownEqFalse    bool
	ParallelSafe      bool
	SetParam          *ast.List
	ParParam          *ast.List
	Args              *ast.List
	StartupCost       Cost
	PerCallCost       Cost
}

func (*SubPlan) Pos ¶ 

func (n *SubPlan) Pos() int

type SubTransactionId ¶ 

type SubTransactionId uint32

func (*SubTransactionId) Pos ¶ 

func (n *SubTransactionId) Pos() int

type TableFunc ¶ 

type TableFunc struct {
	NsUris        *ast.List
	NsNames       *ast.List
	Docexpr       ast.Node
	Rowexpr       ast.Node
	Colnames      *ast.List
	Coltypes      *ast.List
	Coltypmods    *ast.List
	Colcollations *ast.List
	Colexprs      *ast.List
	Coldefexprs   *ast.List
	Notnulls      []uint32
	Ordinalitycol int
	Location      int
}

func (*TableFunc) Pos ¶ 

func (n *TableFunc) Pos() int

type TableLikeClause ¶ 

type TableLikeClause struct {
	Relation *RangeVar
	Options  uint32
}

func (*TableLikeClause) Pos ¶ 

func (n *TableLikeClause) Pos() int

type TableLikeOption ¶ 

type TableLikeOption uint

func (*TableLikeOption) Pos ¶ 

func (n *TableLikeOption) Pos() int

type TableSampleClause ¶ 

type TableSampleClause struct {
	Tsmhandler Oid
	Args       *ast.List
	Repeatable ast.Node
}

func (*TableSampleClause) Pos ¶ 

func (n *TableSampleClause) Pos() int

type TargetEntry ¶ 

type TargetEntry struct {
	Xpr             ast.Node
	Expr            ast.Node
	Resno           AttrNumber
	Resname         *string
	Ressortgroupref Index
	Resorigtbl      Oid
	Resorigcol      AttrNumber
	Resjunk         bool
}

func (*TargetEntry) Pos ¶ 

func (n *TargetEntry) Pos() int

type TransactionId ¶ 

type TransactionId uint32

func (*TransactionId) Pos ¶ 

func (n *TransactionId) Pos() int

type TransactionStmt ¶ 

type TransactionStmt struct {
	Kind    TransactionStmtKind
	Options *ast.List
	Gid     *string
}

func (*TransactionStmt) Pos ¶ 

func (n *TransactionStmt) Pos() int

type TransactionStmtKind ¶ 

type TransactionStmtKind uint

func (*TransactionStmtKind) Pos ¶ 

func (n *TransactionStmtKind) Pos() int

type TriggerTransition ¶ 

type TriggerTransition struct {
	Name    *string
	IsNew   bool
	IsTable bool
}

func (*TriggerTransition) Pos ¶ 

func (n *TriggerTransition) Pos() int

type TruncateStmt ¶ 

type TruncateStmt struct {
	Relations   *ast.List
	RestartSeqs bool
	Behavior    DropBehavior
}

func (*TruncateStmt) Pos ¶ 

func (n *TruncateStmt) Pos() int

type TypeCast ¶ 

type TypeCast struct {
	Arg      ast.Node
	TypeName *TypeName
	Location int
}

func (*TypeCast) Pos ¶ 

func (n *TypeCast) Pos() int

type TypeName ¶ 

type TypeName struct {
	Names       *ast.List
	TypeOid     Oid
	Setof       bool
	PctType     bool
	Typmods     *ast.List
	Typemod     int32
	ArrayBounds *ast.List
	Location    int
}

func (*TypeName) Pos ¶ 

func (n *TypeName) Pos() int

type UnlistenStmt ¶ 

type UnlistenStmt struct {
	Conditionname *string
}

func (*UnlistenStmt) Pos ¶ 

func (n *UnlistenStmt) Pos() int

type UpdateStmt ¶ 

type UpdateStmt struct {
	Relation      *RangeVar
	TargetList    *ast.List
	WhereClause   ast.Node
	FromClause    *ast.List
	ReturningList *ast.List
	WithClause    *WithClause
}

func (*UpdateStmt) Pos ¶ 

func (n *UpdateStmt) Pos() int

type VacuumOption ¶ 

type VacuumOption uint

func (*VacuumOption) Pos ¶ 

func (n *VacuumOption) Pos() int

type VacuumStmt ¶ 

type VacuumStmt struct {
	Options  int
	Relation *RangeVar
	VaCols   *ast.List
}

func (*VacuumStmt) Pos ¶ 

func (n *VacuumStmt) Pos() int

type Var ¶ 

type Var struct {
	Xpr         ast.Node
	Varno       Index
	Varattno    AttrNumber
	Vartype     Oid
	Vartypmod   int32
	Varcollid   Oid
	Varlevelsup Index
	Varnoold    Index
	Varoattno   AttrNumber
	Location    int
}

func (*Var) Pos ¶ 

func (n *Var) Pos() int

type VariableSetKind ¶ 

type VariableSetKind uint

func (*VariableSetKind) Pos ¶ 

func (n *VariableSetKind) Pos() int

type VariableSetStmt ¶ 

type VariableSetStmt struct {
	Kind    VariableSetKind
	Name    *string
	Args    *ast.List
	IsLocal bool
}

func (*VariableSetStmt) Pos ¶ 

func (n *VariableSetStmt) Pos() int

type VariableShowStmt ¶ 

type VariableShowStmt struct {
	Name *string
}

func (*VariableShowStmt) Pos ¶ 

func (n *VariableShowStmt) Pos() int

type ViewCheckOption ¶ 

type ViewCheckOption uint

func (*ViewCheckOption) Pos ¶ 

func (n *ViewCheckOption) Pos() int

type ViewStmt ¶ 

type ViewStmt struct {
	View            *RangeVar
	Aliases         *ast.List
	Query           ast.Node
	Replace         bool
	Options         *ast.List
	WithCheckOption ViewCheckOption
}

func (*ViewStmt) Pos ¶ 

func (n *ViewStmt) Pos() int

type WCOKind ¶ 

type WCOKind uint

func (*WCOKind) Pos ¶ 

func (n *WCOKind) Pos() int

type WindowClause ¶ 

type WindowClause struct {
	Name            *string
	Refname         *string
	PartitionClause *ast.List
	OrderClause     *ast.List
	FrameOptions    int
	StartOffset     ast.Node
	EndOffset       ast.Node
	Winref          Index
	CopiedOrder     bool
}

func (*WindowClause) Pos ¶ 

func (n *WindowClause) Pos() int

type WindowFunc ¶ 

type WindowFunc struct {
	Xpr         ast.Node
	Winfnoid    Oid
	Wintype     Oid
	Wincollid   Oid
	Inputcollid Oid
	Args        *ast.List
	Aggfilter   ast.Node
	Winref      Index
	Winstar     bool
	Winagg      bool
	Location    int
}

func (*WindowFunc) Pos ¶ 

func (n *WindowFunc) Pos() int

type WithCheckOption ¶ 

type WithCheckOption struct {
	Kind     WCOKind
	Relname  *string
	Polname  *string
	Qual     ast.Node
	Cascaded bool
}

func (*WithCheckOption) Pos ¶ 

func (n *WithCheckOption) Pos() int

type WithClause ¶ 

type WithClause struct {
	Ctes      *ast.List
	Recursive bool
	Location  int
}

func (*WithClause) Pos ¶ 

func (n *WithClause) Pos() int

type XmlExpr ¶ 

type XmlExpr struct {
	Xpr       ast.Node
	Op        XmlExprOp
	Name      *string
	NamedArgs *ast.List
	ArgNames  *ast.List
	Args      *ast.List
	Xmloption XmlOptionType
	Type      Oid
	Typmod    int32
	Location  int
}

func (*XmlExpr) Pos ¶ 

func (n *XmlExpr) Pos() int

type XmlExprOp ¶ 

type XmlExprOp uint

func (*XmlExprOp) Pos ¶ 

func (n *XmlExprOp) Pos() int

type XmlOptionType ¶ 

type XmlOptionType uint

func (*XmlOptionType) Pos ¶ 

func (n *XmlOptionType) Pos() int

type XmlSerialize ¶ 

type XmlSerialize struct {
	Xmloption XmlOptionType
	Expr      ast.Node
	TypeName  *TypeName
	Location  int
}

func (*XmlSerialize) Pos ¶ 

func (n *XmlSerialize) Pos() int

Source Files ¶

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.