Versions in this module Expand all Collapse all v0 v0.0.4 Mar 20, 2022 v0.0.3 Mar 20, 2022 v0.0.2 Mar 20, 2022 v0.0.1 Mar 18, 2022 Changes in this version + const AllFuncType + const AnnotateExplicit + const AnnotateShort + const AstCross + const AstFull + const AstHash + const AstHaving + const AstInner + const AstInverted + const AstLeft + const AstLookup + const AstMerge + const AstRight + const AstWhere + const CastExplicit + const CastPrepend + const CastShort + const ColumnLimit + const ConsoleLineWidth + const DefaultCollationTag + const DefaultLineWidth + const DistinctFuncType + const FollowerReadTimestampExperimentalFunctionName + const FollowerReadTimestampFunctionName + const LikeTableOptAll + const MaxPlaceholderIdx + const NoColumnIdx + const PasswordSubstitution + const PrettyAlignAndDeindent + const PrettyAlignAndExtraIndent + const PrettyAlignOnly + const PrettyNoAlign + const PrimaryRegionNotSpecifiedName + const PublicSchema + const PublicSchemaName + const RegionEnum + const RegionalByRowRegionDefaultCol + const RegionalByRowRegionDefaultColName + const RegionalByRowRegionNotSpecifiedName + const ScrubDatabase + const ScrubTable + const SeqOptAs + const SeqOptCache + const SeqOptCycle + const SeqOptIncrement + const SeqOptMaxValue + const SeqOptMinValue + const SeqOptNoCycle + const SeqOptOwnedBy + const SeqOptStart + const SeqOptVirtual + const TableLimit + const TelemetryNameGlobal + const TelemetryNameRegionalByRow + const TelemetryNameRegionalByRowAs + const TelemetryNameRegionalByTable + const TelemetryNameRegionalByTableIn + const WithMaxStalenessFunctionName + const WithMinTimestampFunctionName + const ZeroOidValue + var AbsentReturningClause = &NoReturningClause + var BinOps = map[treebin.BinaryOperatorSymbol]binOpOverload + var CmpOps = cmpOpFixups(map[treecmp.ComparisonOperatorSymbol]cmpOpOverload{ ... }) + var DBoolFalse = &constDBoolFalse + var DBoolTrue = &constDBoolTrue + var DMaxIPAddr = NewDIPAddr(DIPAddr{ ... }) + var DMaxTimeTZ = NewDTimeTZFromOffset(timeofday.Max, timetz.MaxTimeTZOffsetSecs) + var DMaxUUID = NewDUuid(DUuid{ ... }) + var DMinIPAddr = NewDIPAddr(DIPAddr{ ... }) + var DMinTimeTZ = NewDTimeTZFromOffset(timeofday.Min, timetz.MinTimeTZOffsetSecs) + var DMinUUID = NewDUuid(DUuid{ ... }) + var DNull Datum = dNull + var DTimeMaxTimeRegex = regexp.MustCompile(`^([0-9-]*(\s|T))?\s*24:00(:00(.0+)?)?\s*$`) + var DVoidDatum = &DVoid + var DZero = NewDInt(0) + var DecimalCtx = &apd.Context + var ErrAsOfSpecifiedWithReadWrite = pgerror.New(pgcode.Syntax, "AS OF SYSTEM TIME specified with READ WRITE mode") + var ErrDecOutOfRange = pgerror.New(pgcode.NumericValueOutOfRange, "decimal out of range") + var ErrDivByZero = pgerror.New(pgcode.DivisionByZero, "division by zero") + var ErrFloatOutOfRange = pgerror.New(pgcode.NumericValueOutOfRange, "float out of range") + var ErrInt2OutOfRange = pgerror.New(pgcode.NumericValueOutOfRange, "integer out of range for type int2") + var ErrInt4OutOfRange = pgerror.New(pgcode.NumericValueOutOfRange, "integer out of range for type int4") + var ErrIntOutOfRange = pgerror.New(pgcode.NumericValueOutOfRange, "integer out of range") + var ErrShiftArgOutOfRange = pgerror.New(pgcode.InvalidParameterValue, "shift argument out of range") + var ExactCtx = DecimalCtx.WithPrecision(0) + var FunDefs map[string]*FunctionDefinition + var HighPrecisionCtx = DecimalCtx.WithPrecision(2000) + var IntermediateCtx = DecimalCtx.WithPrecision(DecimalCtx.Precision + 5) + var IsolationLevelMap = map[string]IsolationLevel + var JobCommandToStatement = map[JobCommand]string + var MaxSupportedTime = timeutil.Unix(9224318016000 - 1, 999999000) + var MinSupportedTime = timeutil.Unix(-210866803200, 0) + var NumValAvailDecimalNoFraction = append(decimalLikeTypes, intLikeTypes) + var NumValAvailDecimalWithFraction = decimalLikeTypes + var NumValAvailInteger = append(intLikeTypes, decimalLikeTypes) + var OidToBuiltinName map[oid.Oid]string + var ReturningNothingClause = &ReturningNothing + var RoundCtx = func() *apd.Context { ... }() + var ShowLastQueryStatisticsDefaultColumns = NameList([]Name{ ... }) + var StrValAvailAllParsable = []*types.T + var StrValAvailBytes = []*types.T + var UnaryOps = unaryOpFixups(map[UnaryOperatorSymbol]unaryOpOverload{ ... }) + var UnknownReturnType *types.T + func AsJSON(d Datum, dcc sessiondatapb.DataConversionConfig, loc *time.Location) (json.JSON, error) + func AsString(n NodeFormatter) string + func AsStringWithFQNames(n NodeFormatter, ann *Annotations) string + func AsStringWithFlags(n NodeFormatter, fl FmtFlags, opts ...FmtCtxOption) string + func CanModifySchema(stmt Statement) bool + func CanWriteData(stmt Statement) bool + func CheckIsWindowOrAgg(def *FunctionDefinition) error + func CmpOpInverse(i treecmp.ComparisonOperatorSymbol) (treecmp.ComparisonOperatorSymbol, bool) + func CompareBools(d, v bool) int + func CompareDecimals(d *apd.Decimal, v *apd.Decimal) int + func ComputeColNameInternal(sp sessiondata.SearchPath, target Expr) (int, string, error) + func ContainsVars(expr Expr) bool + func ConvertLikeToRegexp(ctx *EvalContext, pattern string, caseInsensitive bool, escape rune) (*regexp.Regexp, error) + func DatumToHLC(evalCtx *EvalContext, stmtTimestamp time.Time, d Datum) (hlc.Timestamp, error) + func DatumTypeSize(t *types.T) (size uintptr, isVarlen bool) + func DecimalToHLC(d *apd.Decimal) (hlc.Timestamp, error) + func ErrNameString(s string) string + func ErrNameStringP(s *string) string + func ErrString(n NodeFormatter) string + func ExprDebugString(expr Expr) string + func FoldComparisonExpr(op treecmp.ComparisonOperator, left, right Expr) (newOp treecmp.ComparisonOperator, newLeft Expr, newRight Expr, flipped bool, ...) + func ForEachCast(fn func(src, tgt oid.Oid)) + func FormatDate(d pgdate.Date, ctx *FmtCtx) + func FormatDuration(d duration.Duration, ctx *FmtCtx) + func GetCastCounter(from, to types.Family) telemetry.Counter + func GetEnumComponentsFromPhysicalRep(typ *types.T, rep []byte) ([]byte, string, error) + func GetJSONPath(j json.JSON, ary DArray) (json.JSON, error) + func GetParamsAndReturnType(impl overloadImpl) (TypeList, ReturnTyper) + func GetRenderColName(searchPath sessiondata.SearchPath, target SelectExpr) (string, error) + func GetStaticallyKnownType(ref ResolvableTypeReference) (typ *types.T, ok bool) + func GetTableType(isSequence bool, isView bool, isMaterialized bool) string + func HasReturningClause(clause ReturningClause) bool + func InferTypes(vals []string) []types.Family + func IsConst(evalCtx *EvalContext, expr TypedExpr) bool + func IsFollowerReadTimestampFunction(asOf AsOfClause, searchPath sessiondata.SearchPath) bool + func IsReferenceSerialType(ref ResolvableTypeReference) bool + func LikeEscape(pattern string) (string, error) + func LimitDecimalWidth(d *apd.Decimal, precision, scale int) error + func MakeParseError(s string, typ *types.T, err error) error + func MaxDistinctCount(evalCtx *EvalContext, first, last Datum) (_ int64, ok bool) + func MockNameTypes(types map[string]*types.T) func() + func MustBeStaticallyKnownType(ref ResolvableTypeReference) *types.T + func NameString(s string) string + func NameStringP(s *string) string + func NewAggInAggError() error + func NewCannotMixBitArraySizesError(op string) error + func NewContextDependentOpsNotAllowedError(context string) error + func NewInvalidFunctionUsageError(class FunctionClass, context string) error + func NewInvalidNestedSRFError(context string) error + func NewTypeIsNotCompositeError(resolvedType *types.T) error + func ParseBool(s string) (bool, error) + func ParseHLC(s string) (hlc.Timestamp, error) + func ParsePath(str string) []string + func PgwireFormatBool(d bool) byte + func PopulateRecordWithJSON(ctx *EvalContext, j json.JSON, desiredType *types.T, tup *DTuple) error + func Pretty(stmt NodeFormatter) string + func ProcessPlaceholderAnnotations(semaCtx *SemaContext, stmt Statement, typeHints PlaceholderTypes) error + func ResolveBlankPaddedChar(s string, t *types.T) string + func ResolveType(ctx context.Context, ref ResolvableTypeReference, ...) (*types.T, error) + func Serialize(n NodeFormatter) string + func SerializeForDisplay(n NodeFormatter) string + func SimilarEscape(pattern string) string + func StmtDebugString(stmt Statement) string + func TimeFamilyPrecisionToRoundDuration(precision int32) time.Duration + func TimestampToDecimal(ts hlc.Timestamp) apd.Decimal + func ValidCast(src, tgt *types.T, ctx CastContext) bool + func WalkExprConst(v Visitor, expr Expr) + type AbbreviatedGrant struct + Grantees RoleSpecList + Privileges privilege.List + Target AlterDefaultPrivilegesTargetObject + WithGrantOption bool + func (n *AbbreviatedGrant) Format(ctx *FmtCtx) + type AbbreviatedRevoke struct + GrantOptionFor bool + Grantees RoleSpecList + Privileges privilege.List + Target AlterDefaultPrivilegesTargetObject + func (n *AbbreviatedRevoke) Format(ctx *FmtCtx) + type AggType int + const GeneralAgg + const OrderedSetAgg + type AggregateFunc interface + Add func(_ context.Context, firstArg Datum, otherArgs ...Datum) error + Close func(context.Context) + Reset func(context.Context) + Result func() (Datum, error) + Size func() int64 + type AliasClause struct + Alias Name + Cols NameList + func (a *AliasClause) Format(ctx *FmtCtx) + type AliasedTableExpr struct + As AliasClause + Expr TableExpr + IndexFlags *IndexFlags + Lateral bool + Ordinality bool + func (expr *AliasedTableExpr) WalkTableExpr(v Visitor) TableExpr + func (node *AliasedTableExpr) Format(ctx *FmtCtx) + func (node *AliasedTableExpr) String() string + type AllColumnsSelector struct + TableName *UnresolvedObjectName + func (*AllColumnsSelector) ResolvedType() *types.T + func (a *AllColumnsSelector) Format(ctx *FmtCtx) + func (a *AllColumnsSelector) NormalizeVarName() (VarName, error) + func (a *AllColumnsSelector) String() string + func (a *AllColumnsSelector) Variable() + func (expr *AllColumnsSelector) Eval(ctx *EvalContext) (Datum, error) + func (expr *AllColumnsSelector) TypeCheck(_ context.Context, _ *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *AllColumnsSelector) Walk(_ Visitor) Expr + type AllTablesSelector struct + func (at *AllTablesSelector) Format(ctx *FmtCtx) + func (at *AllTablesSelector) NormalizeTablePattern() (TablePattern, error) + func (at *AllTablesSelector) String() string + type AlterBackup struct + Backup Expr + Cmds AlterBackupCmds + Subdir Expr + func (*AlterBackup) StatementReturnType() StatementReturnType + func (*AlterBackup) StatementTag() string + func (*AlterBackup) StatementType() StatementType + func (n *AlterBackup) String() string + func (node *AlterBackup) Format(ctx *FmtCtx) + type AlterBackupCmd interface + type AlterBackupCmds []AlterBackupCmd + func (node *AlterBackupCmds) Format(ctx *FmtCtx) + type AlterBackupKMS struct + KMSInfo BackupKMS + func (node *AlterBackupKMS) Format(ctx *FmtCtx) + type AlterChangefeed struct + Cmds AlterChangefeedCmds + Jobs Expr + func (*AlterChangefeed) StatementReturnType() StatementReturnType + func (*AlterChangefeed) StatementTag() string + func (*AlterChangefeed) StatementType() StatementType + func (n *AlterChangefeed) String() string + func (node *AlterChangefeed) Format(ctx *FmtCtx) + type AlterChangefeedAddTarget struct + Options KVOptions + Targets ChangefeedTargets + func (node *AlterChangefeedAddTarget) Format(ctx *FmtCtx) + type AlterChangefeedCmd interface + type AlterChangefeedCmds []AlterChangefeedCmd + func (n *AlterChangefeedCmds) String() string + func (node *AlterChangefeedCmds) Format(ctx *FmtCtx) + type AlterChangefeedDropTarget struct + Targets ChangefeedTargets + func (node *AlterChangefeedDropTarget) Format(ctx *FmtCtx) + type AlterChangefeedSetOptions struct + Options KVOptions + func (node *AlterChangefeedSetOptions) Format(ctx *FmtCtx) + type AlterChangefeedUnsetOptions struct + Options NameList + func (node *AlterChangefeedUnsetOptions) Format(ctx *FmtCtx) + type AlterDatabaseAddRegion struct + IfNotExists bool + Name Name + Region Name + func (*AlterDatabaseAddRegion) StatementReturnType() StatementReturnType + func (*AlterDatabaseAddRegion) StatementTag() string + func (*AlterDatabaseAddRegion) StatementType() StatementType + func (n *AlterDatabaseAddRegion) String() string + func (node *AlterDatabaseAddRegion) Format(ctx *FmtCtx) + type AlterDatabaseAddSuperRegion struct + DatabaseName Name + Regions []Name + SuperRegionName Name + func (*AlterDatabaseAddSuperRegion) StatementReturnType() StatementReturnType + func (*AlterDatabaseAddSuperRegion) StatementTag() string + func (*AlterDatabaseAddSuperRegion) StatementType() StatementType + func (n *AlterDatabaseAddSuperRegion) String() string + func (node *AlterDatabaseAddSuperRegion) Format(ctx *FmtCtx) + type AlterDatabaseDropRegion struct + IfExists bool + Name Name + Region Name + func (*AlterDatabaseDropRegion) StatementReturnType() StatementReturnType + func (*AlterDatabaseDropRegion) StatementTag() string + func (*AlterDatabaseDropRegion) StatementType() StatementType + func (n *AlterDatabaseDropRegion) String() string + func (node *AlterDatabaseDropRegion) Format(ctx *FmtCtx) + type AlterDatabaseDropSuperRegion struct + DatabaseName Name + SuperRegionName Name + func (*AlterDatabaseDropSuperRegion) StatementReturnType() StatementReturnType + func (*AlterDatabaseDropSuperRegion) StatementTag() string + func (*AlterDatabaseDropSuperRegion) StatementType() StatementType + func (n *AlterDatabaseDropSuperRegion) String() string + func (node *AlterDatabaseDropSuperRegion) Format(ctx *FmtCtx) + type AlterDatabaseOwner struct + Name Name + Owner RoleSpec + func (*AlterDatabaseOwner) StatementReturnType() StatementReturnType + func (*AlterDatabaseOwner) StatementTag() string + func (*AlterDatabaseOwner) StatementType() StatementType + func (n *AlterDatabaseOwner) String() string + func (node *AlterDatabaseOwner) Format(ctx *FmtCtx) + type AlterDatabasePlacement struct + Name Name + Placement DataPlacement + func (*AlterDatabasePlacement) StatementReturnType() StatementReturnType + func (*AlterDatabasePlacement) StatementTag() string + func (*AlterDatabasePlacement) StatementType() StatementType + func (n *AlterDatabasePlacement) String() string + func (node *AlterDatabasePlacement) Format(ctx *FmtCtx) + type AlterDatabasePrimaryRegion struct + Name Name + PrimaryRegion Name + func (*AlterDatabasePrimaryRegion) StatementReturnType() StatementReturnType + func (*AlterDatabasePrimaryRegion) StatementTag() string + func (*AlterDatabasePrimaryRegion) StatementType() StatementType + func (n *AlterDatabasePrimaryRegion) String() string + func (node *AlterDatabasePrimaryRegion) Format(ctx *FmtCtx) + type AlterDatabaseSurvivalGoal struct + Name Name + SurvivalGoal SurvivalGoal + func (*AlterDatabaseSurvivalGoal) StatementReturnType() StatementReturnType + func (*AlterDatabaseSurvivalGoal) StatementTag() string + func (*AlterDatabaseSurvivalGoal) StatementType() StatementType + func (n *AlterDatabaseSurvivalGoal) String() string + func (node *AlterDatabaseSurvivalGoal) Format(ctx *FmtCtx) + type AlterDefaultPrivileges struct + Database *Name + ForAllRoles bool + Grant AbbreviatedGrant + IsGrant bool + Revoke AbbreviatedRevoke + Roles RoleSpecList + Schemas ObjectNamePrefixList + func (*AlterDefaultPrivileges) StatementReturnType() StatementReturnType + func (*AlterDefaultPrivileges) StatementTag() string + func (*AlterDefaultPrivileges) StatementType() StatementType + func (n *AlterDefaultPrivileges) Format(ctx *FmtCtx) + func (n *AlterDefaultPrivileges) String() string + type AlterDefaultPrivilegesTargetObject uint32 + const Schemas + const Sequences + const Tables + const Types + func GetAlterDefaultPrivilegesTargetObjects() []AlterDefaultPrivilegesTargetObject + func (t AlterDefaultPrivilegesTargetObject) String() string + func (t AlterDefaultPrivilegesTargetObject) ToPrivilegeObjectType() privilege.ObjectType + type AlterIndex struct + Cmds AlterIndexCmds + IfExists bool + Index TableIndexName + func (*AlterIndex) StatementReturnType() StatementReturnType + func (*AlterIndex) StatementTag() string + func (*AlterIndex) StatementType() StatementType + func (n *AlterIndex) String() string + func (node *AlterIndex) Format(ctx *FmtCtx) + type AlterIndexCmd interface + type AlterIndexCmds []AlterIndexCmd + func (node *AlterIndexCmds) Format(ctx *FmtCtx) + type AlterIndexPartitionBy struct + func (node *AlterIndexPartitionBy) Format(ctx *FmtCtx) + type AlterRole struct + IfExists bool + IsRole bool + KVOptions KVOptions + Name RoleSpec + func (*AlterRole) StatementReturnType() StatementReturnType + func (*AlterRole) StatementTag() string + func (*AlterRole) StatementType() StatementType + func (n *AlterRole) String() string + func (node *AlterRole) Format(ctx *FmtCtx) + type AlterRoleSet struct + AllRoles bool + DatabaseName Name + IfExists bool + IsRole bool + RoleName RoleSpec + SetOrReset *SetVar + func (*AlterRoleSet) StatementReturnType() StatementReturnType + func (*AlterRoleSet) StatementTag() string + func (*AlterRoleSet) StatementType() StatementType + func (n *AlterRoleSet) String() string + func (node *AlterRoleSet) Format(ctx *FmtCtx) + type AlterSchema struct + Cmd AlterSchemaCmd + Schema ObjectNamePrefix + func (*AlterSchema) StatementReturnType() StatementReturnType + func (*AlterSchema) StatementTag() string + func (*AlterSchema) StatementType() StatementType + func (n *AlterSchema) String() string + func (node *AlterSchema) Format(ctx *FmtCtx) + type AlterSchemaCmd interface + type AlterSchemaOwner struct + Owner RoleSpec + func (node *AlterSchemaOwner) Format(ctx *FmtCtx) + type AlterSchemaRename struct + NewName Name + func (node *AlterSchemaRename) Format(ctx *FmtCtx) + type AlterSequence struct + IfExists bool + Name *UnresolvedObjectName + Options SequenceOptions + func (*AlterSequence) StatementReturnType() StatementReturnType + func (*AlterSequence) StatementTag() string + func (*AlterSequence) StatementType() StatementType + func (n *AlterSequence) String() string + func (node *AlterSequence) Format(ctx *FmtCtx) + type AlterTable struct + Cmds AlterTableCmds + IfExists bool + Table *UnresolvedObjectName + func (*AlterTable) StatementReturnType() StatementReturnType + func (*AlterTable) StatementTag() string + func (*AlterTable) StatementType() StatementType + func (n *AlterTable) String() string + func (node *AlterTable) Format(ctx *FmtCtx) + func (node *AlterTable) HoistAddColumnConstraints() + type AlterTableAddColumn struct + ColumnDef *ColumnTableDef + IfNotExists bool + func (n *AlterTableAddColumn) String() string + func (node *AlterTableAddColumn) Format(ctx *FmtCtx) + func (node *AlterTableAddColumn) TelemetryCounter() telemetry.Counter + type AlterTableAddConstraint struct + ConstraintDef ConstraintTableDef + ValidationBehavior ValidationBehavior + func (n *AlterTableAddConstraint) String() string + func (node *AlterTableAddConstraint) Format(ctx *FmtCtx) + func (node *AlterTableAddConstraint) TelemetryCounter() telemetry.Counter + type AlterTableAlterColumnType struct + Collation string + Column Name + ToType ResolvableTypeReference + Using Expr + func (n *AlterTableAlterColumnType) String() string + func (node *AlterTableAlterColumnType) Format(ctx *FmtCtx) + func (node *AlterTableAlterColumnType) GetColumn() Name + func (node *AlterTableAlterColumnType) TelemetryCounter() telemetry.Counter + type AlterTableAlterPrimaryKey struct + Columns IndexElemList + Name Name + Sharded *ShardedIndexDef + StorageParams StorageParams + func (node *AlterTableAlterPrimaryKey) Format(ctx *FmtCtx) + func (node *AlterTableAlterPrimaryKey) TelemetryCounter() telemetry.Counter + type AlterTableCmd interface + TelemetryCounter func() telemetry.Counter + type AlterTableCmds []AlterTableCmd + func (n *AlterTableCmds) String() string + func (node *AlterTableCmds) Format(ctx *FmtCtx) + type AlterTableDropColumn struct + Column Name + DropBehavior DropBehavior + IfExists bool + func (n *AlterTableDropColumn) String() string + func (node *AlterTableDropColumn) Format(ctx *FmtCtx) + func (node *AlterTableDropColumn) TelemetryCounter() telemetry.Counter + type AlterTableDropConstraint struct + Constraint Name + DropBehavior DropBehavior + IfExists bool + func (n *AlterTableDropConstraint) String() string + func (node *AlterTableDropConstraint) Format(ctx *FmtCtx) + func (node *AlterTableDropConstraint) TelemetryCounter() telemetry.Counter + type AlterTableDropNotNull struct + Column Name + func (n *AlterTableDropNotNull) String() string + func (node *AlterTableDropNotNull) Format(ctx *FmtCtx) + func (node *AlterTableDropNotNull) GetColumn() Name + func (node *AlterTableDropNotNull) TelemetryCounter() telemetry.Counter + type AlterTableDropStored struct + Column Name + func (n *AlterTableDropStored) String() string + func (node *AlterTableDropStored) Format(ctx *FmtCtx) + func (node *AlterTableDropStored) GetColumn() Name + func (node *AlterTableDropStored) TelemetryCounter() telemetry.Counter + type AlterTableInjectStats struct + Stats Expr + func (node *AlterTableInjectStats) Format(ctx *FmtCtx) + func (node *AlterTableInjectStats) TelemetryCounter() telemetry.Counter + type AlterTableLocality struct + IfExists bool + Locality *Locality + Name *UnresolvedObjectName + func (*AlterTableLocality) StatementReturnType() StatementReturnType + func (*AlterTableLocality) StatementTag() string + func (*AlterTableLocality) StatementType() StatementType + func (n *AlterTableLocality) String() string + func (node *AlterTableLocality) Format(ctx *FmtCtx) + type AlterTableOwner struct + IfExists bool + IsMaterialized bool + IsSequence bool + IsView bool + Name *UnresolvedObjectName + Owner RoleSpec + func (*AlterTableOwner) StatementReturnType() StatementReturnType + func (*AlterTableOwner) StatementTag() string + func (*AlterTableOwner) StatementType() StatementType + func (n *AlterTableOwner) String() string + func (node *AlterTableOwner) Format(ctx *FmtCtx) + func (node *AlterTableOwner) TelemetryCounter() telemetry.Counter + type AlterTablePartitionByTable struct + func (node *AlterTablePartitionByTable) Format(ctx *FmtCtx) + func (node *AlterTablePartitionByTable) TelemetryCounter() telemetry.Counter + type AlterTableRenameColumn struct + Column Name + NewName Name + func (node *AlterTableRenameColumn) Format(ctx *FmtCtx) + func (node *AlterTableRenameColumn) TelemetryCounter() telemetry.Counter + type AlterTableRenameConstraint struct + Constraint Name + NewName Name + func (node *AlterTableRenameConstraint) Format(ctx *FmtCtx) + func (node *AlterTableRenameConstraint) TelemetryCounter() telemetry.Counter + type AlterTableResetStorageParams struct + Params NameList + func (node *AlterTableResetStorageParams) Format(ctx *FmtCtx) + func (node *AlterTableResetStorageParams) TelemetryCounter() telemetry.Counter + type AlterTableSetAudit struct + Mode AuditMode + func (node *AlterTableSetAudit) Format(ctx *FmtCtx) + func (node *AlterTableSetAudit) TelemetryCounter() telemetry.Counter + type AlterTableSetDefault struct + Column Name + Default Expr + func (n *AlterTableSetDefault) String() string + func (node *AlterTableSetDefault) Format(ctx *FmtCtx) + func (node *AlterTableSetDefault) GetColumn() Name + func (node *AlterTableSetDefault) TelemetryCounter() telemetry.Counter + type AlterTableSetNotNull struct + Column Name + func (n *AlterTableSetNotNull) String() string + func (node *AlterTableSetNotNull) Format(ctx *FmtCtx) + func (node *AlterTableSetNotNull) GetColumn() Name + func (node *AlterTableSetNotNull) TelemetryCounter() telemetry.Counter + type AlterTableSetOnUpdate struct + Column Name + Expr Expr + func (node *AlterTableSetOnUpdate) Format(ctx *FmtCtx) + func (node *AlterTableSetOnUpdate) GetColumn() Name + func (node *AlterTableSetOnUpdate) TelemetryCounter() telemetry.Counter + type AlterTableSetSchema struct + IfExists bool + IsMaterialized bool + IsSequence bool + IsView bool + Name *UnresolvedObjectName + Schema Name + func (*AlterTableSetSchema) StatementReturnType() StatementReturnType + func (*AlterTableSetSchema) StatementTag() string + func (*AlterTableSetSchema) StatementType() StatementType + func (n *AlterTableSetSchema) String() string + func (node *AlterTableSetSchema) Format(ctx *FmtCtx) + func (node *AlterTableSetSchema) TelemetryCounter() telemetry.Counter + type AlterTableSetStorageParams struct + StorageParams StorageParams + func (node *AlterTableSetStorageParams) Format(ctx *FmtCtx) + func (node *AlterTableSetStorageParams) TelemetryCounter() telemetry.Counter + type AlterTableSetVisible struct + Column Name + Visible bool + func (n *AlterTableSetVisible) String() string + func (node *AlterTableSetVisible) Format(ctx *FmtCtx) + func (node *AlterTableSetVisible) GetColumn() Name + func (node *AlterTableSetVisible) TelemetryCounter() telemetry.Counter + type AlterTableValidateConstraint struct + Constraint Name + func (node *AlterTableValidateConstraint) Format(ctx *FmtCtx) + func (node *AlterTableValidateConstraint) TelemetryCounter() telemetry.Counter + type AlterTenantSetClusterSetting struct + TenantAll bool + TenantID Expr + func (*AlterTenantSetClusterSetting) StatementReturnType() StatementReturnType + func (*AlterTenantSetClusterSetting) StatementTag() string + func (*AlterTenantSetClusterSetting) StatementType() StatementType + func (n *AlterTenantSetClusterSetting) Format(ctx *FmtCtx) + func (n *AlterTenantSetClusterSetting) String() string + type AlterType struct + Cmd AlterTypeCmd + Type *UnresolvedObjectName + func (*AlterType) StatementReturnType() StatementReturnType + func (*AlterType) StatementTag() string + func (*AlterType) StatementType() StatementType + func (n *AlterType) String() string + func (node *AlterType) Format(ctx *FmtCtx) + type AlterTypeAddValue struct + IfNotExists bool + NewVal EnumValue + Placement *AlterTypeAddValuePlacement + func (node *AlterTypeAddValue) Format(ctx *FmtCtx) + func (node *AlterTypeAddValue) TelemetryCounter() telemetry.Counter + type AlterTypeAddValuePlacement struct + Before bool + ExistingVal EnumValue + type AlterTypeCmd interface + TelemetryCounter func() telemetry.Counter + type AlterTypeDropValue struct + Val EnumValue + func (node *AlterTypeDropValue) Format(ctx *FmtCtx) + func (node *AlterTypeDropValue) TelemetryCounter() telemetry.Counter + type AlterTypeOwner struct + Owner RoleSpec + func (node *AlterTypeOwner) Format(ctx *FmtCtx) + func (node *AlterTypeOwner) TelemetryCounter() telemetry.Counter + type AlterTypeRename struct + NewName Name + func (node *AlterTypeRename) Format(ctx *FmtCtx) + func (node *AlterTypeRename) TelemetryCounter() telemetry.Counter + type AlterTypeRenameValue struct + NewVal EnumValue + OldVal EnumValue + func (node *AlterTypeRenameValue) Format(ctx *FmtCtx) + func (node *AlterTypeRenameValue) TelemetryCounter() telemetry.Counter + type AlterTypeSetSchema struct + Schema Name + func (node *AlterTypeSetSchema) Format(ctx *FmtCtx) + func (node *AlterTypeSetSchema) TelemetryCounter() telemetry.Counter + type Analyze struct + Table TableExpr + func (*Analyze) StatementReturnType() StatementReturnType + func (*Analyze) StatementTag() string + func (*Analyze) StatementType() StatementType + func (n *Analyze) String() string + func (node *Analyze) Format(ctx *FmtCtx) + type AndExpr struct + Left Expr + Right Expr + func NewTypedAndExpr(left, right TypedExpr) *AndExpr + func (expr *AndExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *AndExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *AndExpr) Walk(v Visitor) Expr + func (node *AndExpr) Format(ctx *FmtCtx) + func (node *AndExpr) String() string + func (node *AndExpr) TypedLeft() TypedExpr + func (node *AndExpr) TypedRight() TypedExpr + func (ta AndExpr) ResolvedType() *types.T + type AnnotateTypeExpr struct + Expr Expr + SyntaxMode annotateSyntaxMode + Type ResolvableTypeReference + func (expr *AnnotateTypeExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *AnnotateTypeExpr) Walk(v Visitor) Expr + func (node *AnnotateTypeExpr) Format(ctx *FmtCtx) + func (node *AnnotateTypeExpr) String() string + func (node *AnnotateTypeExpr) TypedInnerExpr() TypedExpr + type AnnotatedNode struct + AnnIdx AnnotationIdx + func (n AnnotatedNode) GetAnnotation(ann *Annotations) interface{} + func (n AnnotatedNode) SetAnnotation(ann *Annotations, annotation interface{}) + type AnnotationIdx int32 + const NoAnnotation + type Annotations []interface + func (a *Annotations) Get(idx AnnotationIdx) interface{} + func (a *Annotations) Set(idx AnnotationIdx, annotation interface{}) + func MakeAnnotations(numAnnotations AnnotationIdx) Annotations + type ArgTypes []struct + func (a ArgTypes) GetAt(i int) *types.T + func (a ArgTypes) Length() int + func (a ArgTypes) Match(types []*types.T) bool + func (a ArgTypes) MatchAt(typ *types.T, i int) bool + func (a ArgTypes) MatchLen(l int) bool + func (a ArgTypes) String() string + func (a ArgTypes) Types() []*types.T + type Array struct + Exprs Exprs + func NewTypedArray(typedExprs TypedExprs, typ *types.T) *Array + func (expr *Array) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *Array) Walk(v Visitor) Expr + func (node *Array) Format(ctx *FmtCtx) + func (node *Array) String() string + func (t *Array) Eval(ctx *EvalContext) (Datum, error) + func (ta Array) ResolvedType() *types.T + type ArrayFlatten struct + Subquery Expr + func NewTypedArrayFlattenExpr(input Expr) *ArrayFlatten + func (expr *ArrayFlatten) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *ArrayFlatten) Walk(v Visitor) Expr + func (node *ArrayFlatten) Format(ctx *FmtCtx) + func (node *ArrayFlatten) String() string + func (t *ArrayFlatten) Eval(ctx *EvalContext) (Datum, error) + func (ta ArrayFlatten) ResolvedType() *types.T + type ArraySubscript struct + Begin Expr + End Expr + Slice bool + func (a *ArraySubscript) Format(ctx *FmtCtx) + type ArraySubscripts []*ArraySubscript + func (a *ArraySubscripts) Format(ctx *FmtCtx) + type ArrayTypeReference struct + ElementType ResolvableTypeReference + func (node *ArrayTypeReference) Format(ctx *FmtCtx) + func (node *ArrayTypeReference) SQLString() string + type AsOfClause struct + Expr Expr + func (a *AsOfClause) Format(ctx *FmtCtx) + type AsOfSystemTime struct + BoundedStaleness bool + MaxTimestampBound hlc.Timestamp + NearestOnly bool + Timestamp hlc.Timestamp + func EvalAsOfTimestamp(ctx context.Context, asOf AsOfClause, semaCtx *SemaContext, ...) (AsOfSystemTime, error) + type AuditMode int + const AuditModeDisable + const AuditModeReadWrite + func (m AuditMode) String() string + func (m AuditMode) TelemetryName() string + type Backup struct + AppendToLatest bool + AsOf AsOfClause + IncrementalFrom Exprs + Nested bool + Options BackupOptions + Subdir Expr + Targets *TargetList + To StringOrPlaceholderOptList + func (*Backup) StatementReturnType() StatementReturnType + func (*Backup) StatementTag() string + func (*Backup) StatementType() StatementType + func (n *Backup) String() string + func (node *Backup) Format(ctx *FmtCtx) + func (node Backup) Coverage() DescriptorCoverage + type BackupDetails int + const BackupDefaultDetails + const BackupFileDetails + const BackupManifestAsJSON + const BackupRangeDetails + type BackupKMS struct + NewKMSURI StringOrPlaceholderOptList + OldKMSURI StringOrPlaceholderOptList + type BackupOptions struct + CaptureRevisionHistory bool + Detached bool + EncryptionKMSURI StringOrPlaceholderOptList + EncryptionPassphrase Expr + IncrementalStorage StringOrPlaceholderOptList + func (o *BackupOptions) CombineWith(other *BackupOptions) error + func (o *BackupOptions) Format(ctx *FmtCtx) + func (o BackupOptions) IsDefault() bool + type BeginTransaction struct + Modes TransactionModes + func (*BeginTransaction) StatementReturnType() StatementReturnType + func (*BeginTransaction) StatementTag() string + func (*BeginTransaction) StatementType() StatementType + func (n *BeginTransaction) String() string + func (node *BeginTransaction) Format(ctx *FmtCtx) + type BinOp struct + Fn TwoArgFn + LeftType *types.T + NullableArgs bool + PreferredOverload bool + ReturnType *types.T + RightType *types.T + Volatility Volatility + type BinaryExpr struct + Fn *BinOp + Left Expr + Operator treebin.BinaryOperator + Right Expr + func NewTypedBinaryExpr(op treebin.BinaryOperator, left, right TypedExpr, typ *types.T) *BinaryExpr + func (expr *BinaryExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *BinaryExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *BinaryExpr) Walk(v Visitor) Expr + func (node *BinaryExpr) Format(ctx *FmtCtx) + func (node *BinaryExpr) ResolvedBinOp() *BinOp + func (node *BinaryExpr) String() string + func (node *BinaryExpr) TypedLeft() TypedExpr + func (node *BinaryExpr) TypedRight() TypedExpr + func (ta BinaryExpr) ResolvedType() *types.T + type CCLOnlyStatement interface + type CTE struct + Mtr MaterializeClause + Name AliasClause + Stmt Statement + type CallbackValueGenerator struct + func NewCallbackValueGenerator(cb func(ctx context.Context, prev int, txn *kv.Txn) (int, error)) *CallbackValueGenerator + func (c *CallbackValueGenerator) Close(_ context.Context) + func (c *CallbackValueGenerator) Next(ctx context.Context) (bool, error) + func (c *CallbackValueGenerator) ResolvedType() *types.T + func (c *CallbackValueGenerator) Start(_ context.Context, txn *kv.Txn) error + func (c *CallbackValueGenerator) Values() (Datums, error) + type CancelQueries struct + IfExists bool + Queries *Select + func (*CancelQueries) StatementReturnType() StatementReturnType + func (*CancelQueries) StatementTag() string + func (*CancelQueries) StatementType() StatementType + func (n *CancelQueries) String() string + func (node *CancelQueries) Format(ctx *FmtCtx) + type CancelSessions struct + IfExists bool + Sessions *Select + func (*CancelSessions) StatementReturnType() StatementReturnType + func (*CancelSessions) StatementTag() string + func (*CancelSessions) StatementType() StatementType + func (n *CancelSessions) String() string + func (node *CancelSessions) Format(ctx *FmtCtx) + type CannedOptPlan struct + Plan string + func (*CannedOptPlan) StatementReturnType() StatementReturnType + func (*CannedOptPlan) StatementTag() string + func (*CannedOptPlan) StatementType() StatementType + func (n *CannedOptPlan) String() string + func (node *CannedOptPlan) Format(ctx *FmtCtx) + type CaseExpr struct + Else Expr + Expr Expr + Whens []*When + func NewTypedCaseExpr(expr TypedExpr, whens []*When, elseStmt TypedExpr, typ *types.T) (*CaseExpr, error) + func (expr *CaseExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *CaseExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *CaseExpr) Walk(v Visitor) Expr + func (node *CaseExpr) Format(ctx *FmtCtx) + func (node *CaseExpr) String() string + func (ta CaseExpr) ResolvedType() *types.T + type CaseMode int + const LowerCase + const UpperCase + type CastContext uint8 + const CastContextAssignment + const CastContextExplicit + const CastContextImplicit + func (cc CastContext) String() string + type CastExpr struct + Expr Expr + SyntaxMode castSyntaxMode + Type ResolvableTypeReference + func NewTypedCastExpr(expr TypedExpr, typ *types.T) *CastExpr + func (expr *CastExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *CastExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *CastExpr) Walk(v Visitor) Expr + func (node *CastExpr) Format(ctx *FmtCtx) + func (node *CastExpr) String() string + func (ta CastExpr) ResolvedType() *types.T + type ChangefeedTarget struct + FamilyName Name + TableName TablePattern + func (ct *ChangefeedTarget) Format(ctx *FmtCtx) + type ChangefeedTargets []ChangefeedTarget + func (cts *ChangefeedTargets) Format(ctx *FmtCtx) + type CheckConstraintTableDef struct + Expr Expr + Hidden bool + IfNotExists bool + Name Name + func (node *CheckConstraintTableDef) Format(ctx *FmtCtx) + func (node *CheckConstraintTableDef) SetIfNotExists() + func (node *CheckConstraintTableDef) SetName(name Name) + type ClientNoticeSender interface + BufferClientNotice func(ctx context.Context, notice pgnotice.Notice) + type CloseCursor struct + All bool + Name Name + func (*CloseCursor) StatementReturnType() StatementReturnType + func (*CloseCursor) StatementTag() string + func (*CloseCursor) StatementType() StatementType + func (c CloseCursor) Format(ctx *FmtCtx) + func (n *CloseCursor) String() string + type CmpOp struct + Fn TwoArgFn + LeftType *types.T + NullableArgs bool + PreferredOverload bool + RightType *types.T + Volatility Volatility + type CoalesceExpr struct + Exprs Exprs + Name string + func NewTypedCoalesceExpr(typedExprs TypedExprs, typ *types.T) *CoalesceExpr + func (expr *CoalesceExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *CoalesceExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *CoalesceExpr) Walk(v Visitor) Expr + func (node *CoalesceExpr) Format(ctx *FmtCtx) + func (node *CoalesceExpr) String() string + func (node *CoalesceExpr) TypedExprAt(idx int) TypedExpr + func (ta CoalesceExpr) ResolvedType() *types.T + type CollateExpr struct + Expr Expr + Locale string + func NewTypedCollateExpr(expr TypedExpr, locale string) *CollateExpr + func (expr *CollateExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *CollateExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *CollateExpr) Walk(v Visitor) Expr + func (node *CollateExpr) Format(ctx *FmtCtx) + func (node *CollateExpr) String() string + func (ta CollateExpr) ResolvedType() *types.T + type CollationEnvironment struct + type ColumnAccessExpr struct + ByIndex bool + ColIndex int + ColName Name + Expr Expr + func NewTypedColumnAccessExpr(expr TypedExpr, colName Name, colIdx int) *ColumnAccessExpr + func (expr *ColumnAccessExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *ColumnAccessExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *ColumnAccessExpr) Walk(v Visitor) Expr + func (node *ColumnAccessExpr) Format(ctx *FmtCtx) + func (node *ColumnAccessExpr) String() string + func (ta ColumnAccessExpr) ResolvedType() *types.T + type ColumnCheckConstraint struct + Expr Expr + type ColumnCollation string + type ColumnComputedDef struct + Expr Expr + Virtual bool + type ColumnDefault struct + Expr Expr + type ColumnFKConstraint struct + Actions ReferenceActions + Col Name + Match CompositeKeyMatchMethod + Table TableName + type ColumnFamilyConstraint struct + Create bool + Family Name + IfNotExists bool + type ColumnID = catid.ColumnID + type ColumnItem struct + ColumnName Name + TableName *UnresolvedObjectName + func MakeColumnItem(tn *TableName, colName Name) ColumnItem + func NewColumnItem(tn *TableName, colName Name) *ColumnItem + func (c *ColumnItem) Column() string + func (c *ColumnItem) Format(ctx *FmtCtx) + func (c *ColumnItem) NormalizeVarName() (VarName, error) + func (c *ColumnItem) ResolvedType() *types.T + func (c *ColumnItem) String() string + func (c *ColumnItem) Variable() + func (expr *ColumnItem) Eval(ctx *EvalContext) (Datum, error) + func (expr *ColumnItem) TypeCheck(_ context.Context, _ *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *ColumnItem) Walk(_ Visitor) Expr + type ColumnMutationCmd interface + GetColumn func() Name + type ColumnOnUpdate struct + Expr Expr + type ColumnQualification interface + type ColumnTableDef struct + CheckExprs []ColumnTableDefCheckExpr + Computed struct{ ... } + DefaultExpr struct{ ... } + Family struct{ ... } + GeneratedIdentity struct{ ... } + Hidden bool + IsSerial bool + Name Name + Nullable struct{ ... } + OnUpdateExpr struct{ ... } + PrimaryKey struct{ ... } + References struct{ ... } + Type ResolvableTypeReference + Unique struct{ ... } + func NewColumnTableDef(name Name, typRef ResolvableTypeReference, isSerial bool, ...) (*ColumnTableDef, error) + func (node *ColumnTableDef) Format(ctx *FmtCtx) + func (node *ColumnTableDef) HasColumnFamily() bool + func (node *ColumnTableDef) HasDefaultExpr() bool + func (node *ColumnTableDef) HasFKConstraint() bool + func (node *ColumnTableDef) HasOnUpdateExpr() bool + func (node *ColumnTableDef) IsComputed() bool + func (node *ColumnTableDef) IsVirtual() bool + func (node *ColumnTableDef) String() string + type ColumnTableDefCheckExpr struct + ConstraintName Name + Expr Expr + type CommentOnColumn struct + Comment *string + func (*CommentOnColumn) StatementReturnType() StatementReturnType + func (*CommentOnColumn) StatementTag() string + func (*CommentOnColumn) StatementType() StatementType + func (n *CommentOnColumn) Format(ctx *FmtCtx) + func (n *CommentOnColumn) String() string + type CommentOnConstraint struct + Comment *string + Constraint Name + Table *UnresolvedObjectName + func (*CommentOnConstraint) StatementReturnType() StatementReturnType + func (*CommentOnConstraint) StatementTag() string + func (*CommentOnConstraint) StatementType() StatementType + func (n *CommentOnConstraint) Format(ctx *FmtCtx) + func (n *CommentOnConstraint) String() string + type CommentOnDatabase struct + Comment *string + Name Name + func (*CommentOnDatabase) StatementReturnType() StatementReturnType + func (*CommentOnDatabase) StatementTag() string + func (*CommentOnDatabase) StatementType() StatementType + func (n *CommentOnDatabase) Format(ctx *FmtCtx) + func (n *CommentOnDatabase) String() string + type CommentOnIndex struct + Comment *string + Index TableIndexName + func (*CommentOnIndex) StatementReturnType() StatementReturnType + func (*CommentOnIndex) StatementTag() string + func (*CommentOnIndex) StatementType() StatementType + func (n *CommentOnIndex) Format(ctx *FmtCtx) + func (n *CommentOnIndex) String() string + type CommentOnSchema struct + Comment *string + Name Name + func (*CommentOnSchema) StatementReturnType() StatementReturnType + func (*CommentOnSchema) StatementTag() string + func (*CommentOnSchema) StatementType() StatementType + func (n *CommentOnSchema) Format(ctx *FmtCtx) + func (n *CommentOnSchema) String() string + type CommentOnTable struct + Comment *string + Table *UnresolvedObjectName + func (*CommentOnTable) StatementReturnType() StatementReturnType + func (*CommentOnTable) StatementTag() string + func (*CommentOnTable) StatementType() StatementType + func (n *CommentOnTable) Format(ctx *FmtCtx) + func (n *CommentOnTable) String() string + type CommitTransaction struct + func (*CommitTransaction) StatementReturnType() StatementReturnType + func (*CommitTransaction) StatementTag() string + func (*CommitTransaction) StatementType() StatementType + func (n *CommitTransaction) String() string + func (node *CommitTransaction) Format(ctx *FmtCtx) + type CommonLookupFlags struct + AvoidLeased bool + AvoidSynthetic bool + IncludeDropped bool + IncludeOffline bool + RequireMutable bool + Required bool + type CompactEngineSpanFunc func(ctx context.Context, nodeID, storeID int32, startKey, endKey []byte) error + type ComparisonExpr struct + Fn *CmpOp + Left Expr + Operator treecmp.ComparisonOperator + Right Expr + SubOperator treecmp.ComparisonOperator + func NewTypedComparisonExpr(op treecmp.ComparisonOperator, left, right TypedExpr) *ComparisonExpr + func NewTypedComparisonExprWithSubOp(op, subOp treecmp.ComparisonOperator, left, right TypedExpr) *ComparisonExpr + func (expr *ComparisonExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *ComparisonExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *ComparisonExpr) Walk(v Visitor) Expr + func (node *ComparisonExpr) Format(ctx *FmtCtx) + func (node *ComparisonExpr) String() string + func (node *ComparisonExpr) TypedLeft() TypedExpr + func (node *ComparisonExpr) TypedRight() TypedExpr + func (ta ComparisonExpr) ResolvedType() *types.T + type CompositeDatum interface + IsComposite func() bool + type CompositeKeyMatchMethod int + const MatchFull + const MatchPartial + const MatchSimple + func (c CompositeKeyMatchMethod) String() string + type Constant interface + AvailableTypes func() []*types.T + DesirableTypes func() []*types.T + ResolveAsType func(context.Context, *SemaContext, *types.T) (TypedExpr, error) + type ConstantEvalVisitor struct + func MakeConstantEvalVisitor(ctx *EvalContext) ConstantEvalVisitor + func (v *ConstantEvalVisitor) Err() error + func (v *ConstantEvalVisitor) VisitPost(expr Expr) Expr + func (v *ConstantEvalVisitor) VisitPre(expr Expr) (recurse bool, newExpr Expr) + type ConstraintTableDef interface + SetIfNotExists func() + SetName func(name Name) + type ControlJobs struct + Command JobCommand + Jobs *Select + Reason Expr + func (*ControlJobs) StatementReturnType() StatementReturnType + func (*ControlJobs) StatementType() StatementType + func (n *ControlJobs) Format(ctx *FmtCtx) + func (n *ControlJobs) StatementTag() string + func (n *ControlJobs) String() string + type ControlJobsForSchedules struct + Command JobCommand + Schedules *Select + func (*ControlJobsForSchedules) StatementReturnType() StatementReturnType + func (*ControlJobsForSchedules) StatementType() StatementType + func (n *ControlJobsForSchedules) Format(ctx *FmtCtx) + func (n *ControlJobsForSchedules) StatementTag() string + func (n *ControlJobsForSchedules) String() string + type ControlJobsOfType struct + Command JobCommand + Type string + func (*ControlJobsOfType) StatementReturnType() StatementReturnType + func (*ControlJobsOfType) StatementType() StatementType + func (n *ControlJobsOfType) Format(ctx *FmtCtx) + func (n *ControlJobsOfType) StatementTag() string + func (n *ControlJobsOfType) String() string + type ControlSchedules struct + Command ScheduleCommand + Schedules *Select + func (*ControlSchedules) StatementReturnType() StatementReturnType + func (*ControlSchedules) StatementType() StatementType + func (n *ControlSchedules) Format(ctx *FmtCtx) + func (n *ControlSchedules) StatementTag() string + func (n *ControlSchedules) String() string + type CopyFormat int + const CopyFormatBinary + const CopyFormatCSV + const CopyFormatText + type CopyFrom struct + Columns NameList + Options CopyOptions + Stdin bool + Table TableName + func (*CopyFrom) StatementReturnType() StatementReturnType + func (*CopyFrom) StatementTag() string + func (*CopyFrom) StatementType() StatementType + func (n *CopyFrom) String() string + func (node *CopyFrom) Format(ctx *FmtCtx) + type CopyOptions struct + CopyFormat CopyFormat + Delimiter Expr + Destination Expr + Null Expr + func (o *CopyOptions) CombineWith(other *CopyOptions) error + func (o *CopyOptions) Format(ctx *FmtCtx) + func (o CopyOptions) IsDefault() bool + type CreateChangefeed struct + Options KVOptions + SinkURI Expr + Targets ChangefeedTargets + func (*CreateChangefeed) StatementReturnType() StatementReturnType + func (*CreateChangefeed) StatementType() StatementType + func (n *CreateChangefeed) StatementTag() string + func (n *CreateChangefeed) String() string + func (node *CreateChangefeed) Format(ctx *FmtCtx) + type CreateDatabase struct + CType string + Collate string + ConnectionLimit int32 + Encoding string + IfNotExists bool + Name Name + Owner RoleSpec + Placement DataPlacement + PrimaryRegion Name + Regions NameList + SurvivalGoal SurvivalGoal + Template string + func (*CreateDatabase) StatementReturnType() StatementReturnType + func (*CreateDatabase) StatementTag() string + func (*CreateDatabase) StatementType() StatementType + func (n *CreateDatabase) String() string + func (node *CreateDatabase) Format(ctx *FmtCtx) + type CreateExtension struct + IfNotExists bool + Name string + func (*CreateExtension) StatementReturnType() StatementReturnType + func (*CreateExtension) StatementTag() string + func (*CreateExtension) StatementType() StatementType + func (n *CreateExtension) String() string + func (node *CreateExtension) Format(ctx *FmtCtx) + type CreateIndex struct + Columns IndexElemList + Concurrently bool + IfNotExists bool + Inverted bool + Name Name + PartitionByIndex *PartitionByIndex + Predicate Expr + Sharded *ShardedIndexDef + StorageParams StorageParams + Storing NameList + Table TableName + Unique bool + func (*CreateIndex) StatementReturnType() StatementReturnType + func (*CreateIndex) StatementTag() string + func (*CreateIndex) StatementType() StatementType + func (n *CreateIndex) String() string + func (node *CreateIndex) Format(ctx *FmtCtx) + type CreateRole struct + IfNotExists bool + IsRole bool + KVOptions KVOptions + Name RoleSpec + func (*CreateRole) StatementReturnType() StatementReturnType + func (*CreateRole) StatementTag() string + func (*CreateRole) StatementType() StatementType + func (n *CreateRole) String() string + func (node *CreateRole) Format(ctx *FmtCtx) + type CreateSchema struct + AuthRole RoleSpec + IfNotExists bool + Schema ObjectNamePrefix + func (*CreateSchema) StatementType() StatementType + func (n *CreateSchema) StatementReturnType() StatementReturnType + func (n *CreateSchema) StatementTag() string + func (n *CreateSchema) String() string + func (node *CreateSchema) Format(ctx *FmtCtx) + type CreateSequence struct + IfNotExists bool + Name TableName + Options SequenceOptions + Persistence Persistence + func (*CreateSequence) StatementReturnType() StatementReturnType + func (*CreateSequence) StatementTag() string + func (*CreateSequence) StatementType() StatementType + func (n *CreateSequence) String() string + func (node *CreateSequence) Format(ctx *FmtCtx) + type CreateStats struct + ColumnNames NameList + Name Name + Options CreateStatsOptions + Table TableExpr + func (*CreateStats) StatementReturnType() StatementReturnType + func (*CreateStats) StatementTag() string + func (*CreateStats) StatementType() StatementType + func (n *CreateStats) String() string + func (node *CreateStats) Format(ctx *FmtCtx) + type CreateStatsOptions struct + AsOf AsOfClause + Throttling float64 + func (o *CreateStatsOptions) CombineWith(other *CreateStatsOptions) error + func (o *CreateStatsOptions) Empty() bool + func (o *CreateStatsOptions) Format(ctx *FmtCtx) + type CreateTable struct + AsSource *Select + Defs TableDefs + IfNotExists bool + Locality *Locality + OnCommit CreateTableOnCommitSetting + PartitionByTable *PartitionByTable + Persistence Persistence + StorageParams StorageParams + Table TableName + func (*CreateTable) StatementType() StatementType + func (n *CreateTable) StatementReturnType() StatementReturnType + func (n *CreateTable) StatementTag() string + func (n *CreateTable) String() string + func (node *CreateTable) As() bool + func (node *CreateTable) AsHasUserSpecifiedPrimaryKey() bool + func (node *CreateTable) Format(ctx *FmtCtx) + func (node *CreateTable) FormatBody(ctx *FmtCtx) + func (node *CreateTable) HoistConstraints() + type CreateTableOnCommitSetting uint32 + const CreateTableOnCommitPreserveRows + const CreateTableOnCommitUnset + type CreateType struct + EnumLabels EnumValueList + IfNotExists bool + TypeName *UnresolvedObjectName + Variety CreateTypeVariety + func (*CreateType) StatementReturnType() StatementReturnType + func (*CreateType) StatementTag() string + func (*CreateType) StatementType() StatementType + func (node *CreateType) Format(ctx *FmtCtx) + func (node *CreateType) String() string + type CreateTypeVariety int + const Base + const Composite + const Domain + const Enum + const Range + const Shell + func (i CreateTypeVariety) String() string + type CreateView struct + AsSource *Select + ColumnNames NameList + IfNotExists bool + Materialized bool + Name TableName + Persistence Persistence + Replace bool + func (*CreateView) StatementReturnType() StatementReturnType + func (*CreateView) StatementTag() string + func (*CreateView) StatementType() StatementType + func (n *CreateView) String() string + func (node *CreateView) Format(ctx *FmtCtx) + type CursorScrollOption int8 + const NoScroll + const Scroll + const UnspecifiedScroll + func (o CursorScrollOption) String() string + type CursorSensitivity int + const Asensitive + const Insensitive + const UnspecifiedSensitivity + func (o CursorSensitivity) String() string + type CursorStmt struct + Count int64 + FetchType FetchType + Name Name + func (c CursorStmt) Format(ctx *FmtCtx) + type DArray struct + Array Datums + HasNonNulls bool + HasNulls bool + ParamTyp *types.T + func AsDArray(e Expr) (*DArray, bool) + func MustBeDArray(e Expr) *DArray + func NewDArray(paramTyp *types.T) *DArray + func ParseDArrayFromString(ctx ParseTimeContext, s string, t *types.T) (_ *DArray, dependsOnContext bool, _ error) + func (d *DArray) AmbiguousFormat() bool + func (d *DArray) Append(v Datum) error + func (d *DArray) Compare(ctx *EvalContext, other Datum) int + func (d *DArray) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DArray) FirstIndex() int + func (d *DArray) Format(ctx *FmtCtx) + func (d *DArray) IsComposite() bool + func (d *DArray) IsMax(_ *EvalContext) bool + func (d *DArray) IsMin(_ *EvalContext) bool + func (d *DArray) Len() int + func (d *DArray) Max(_ *EvalContext) (Datum, bool) + func (d *DArray) Min(_ *EvalContext) (Datum, bool) + func (d *DArray) Next(_ *EvalContext) (Datum, bool) + func (d *DArray) Prev(_ *EvalContext) (Datum, bool) + func (d *DArray) ResolvedType() *types.T + func (d *DArray) Size() uintptr + func (d *DArray) TypeCheck(_ context.Context, _ *SemaContext, desired *types.T) (TypedExpr, error) + func (d *DArray) Validate() error + func (expr *DArray) Walk(v Visitor) Expr + func (node *DArray) String() string + func (t *DArray) Eval(_ *EvalContext) (Datum, error) + type DBitArray struct + func AsDBitArray(e Expr) (*DBitArray, bool) + func MakeDBitArray(bitLen uint) DBitArray + func MustBeDBitArray(e Expr) *DBitArray + func NewDBitArray(bitLen uint) *DBitArray + func NewDBitArrayFromInt(i int64, width uint) (*DBitArray, error) + func ParseDBitArray(s string) (*DBitArray, error) + func (*DBitArray) AmbiguousFormat() bool + func (*DBitArray) ResolvedType() *types.T + func (d *DBitArray) AsDInt(n uint) *DInt + func (d *DBitArray) Compare(ctx *EvalContext, other Datum) int + func (d *DBitArray) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DBitArray) Format(ctx *FmtCtx) + func (d *DBitArray) IsMax(_ *EvalContext) bool + func (d *DBitArray) IsMin(_ *EvalContext) bool + func (d *DBitArray) Max(_ *EvalContext) (Datum, bool) + func (d *DBitArray) Min(_ *EvalContext) (Datum, bool) + func (d *DBitArray) Next(_ *EvalContext) (Datum, bool) + func (d *DBitArray) Prev(_ *EvalContext) (Datum, bool) + func (d *DBitArray) Size() uintptr + func (d *DBitArray) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DBitArray) Walk(_ Visitor) Expr + func (node *DBitArray) String() string + func (t *DBitArray) Eval(_ *EvalContext) (Datum, error) + type DBool bool + func ArrayContains(ctx *EvalContext, haystack *DArray, needles *DArray) (*DBool, error) + func AsDBool(e Expr) (DBool, bool) + func GetBool(d Datum) (DBool, error) + func JSONExistsAny(_ *EvalContext, json DJSON, dArray *DArray) (*DBool, error) + func MakeDBool(d DBool) *DBool + func MustBeDBool(e Expr) DBool + func ParseDBool(s string) (*DBool, error) + func (*DBool) AmbiguousFormat() bool + func (*DBool) Next(_ *EvalContext) (Datum, bool) + func (*DBool) Prev(_ *EvalContext) (Datum, bool) + func (*DBool) ResolvedType() *types.T + func (d *DBool) Compare(ctx *EvalContext, other Datum) int + func (d *DBool) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DBool) Format(ctx *FmtCtx) + func (d *DBool) IsMax(_ *EvalContext) bool + func (d *DBool) IsMin(_ *EvalContext) bool + func (d *DBool) Max(_ *EvalContext) (Datum, bool) + func (d *DBool) Min(_ *EvalContext) (Datum, bool) + func (d *DBool) Size() uintptr + func (d *DBool) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DBool) Walk(_ Visitor) Expr + func (node *DBool) String() string + func (t *DBool) Eval(_ *EvalContext) (Datum, error) + type DBox2D struct + func AsDBox2D(e Expr) (*DBox2D, bool) + func MustBeDBox2D(e Expr) *DBox2D + func NewDBox2D(b geo.CartesianBoundingBox) *DBox2D + func ParseDBox2D(str string) (*DBox2D, error) + func (*DBox2D) AmbiguousFormat() bool + func (*DBox2D) ResolvedType() *types.T + func (d *DBox2D) Compare(ctx *EvalContext, other Datum) int + func (d *DBox2D) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DBox2D) Format(ctx *FmtCtx) + func (d *DBox2D) IsMax(_ *EvalContext) bool + func (d *DBox2D) IsMin(_ *EvalContext) bool + func (d *DBox2D) Max(_ *EvalContext) (Datum, bool) + func (d *DBox2D) Min(_ *EvalContext) (Datum, bool) + func (d *DBox2D) Next(ctx *EvalContext) (Datum, bool) + func (d *DBox2D) Prev(ctx *EvalContext) (Datum, bool) + func (d *DBox2D) Size() uintptr + func (d *DBox2D) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DBox2D) Walk(_ Visitor) Expr + func (node *DBox2D) String() string + func (t *DBox2D) Eval(_ *EvalContext) (Datum, error) + type DBytes string + func AsDBytes(e Expr) (DBytes, bool) + func MustBeDBytes(e Expr) DBytes + func NewDBytes(d DBytes) *DBytes + func ParseDByte(s string) (*DBytes, error) + func (*DBytes) AmbiguousFormat() bool + func (*DBytes) IsMax(_ *EvalContext) bool + func (*DBytes) ResolvedType() *types.T + func (d *DBytes) Compare(ctx *EvalContext, other Datum) int + func (d *DBytes) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DBytes) Format(ctx *FmtCtx) + func (d *DBytes) IsMin(_ *EvalContext) bool + func (d *DBytes) Max(_ *EvalContext) (Datum, bool) + func (d *DBytes) Min(_ *EvalContext) (Datum, bool) + func (d *DBytes) Next(_ *EvalContext) (Datum, bool) + func (d *DBytes) Prev(_ *EvalContext) (Datum, bool) + func (d *DBytes) Size() uintptr + func (d *DBytes) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DBytes) Walk(_ Visitor) Expr + func (node *DBytes) String() string + func (t *DBytes) Eval(_ *EvalContext) (Datum, error) + type DCollatedString struct + Contents string + Key []byte + Locale string + func NewDCollatedString(contents string, locale string, env *CollationEnvironment) (*DCollatedString, error) + func (*DCollatedString) AmbiguousFormat() bool + func (*DCollatedString) IsMax(_ *EvalContext) bool + func (d *DCollatedString) Compare(ctx *EvalContext, other Datum) int + func (d *DCollatedString) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DCollatedString) Format(ctx *FmtCtx) + func (d *DCollatedString) IsComposite() bool + func (d *DCollatedString) IsMin(_ *EvalContext) bool + func (d *DCollatedString) Max(_ *EvalContext) (Datum, bool) + func (d *DCollatedString) Min(_ *EvalContext) (Datum, bool) + func (d *DCollatedString) Next(_ *EvalContext) (Datum, bool) + func (d *DCollatedString) Prev(_ *EvalContext) (Datum, bool) + func (d *DCollatedString) ResolvedType() *types.T + func (d *DCollatedString) Size() uintptr + func (d *DCollatedString) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DCollatedString) Walk(_ Visitor) Expr + func (node *DCollatedString) String() string + func (t *DCollatedString) Eval(_ *EvalContext) (Datum, error) + type DDate struct + func AsDDate(e Expr) (DDate, bool) + func MakeDDate(d pgdate.Date) DDate + func MustBeDDate(e Expr) DDate + func NewDDate(d pgdate.Date) *DDate + func NewDDateFromTime(t time.Time) (*DDate, error) + func ParseDDate(ctx ParseTimeContext, s string) (_ *DDate, dependsOnContext bool, _ error) + func (*DDate) AmbiguousFormat() bool + func (*DDate) ResolvedType() *types.T + func (d *DDate) Compare(ctx *EvalContext, other Datum) int + func (d *DDate) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DDate) Format(ctx *FmtCtx) + func (d *DDate) IsMax(_ *EvalContext) bool + func (d *DDate) IsMin(_ *EvalContext) bool + func (d *DDate) Max(_ *EvalContext) (Datum, bool) + func (d *DDate) Min(_ *EvalContext) (Datum, bool) + func (d *DDate) Next(_ *EvalContext) (Datum, bool) + func (d *DDate) Prev(_ *EvalContext) (Datum, bool) + func (d *DDate) Size() uintptr + func (d *DDate) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DDate) Walk(_ Visitor) Expr + func (node *DDate) String() string + func (t *DDate) Eval(_ *EvalContext) (Datum, error) + type DDecimal struct + var DecimalOne DDecimal + func DecimalCbrt(x *apd.Decimal) (*DDecimal, error) + func DecimalSqrt(x *apd.Decimal) (*DDecimal, error) + func MustBeDDecimal(e Expr) DDecimal + func ParseDDecimal(s string) (*DDecimal, error) + func TimestampToDecimalDatum(ts hlc.Timestamp) *DDecimal + func (*DDecimal) AmbiguousFormat() bool + func (*DDecimal) ResolvedType() *types.T + func (d *DDecimal) Compare(ctx *EvalContext, other Datum) int + func (d *DDecimal) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DDecimal) Format(ctx *FmtCtx) + func (d *DDecimal) IsComposite() bool + func (d *DDecimal) IsMax(_ *EvalContext) bool + func (d *DDecimal) IsMin(_ *EvalContext) bool + func (d *DDecimal) Max(_ *EvalContext) (Datum, bool) + func (d *DDecimal) Min(_ *EvalContext) (Datum, bool) + func (d *DDecimal) Next(_ *EvalContext) (Datum, bool) + func (d *DDecimal) Prev(_ *EvalContext) (Datum, bool) + func (d *DDecimal) SetString(s string) error + func (d *DDecimal) Size() uintptr + func (d *DDecimal) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DDecimal) Walk(_ Visitor) Expr + func (node *DDecimal) String() string + func (t *DDecimal) Eval(_ *EvalContext) (Datum, error) + type DEncodedKey string + func NewDEncodedKey(d DEncodedKey) *DEncodedKey + func (*DEncodedKey) AmbiguousFormat() bool + func (*DEncodedKey) IsMax(_ *EvalContext) bool + func (*DEncodedKey) ResolvedType() *types.T + func (d *DEncodedKey) Compare(ctx *EvalContext, other Datum) int + func (d *DEncodedKey) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DEncodedKey) Format(ctx *FmtCtx) + func (d *DEncodedKey) IsMin(_ *EvalContext) bool + func (d *DEncodedKey) Max(_ *EvalContext) (Datum, bool) + func (d *DEncodedKey) Min(_ *EvalContext) (Datum, bool) + func (d *DEncodedKey) Next(_ *EvalContext) (Datum, bool) + func (d *DEncodedKey) Prev(_ *EvalContext) (Datum, bool) + func (d *DEncodedKey) Size() uintptr + func (d *DEncodedKey) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DEncodedKey) Walk(_ Visitor) Expr + func (node *DEncodedKey) String() string + func (t *DEncodedKey) Eval(_ *EvalContext) (Datum, error) + type DEnum struct + EnumTyp *types.T + LogicalRep string + PhysicalRep []byte + func MakeDEnumFromLogicalRepresentation(typ *types.T, rep string) (*DEnum, error) + func MakeDEnumFromPhysicalRepresentation(typ *types.T, rep []byte) (*DEnum, error) + func (d *DEnum) AmbiguousFormat() bool + func (d *DEnum) Compare(ctx *EvalContext, other Datum) int + func (d *DEnum) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DEnum) Format(ctx *FmtCtx) + func (d *DEnum) IsMax(_ *EvalContext) bool + func (d *DEnum) IsMin(_ *EvalContext) bool + func (d *DEnum) Max(ctx *EvalContext) (Datum, bool) + func (d *DEnum) MaxWriteable() (Datum, bool) + func (d *DEnum) Min(ctx *EvalContext) (Datum, bool) + func (d *DEnum) MinWriteable() (Datum, bool) + func (d *DEnum) Next(ctx *EvalContext) (Datum, bool) + func (d *DEnum) Prev(ctx *EvalContext) (Datum, bool) + func (d *DEnum) ResolvedType() *types.T + func (d *DEnum) Size() uintptr + func (d *DEnum) String() string + func (d *DEnum) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DEnum) Walk(_ Visitor) Expr + func (t *DEnum) Eval(_ *EvalContext) (Datum, error) + type DFloat float64 + func Cbrt(x float64) (*DFloat, error) + func MustBeDFloat(e Expr) DFloat + func NewDFloat(d DFloat) *DFloat + func ParseDFloat(s string) (*DFloat, error) + func Sqrt(x float64) (*DFloat, error) + func (*DFloat) AmbiguousFormat() bool + func (*DFloat) ResolvedType() *types.T + func (d *DFloat) Compare(ctx *EvalContext, other Datum) int + func (d *DFloat) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DFloat) Format(ctx *FmtCtx) + func (d *DFloat) IsComposite() bool + func (d *DFloat) IsMax(_ *EvalContext) bool + func (d *DFloat) IsMin(_ *EvalContext) bool + func (d *DFloat) Max(_ *EvalContext) (Datum, bool) + func (d *DFloat) Min(_ *EvalContext) (Datum, bool) + func (d *DFloat) Next(_ *EvalContext) (Datum, bool) + func (d *DFloat) Prev(_ *EvalContext) (Datum, bool) + func (d *DFloat) Size() uintptr + func (d *DFloat) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DFloat) Walk(_ Visitor) Expr + func (node *DFloat) String() string + func (t *DFloat) Eval(_ *EvalContext) (Datum, error) + type DGeography struct + func AsDGeography(e Expr) (*DGeography, bool) + func MustBeDGeography(e Expr) *DGeography + func NewDGeography(g geo.Geography) *DGeography + func ParseDGeography(str string) (*DGeography, error) + func (*DGeography) AmbiguousFormat() bool + func (*DGeography) ResolvedType() *types.T + func (d *DGeography) Compare(ctx *EvalContext, other Datum) int + func (d *DGeography) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DGeography) Format(ctx *FmtCtx) + func (d *DGeography) IsMax(_ *EvalContext) bool + func (d *DGeography) IsMin(_ *EvalContext) bool + func (d *DGeography) Max(_ *EvalContext) (Datum, bool) + func (d *DGeography) Min(_ *EvalContext) (Datum, bool) + func (d *DGeography) Next(ctx *EvalContext) (Datum, bool) + func (d *DGeography) Prev(ctx *EvalContext) (Datum, bool) + func (d *DGeography) Size() uintptr + func (d *DGeography) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DGeography) Walk(_ Visitor) Expr + func (node *DGeography) String() string + func (t *DGeography) Eval(_ *EvalContext) (Datum, error) + type DGeometry struct + func AsDGeometry(e Expr) (*DGeometry, bool) + func MustBeDGeometry(e Expr) *DGeometry + func NewDGeometry(g geo.Geometry) *DGeometry + func ParseDGeometry(str string) (*DGeometry, error) + func (*DGeometry) AmbiguousFormat() bool + func (*DGeometry) ResolvedType() *types.T + func (d *DGeometry) Compare(ctx *EvalContext, other Datum) int + func (d *DGeometry) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DGeometry) Format(ctx *FmtCtx) + func (d *DGeometry) IsMax(_ *EvalContext) bool + func (d *DGeometry) IsMin(_ *EvalContext) bool + func (d *DGeometry) Max(_ *EvalContext) (Datum, bool) + func (d *DGeometry) Min(_ *EvalContext) (Datum, bool) + func (d *DGeometry) Next(ctx *EvalContext) (Datum, bool) + func (d *DGeometry) Prev(ctx *EvalContext) (Datum, bool) + func (d *DGeometry) Size() uintptr + func (d *DGeometry) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DGeometry) Walk(_ Visitor) Expr + func (node *DGeometry) String() string + func (t *DGeometry) Eval(_ *EvalContext) (Datum, error) + type DIPAddr struct + func AsDIPAddr(e Expr) (DIPAddr, bool) + func MustBeDIPAddr(e Expr) DIPAddr + func NewDIPAddr(d DIPAddr) *DIPAddr + func ParseDIPAddrFromINetString(s string) (*DIPAddr, error) + func (*DIPAddr) AmbiguousFormat() bool + func (*DIPAddr) Max(_ *EvalContext) (Datum, bool) + func (*DIPAddr) Min(_ *EvalContext) (Datum, bool) + func (*DIPAddr) ResolvedType() *types.T + func (d *DIPAddr) Compare(ctx *EvalContext, other Datum) int + func (d *DIPAddr) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DIPAddr) Format(ctx *FmtCtx) + func (d *DIPAddr) IsMax(_ *EvalContext) bool + func (d *DIPAddr) IsMin(_ *EvalContext) bool + func (d *DIPAddr) Next(_ *EvalContext) (Datum, bool) + func (d *DIPAddr) Prev(_ *EvalContext) (Datum, bool) + func (d *DIPAddr) Size() uintptr + func (d *DIPAddr) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DIPAddr) Walk(_ Visitor) Expr + func (node *DIPAddr) String() string + func (t *DIPAddr) Eval(_ *EvalContext) (Datum, error) + type DInt int64 + func AsDInt(e Expr) (DInt, bool) + func IntPow(x, y DInt) (*DInt, error) + func MustBeDInt(e Expr) DInt + func NewDInt(d DInt) *DInt + func ParseDInt(s string) (*DInt, error) + func (*DInt) AmbiguousFormat() bool + func (*DInt) ResolvedType() *types.T + func (d *DInt) Compare(ctx *EvalContext, other Datum) int + func (d *DInt) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DInt) Format(ctx *FmtCtx) + func (d *DInt) IsMax(_ *EvalContext) bool + func (d *DInt) IsMin(_ *EvalContext) bool + func (d *DInt) Max(_ *EvalContext) (Datum, bool) + func (d *DInt) Min(_ *EvalContext) (Datum, bool) + func (d *DInt) Next(_ *EvalContext) (Datum, bool) + func (d *DInt) Prev(_ *EvalContext) (Datum, bool) + func (d *DInt) Size() uintptr + func (d *DInt) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DInt) Walk(_ Visitor) Expr + func (node *DInt) String() string + func (t *DInt) Eval(_ *EvalContext) (Datum, error) + type DInterval struct + func MustBeDInterval(e Expr) *DInterval + func NewDInterval(d duration.Duration, itm types.IntervalTypeMetadata) *DInterval + func ParseDInterval(style duration.IntervalStyle, s string) (*DInterval, error) + func ParseDIntervalWithTypeMetadata(style duration.IntervalStyle, s string, itm types.IntervalTypeMetadata) (*DInterval, error) + func (*DInterval) AmbiguousFormat() bool + func (*DInterval) ResolvedType() *types.T + func (d *DInterval) Compare(ctx *EvalContext, other Datum) int + func (d *DInterval) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DInterval) Format(ctx *FmtCtx) + func (d *DInterval) IsMax(_ *EvalContext) bool + func (d *DInterval) IsMin(_ *EvalContext) bool + func (d *DInterval) Max(_ *EvalContext) (Datum, bool) + func (d *DInterval) Min(_ *EvalContext) (Datum, bool) + func (d *DInterval) Next(_ *EvalContext) (Datum, bool) + func (d *DInterval) Prev(_ *EvalContext) (Datum, bool) + func (d *DInterval) Size() uintptr + func (d *DInterval) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (d *DInterval) ValueAsISO8601String() string + func (expr *DInterval) Walk(_ Visitor) Expr + func (node *DInterval) String() string + func (t *DInterval) Eval(_ *EvalContext) (Datum, error) + type DJSON struct + func AsDJSON(e Expr) (*DJSON, bool) + func MustBeDJSON(e Expr) DJSON + func NewDJSON(j json.JSON) *DJSON + func (*DJSON) AmbiguousFormat() bool + func (*DJSON) ResolvedType() *types.T + func (d *DJSON) Compare(ctx *EvalContext, other Datum) int + func (d *DJSON) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DJSON) Format(ctx *FmtCtx) + func (d *DJSON) IsMax(_ *EvalContext) bool + func (d *DJSON) IsMin(_ *EvalContext) bool + func (d *DJSON) Max(_ *EvalContext) (Datum, bool) + func (d *DJSON) Min(_ *EvalContext) (Datum, bool) + func (d *DJSON) Next(_ *EvalContext) (Datum, bool) + func (d *DJSON) Prev(_ *EvalContext) (Datum, bool) + func (d *DJSON) Size() uintptr + func (d *DJSON) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DJSON) Walk(_ Visitor) Expr + func (node *DJSON) String() string + func (t *DJSON) Eval(_ *EvalContext) (Datum, error) + type DOid struct + func AsDOid(e Expr) (*DOid, bool) + func MakeDOid(d DInt) DOid + func MustBeDOid(e Expr) *DOid + func NewDOid(d DInt) *DOid + func NewDOidWithName(d DInt, typ *types.T, name string) *DOid + func ParseDOid(ctx *EvalContext, s string, t *types.T) (*DOid, error) + func (*DOid) AmbiguousFormat() bool + func (d *DOid) AsRegProc(name string) *DOid + func (d *DOid) Compare(ctx *EvalContext, other Datum) int + func (d *DOid) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DOid) Format(ctx *FmtCtx) + func (d *DOid) IsMax(ctx *EvalContext) bool + func (d *DOid) IsMin(ctx *EvalContext) bool + func (d *DOid) Max(ctx *EvalContext) (Datum, bool) + func (d *DOid) Min(ctx *EvalContext) (Datum, bool) + func (d *DOid) Next(ctx *EvalContext) (Datum, bool) + func (d *DOid) Prev(ctx *EvalContext) (Datum, bool) + func (d *DOid) ResolvedType() *types.T + func (d *DOid) Size() uintptr + func (d *DOid) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DOid) Walk(_ Visitor) Expr + func (node *DOid) String() string + func (t *DOid) Eval(_ *EvalContext) (Datum, error) + type DOidWrapper struct + Oid oid.Oid + Wrapped Datum + func (d *DOidWrapper) AmbiguousFormat() bool + func (d *DOidWrapper) Compare(ctx *EvalContext, other Datum) int + func (d *DOidWrapper) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DOidWrapper) Format(ctx *FmtCtx) + func (d *DOidWrapper) IsMax(ctx *EvalContext) bool + func (d *DOidWrapper) IsMin(ctx *EvalContext) bool + func (d *DOidWrapper) Max(ctx *EvalContext) (Datum, bool) + func (d *DOidWrapper) Min(ctx *EvalContext) (Datum, bool) + func (d *DOidWrapper) Next(ctx *EvalContext) (Datum, bool) + func (d *DOidWrapper) Prev(ctx *EvalContext) (Datum, bool) + func (d *DOidWrapper) ResolvedType() *types.T + func (d *DOidWrapper) Size() uintptr + func (d *DOidWrapper) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DOidWrapper) Walk(_ Visitor) Expr + func (node *DOidWrapper) String() string + func (t *DOidWrapper) Eval(_ *EvalContext) (Datum, error) + type DString string + func AsDString(e Expr) (DString, bool) + func MustBeDString(e Expr) DString + func NewDString(d string) *DString + func (*DString) AmbiguousFormat() bool + func (*DString) IsMax(_ *EvalContext) bool + func (*DString) ResolvedType() *types.T + func (d *DString) Compare(ctx *EvalContext, other Datum) int + func (d *DString) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DString) Format(ctx *FmtCtx) + func (d *DString) IsMin(_ *EvalContext) bool + func (d *DString) Max(_ *EvalContext) (Datum, bool) + func (d *DString) Min(_ *EvalContext) (Datum, bool) + func (d *DString) Next(_ *EvalContext) (Datum, bool) + func (d *DString) Prev(_ *EvalContext) (Datum, bool) + func (d *DString) Size() uintptr + func (d *DString) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DString) Walk(_ Visitor) Expr + func (node *DString) String() string + func (t *DString) Eval(_ *EvalContext) (Datum, error) + type DTime timeofday.TimeOfDay + func MakeDTime(t timeofday.TimeOfDay) *DTime + func ParseDTime(ctx ParseTimeContext, s string, precision time.Duration) (_ *DTime, dependsOnContext bool, _ error) + func (*DTime) AmbiguousFormat() bool + func (*DTime) ResolvedType() *types.T + func (d *DTime) Compare(ctx *EvalContext, other Datum) int + func (d *DTime) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DTime) Format(ctx *FmtCtx) + func (d *DTime) IsMax(_ *EvalContext) bool + func (d *DTime) IsMin(_ *EvalContext) bool + func (d *DTime) Max(_ *EvalContext) (Datum, bool) + func (d *DTime) Min(_ *EvalContext) (Datum, bool) + func (d *DTime) Next(ctx *EvalContext) (Datum, bool) + func (d *DTime) Prev(ctx *EvalContext) (Datum, bool) + func (d *DTime) Round(precision time.Duration) *DTime + func (d *DTime) Size() uintptr + func (d *DTime) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DTime) Walk(_ Visitor) Expr + func (node *DTime) String() string + func (t *DTime) Eval(_ *EvalContext) (Datum, error) + type DTimeTZ struct + func NewDTimeTZ(t timetz.TimeTZ) *DTimeTZ + func NewDTimeTZFromLocation(t timeofday.TimeOfDay, loc *time.Location) *DTimeTZ + func NewDTimeTZFromOffset(t timeofday.TimeOfDay, offsetSecs int32) *DTimeTZ + func NewDTimeTZFromTime(t time.Time) *DTimeTZ + func ParseDTimeTZ(ctx ParseTimeContext, s string, precision time.Duration) (_ *DTimeTZ, dependsOnContext bool, _ error) + func (*DTimeTZ) AmbiguousFormat() bool + func (*DTimeTZ) ResolvedType() *types.T + func (d *DTimeTZ) Compare(ctx *EvalContext, other Datum) int + func (d *DTimeTZ) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DTimeTZ) Format(ctx *FmtCtx) + func (d *DTimeTZ) IsMax(_ *EvalContext) bool + func (d *DTimeTZ) IsMin(_ *EvalContext) bool + func (d *DTimeTZ) Max(_ *EvalContext) (Datum, bool) + func (d *DTimeTZ) Min(_ *EvalContext) (Datum, bool) + func (d *DTimeTZ) Next(ctx *EvalContext) (Datum, bool) + func (d *DTimeTZ) Prev(ctx *EvalContext) (Datum, bool) + func (d *DTimeTZ) Round(precision time.Duration) *DTimeTZ + func (d *DTimeTZ) Size() uintptr + func (d *DTimeTZ) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DTimeTZ) Walk(_ Visitor) Expr + func (node *DTimeTZ) String() string + func (t *DTimeTZ) Eval(_ *EvalContext) (Datum, error) + type DTimestamp struct + func AsDTimestamp(e Expr) (DTimestamp, bool) + func DecimalToInexactDTimestamp(d *DDecimal) (*DTimestamp, error) + func MakeDTimestamp(t time.Time, precision time.Duration) (*DTimestamp, error) + func MustBeDTimestamp(e Expr) DTimestamp + func MustMakeDTimestamp(t time.Time, precision time.Duration) *DTimestamp + func ParseDTimestamp(ctx ParseTimeContext, s string, precision time.Duration) (_ *DTimestamp, dependsOnContext bool, _ error) + func TimestampToInexactDTimestamp(ts hlc.Timestamp) *DTimestamp + func (*DTimestamp) AmbiguousFormat() bool + func (*DTimestamp) ResolvedType() *types.T + func (d *DTimestamp) Compare(ctx *EvalContext, other Datum) int + func (d *DTimestamp) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DTimestamp) Format(ctx *FmtCtx) + func (d *DTimestamp) IsMax(_ *EvalContext) bool + func (d *DTimestamp) IsMin(_ *EvalContext) bool + func (d *DTimestamp) Max(_ *EvalContext) (Datum, bool) + func (d *DTimestamp) Min(_ *EvalContext) (Datum, bool) + func (d *DTimestamp) Next(ctx *EvalContext) (Datum, bool) + func (d *DTimestamp) Prev(ctx *EvalContext) (Datum, bool) + func (d *DTimestamp) Round(precision time.Duration) (*DTimestamp, error) + func (d *DTimestamp) Size() uintptr + func (d *DTimestamp) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DTimestamp) Walk(_ Visitor) Expr + func (node *DTimestamp) String() string + func (t *DTimestamp) Eval(_ *EvalContext) (Datum, error) + type DTimestampTZ struct + func AsDTimestampTZ(e Expr) (DTimestampTZ, bool) + func DecimalToInexactDTimestampTZ(d *DDecimal) (*DTimestampTZ, error) + func MakeDTimestampTZ(t time.Time, precision time.Duration) (*DTimestampTZ, error) + func MakeDTimestampTZFromDate(loc *time.Location, d *DDate) (*DTimestampTZ, error) + func MustBeDTimestampTZ(e Expr) DTimestampTZ + func MustMakeDTimestampTZ(t time.Time, precision time.Duration) *DTimestampTZ + func ParseDTimestampTZ(ctx ParseTimeContext, s string, precision time.Duration) (_ *DTimestampTZ, dependsOnContext bool, _ error) + func (*DTimestampTZ) AmbiguousFormat() bool + func (*DTimestampTZ) ResolvedType() *types.T + func (d *DTimestampTZ) Compare(ctx *EvalContext, other Datum) int + func (d *DTimestampTZ) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DTimestampTZ) EvalAtTimeZone(ctx *EvalContext, loc *time.Location) (*DTimestamp, error) + func (d *DTimestampTZ) Format(ctx *FmtCtx) + func (d *DTimestampTZ) IsMax(_ *EvalContext) bool + func (d *DTimestampTZ) IsMin(_ *EvalContext) bool + func (d *DTimestampTZ) Max(_ *EvalContext) (Datum, bool) + func (d *DTimestampTZ) Min(_ *EvalContext) (Datum, bool) + func (d *DTimestampTZ) Next(ctx *EvalContext) (Datum, bool) + func (d *DTimestampTZ) Prev(ctx *EvalContext) (Datum, bool) + func (d *DTimestampTZ) Round(precision time.Duration) (*DTimestampTZ, error) + func (d *DTimestampTZ) Size() uintptr + func (d *DTimestampTZ) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DTimestampTZ) Walk(_ Visitor) Expr + func (node *DTimestampTZ) String() string + func (t *DTimestampTZ) Eval(_ *EvalContext) (Datum, error) + type DTuple struct + D Datums + func AsDTuple(e Expr) (*DTuple, bool) + func MakeDTuple(typ *types.T, d ...Datum) DTuple + func MustBeDTuple(e Expr) *DTuple + func NewDTuple(typ *types.T, d ...Datum) *DTuple + func NewDTupleWithLen(typ *types.T, l int) *DTuple + func ParseDTupleFromString(ctx ParseTimeContext, s string, t *types.T) (_ *DTuple, dependsOnContext bool, _ error) + func (*DTuple) AmbiguousFormat() bool + func (d *DTuple) AssertSorted() + func (d *DTuple) Compare(ctx *EvalContext, other Datum) int + func (d *DTuple) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DTuple) ContainsNull() bool + func (d *DTuple) Format(ctx *FmtCtx) + func (d *DTuple) IsMax(ctx *EvalContext) bool + func (d *DTuple) IsMin(ctx *EvalContext) bool + func (d *DTuple) Max(ctx *EvalContext) (Datum, bool) + func (d *DTuple) Min(ctx *EvalContext) (Datum, bool) + func (d *DTuple) Next(ctx *EvalContext) (Datum, bool) + func (d *DTuple) Normalize(ctx *EvalContext) + func (d *DTuple) Prev(ctx *EvalContext) (Datum, bool) + func (d *DTuple) ResolvedType() *types.T + func (d *DTuple) SearchSorted(ctx *EvalContext, target Datum) (int, bool) + func (d *DTuple) SetSorted() *DTuple + func (d *DTuple) Size() uintptr + func (d *DTuple) Sorted() bool + func (d *DTuple) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DTuple) Walk(v Visitor) Expr + func (node *DTuple) String() string + func (t *DTuple) Eval(_ *EvalContext) (Datum, error) + type DUuid struct + func NewDUuid(d DUuid) *DUuid + func ParseDUuidFromBytes(b []byte) (*DUuid, error) + func ParseDUuidFromString(s string) (*DUuid, error) + func (*DUuid) AmbiguousFormat() bool + func (*DUuid) Max(_ *EvalContext) (Datum, bool) + func (*DUuid) Min(_ *EvalContext) (Datum, bool) + func (*DUuid) ResolvedType() *types.T + func (d *DUuid) Compare(ctx *EvalContext, other Datum) int + func (d *DUuid) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DUuid) Format(ctx *FmtCtx) + func (d *DUuid) IsMax(_ *EvalContext) bool + func (d *DUuid) IsMin(_ *EvalContext) bool + func (d *DUuid) Next(_ *EvalContext) (Datum, bool) + func (d *DUuid) Prev(_ *EvalContext) (Datum, bool) + func (d *DUuid) Size() uintptr + func (d *DUuid) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DUuid) Walk(_ Visitor) Expr + func (node *DUuid) String() string + func (t *DUuid) Eval(_ *EvalContext) (Datum, error) + type DVoid struct + func (*DVoid) AmbiguousFormat() bool + func (*DVoid) ResolvedType() *types.T + func (d *DVoid) Compare(ctx *EvalContext, other Datum) int + func (d *DVoid) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *DVoid) Format(ctx *FmtCtx) + func (d *DVoid) IsMax(_ *EvalContext) bool + func (d *DVoid) IsMin(_ *EvalContext) bool + func (d *DVoid) Max(_ *EvalContext) (Datum, bool) + func (d *DVoid) Min(_ *EvalContext) (Datum, bool) + func (d *DVoid) Next(ctx *EvalContext) (Datum, bool) + func (d *DVoid) Prev(ctx *EvalContext) (Datum, bool) + func (d *DVoid) Size() uintptr + func (d *DVoid) TypeCheck(_ context.Context, _ *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *DVoid) Walk(_ Visitor) Expr + func (node *DVoid) String() string + func (t *DVoid) Eval(_ *EvalContext) (Datum, error) + type DataPlacement uint32 + const DataPlacementDefault + const DataPlacementRestricted + const DataPlacementUnspecified + func (node *DataPlacement) Format(ctx *FmtCtx) + func (node *DataPlacement) TelemetryName() string + type DatabaseListFlags struct + ExplicitPrefix bool + type DatabaseLookupFlags = CommonLookupFlags + type DatabaseRegionConfig interface + IsValidRegionNameString func(r string) bool + PrimaryRegionString func() string + type Datum interface + AmbiguousFormat func() bool + Compare func(ctx *EvalContext, other Datum) int + CompareError func(ctx *EvalContext, other Datum) (int, error) + IsMax func(ctx *EvalContext) bool + IsMin func(ctx *EvalContext) bool + Max func(ctx *EvalContext) (Datum, bool) + Min func(ctx *EvalContext) (Datum, bool) + Next func(ctx *EvalContext) (Datum, bool) + Prev func(ctx *EvalContext) (Datum, bool) + Size func() uintptr + func AdjustValueToType(typ *types.T, inVal Datum) (outVal Datum, err error) + func AppendToMaybeNullArray(typ *types.T, left Datum, right Datum) (Datum, error) + func ConcatArrays(typ *types.T, left Datum, right Datum) (Datum, error) + func EvalComparisonExprWithSubOperator(ctx *EvalContext, expr *ComparisonExpr, left, right Datum) (Datum, error) + func MakeAllDEnumsInType(typ *types.T) []Datum + func MakeDJSON(d interface{}) (Datum, error) + func MatchLikeEscape(ctx *EvalContext, unescaped, pattern, escape string, caseInsensitive bool) (Datum, error) + func NewDIntVectorFromDArray(d *DArray) Datum + func NewDName(d string) Datum + func NewDNameFromDString(d *DString) Datum + func NewDOidVectorFromDArray(d *DArray) Datum + func NewDefaultDatum(evalCtx *EvalContext, t *types.T) (d Datum, err error) + func ParseAndRequireString(t *types.T, s string, ctx ParseTimeContext) (d Datum, dependsOnContext bool, err error) + func ParseDJSON(s string) (Datum, error) + func ParseDatumPath(evalCtx *EvalContext, str string, typs []types.Family) []Datum + func PerformAssignmentCast(ctx *EvalContext, d Datum, t *types.T) (Datum, error) + func PerformCast(ctx *EvalContext, d Datum, t *types.T) (Datum, error) + func PickFromTuple(ctx *EvalContext, greatest bool, args Datums) (Datum, error) + func PopulateDatumWithJSON(ctx *EvalContext, j json.JSON, desiredType *types.T) (Datum, error) + func PrependToMaybeNullArray(typ *types.T, left Datum, right Datum) (Datum, error) + func SampleDatum(t *types.T) Datum + func SimilarPattern(pattern, escape string) (Datum, error) + func SimilarToEscape(ctx *EvalContext, unescaped, pattern, escape string) (Datum, error) + func UnwrapDatum(evalCtx *EvalContext, d Datum) Datum + type DatumAlloc struct + AllocSize int + func (a *DatumAlloc) DoneInitNewDGeo(so *geopb.SpatialObject) + func (a *DatumAlloc) NewDBitArray(v DBitArray) *DBitArray + func (a *DatumAlloc) NewDBox2D(v DBox2D) *DBox2D + func (a *DatumAlloc) NewDBytes(v DBytes) *DBytes + func (a *DatumAlloc) NewDCollatedString(contents string, locale string) (*DCollatedString, error) + func (a *DatumAlloc) NewDDate(v DDate) *DDate + func (a *DatumAlloc) NewDDecimal(v DDecimal) *DDecimal + func (a *DatumAlloc) NewDEncodedKey(v DEncodedKey) *DEncodedKey + func (a *DatumAlloc) NewDEnum(v DEnum) *DEnum + func (a *DatumAlloc) NewDFloat(v DFloat) *DFloat + func (a *DatumAlloc) NewDGeography(v DGeography) *DGeography + func (a *DatumAlloc) NewDGeographyEmpty() *DGeography + func (a *DatumAlloc) NewDGeometry(v DGeometry) *DGeometry + func (a *DatumAlloc) NewDGeometryEmpty() *DGeometry + func (a *DatumAlloc) NewDIPAddr(v DIPAddr) *DIPAddr + func (a *DatumAlloc) NewDInt(v DInt) *DInt + func (a *DatumAlloc) NewDInterval(v DInterval) *DInterval + func (a *DatumAlloc) NewDJSON(v DJSON) *DJSON + func (a *DatumAlloc) NewDName(v DString) Datum + func (a *DatumAlloc) NewDOid(v DOid) Datum + func (a *DatumAlloc) NewDString(v DString) *DString + func (a *DatumAlloc) NewDTime(v DTime) *DTime + func (a *DatumAlloc) NewDTimeTZ(v DTimeTZ) *DTimeTZ + func (a *DatumAlloc) NewDTimestamp(v DTimestamp) *DTimestamp + func (a *DatumAlloc) NewDTimestampTZ(v DTimestampTZ) *DTimestampTZ + func (a *DatumAlloc) NewDTuple(v DTuple) *DTuple + func (a *DatumAlloc) NewDUuid(v DUuid) *DUuid + func (a *DatumAlloc) NewDVoid() *DVoid + func (a *DatumAlloc) NewDatums(num int) Datums + type Datums []Datum + func (d *Datums) Format(ctx *FmtCtx) + func (d Datums) Compare(evalCtx *EvalContext, other Datums) int + func (d Datums) IsDistinctFrom(evalCtx *EvalContext, other Datums) bool + func (d Datums) Len() int + func (node *Datums) String() string + type Deallocate struct + Name Name + func (*Deallocate) StatementReturnType() StatementReturnType + func (*Deallocate) StatementType() StatementType + func (n *Deallocate) StatementTag() string + func (n *Deallocate) String() string + func (node *Deallocate) Format(ctx *FmtCtx) + type DeclareCursor struct + Binary bool + Hold bool + Name Name + Scroll CursorScrollOption + Select *Select + Sensitivity CursorSensitivity + func (*DeclareCursor) StatementTag() string + func (*DeclareCursor) StatementType() StatementType + func (n *DeclareCursor) StatementReturnType() StatementReturnType + func (n *DeclareCursor) String() string + func (node *DeclareCursor) Format(ctx *FmtCtx) + type DefaultVal struct + func (DefaultVal) ResolvedType() *types.T + func (expr DefaultVal) Eval(ctx *EvalContext) (Datum, error) + func (expr DefaultVal) TypeCheck(_ context.Context, _ *SemaContext, desired *types.T) (TypedExpr, error) + func (expr DefaultVal) Walk(_ Visitor) Expr + func (node DefaultVal) Format(ctx *FmtCtx) + func (node DefaultVal) String() string + type DeferrableMode int + const Deferrable + const NotDeferrable + const UnspecifiedDeferrableMode + func (d DeferrableMode) String() string + type Delete struct + Limit *Limit + OrderBy OrderBy + Returning ReturningClause + Table TableExpr + Where *Where + With *With + func (*Delete) StatementTag() string + func (*Delete) StatementType() StatementType + func (n *Delete) StatementReturnType() StatementReturnType + func (n *Delete) String() string + func (node *Delete) Format(ctx *FmtCtx) + type DescriptorCoverage int32 + const AllDescriptors + const RequestedDescriptors + type DesiredObjectKind int + const TableObject + const TypeObject + type Direction int8 + const Ascending + const DefaultDirection + const Descending + func (d Direction) String() string + type Discard struct + Mode DiscardMode + func (*Discard) StatementReturnType() StatementReturnType + func (*Discard) StatementTag() string + func (*Discard) StatementType() StatementType + func (node *Discard) Format(ctx *FmtCtx) + func (node *Discard) String() string + type DiscardMode int + const DiscardModeAll + type DistinctOn []Expr + func (node *DistinctOn) Format(ctx *FmtCtx) + type DropBehavior int + const DropCascade + const DropDefault + const DropRestrict + func (d DropBehavior) String() string + type DropDatabase struct + DropBehavior DropBehavior + IfExists bool + Name Name + func (*DropDatabase) StatementReturnType() StatementReturnType + func (*DropDatabase) StatementTag() string + func (*DropDatabase) StatementType() StatementType + func (n *DropDatabase) String() string + func (node *DropDatabase) Format(ctx *FmtCtx) + type DropIndex struct + Concurrently bool + DropBehavior DropBehavior + IfExists bool + IndexList TableIndexNames + func (*DropIndex) StatementReturnType() StatementReturnType + func (*DropIndex) StatementTag() string + func (*DropIndex) StatementType() StatementType + func (n *DropIndex) String() string + func (node *DropIndex) Format(ctx *FmtCtx) + type DropOwnedBy struct + DropBehavior DropBehavior + Roles RoleSpecList + func (*DropOwnedBy) StatementReturnType() StatementReturnType + func (*DropOwnedBy) StatementTag() string + func (*DropOwnedBy) StatementType() StatementType + func (n *DropOwnedBy) String() string + func (node *DropOwnedBy) Format(ctx *FmtCtx) + type DropRole struct + IfExists bool + IsRole bool + Names RoleSpecList + func (*DropRole) StatementReturnType() StatementReturnType + func (*DropRole) StatementTag() string + func (*DropRole) StatementType() StatementType + func (n *DropRole) String() string + func (node *DropRole) Format(ctx *FmtCtx) + type DropSchema struct + DropBehavior DropBehavior + IfExists bool + Names ObjectNamePrefixList + func (*DropSchema) StatementReturnType() StatementReturnType + func (*DropSchema) StatementTag() string + func (*DropSchema) StatementType() StatementType + func (n *DropSchema) String() string + func (node *DropSchema) Format(ctx *FmtCtx) + type DropSequence struct + DropBehavior DropBehavior + IfExists bool + Names TableNames + func (*DropSequence) StatementReturnType() StatementReturnType + func (*DropSequence) StatementTag() string + func (*DropSequence) StatementType() StatementType + func (n *DropSequence) String() string + func (node *DropSequence) Format(ctx *FmtCtx) + type DropTable struct + DropBehavior DropBehavior + IfExists bool + Names TableNames + func (*DropTable) StatementReturnType() StatementReturnType + func (*DropTable) StatementTag() string + func (*DropTable) StatementType() StatementType + func (n *DropTable) String() string + func (node *DropTable) Format(ctx *FmtCtx) + type DropType struct + DropBehavior DropBehavior + IfExists bool + Names []*UnresolvedObjectName + func (*DropType) StatementReturnType() StatementReturnType + func (*DropType) StatementTag() string + func (*DropType) StatementType() StatementType + func (n *DropType) String() string + func (node *DropType) Format(ctx *FmtCtx) + type DropView struct + DropBehavior DropBehavior + IfExists bool + IsMaterialized bool + Names TableNames + func (*DropView) StatementReturnType() StatementReturnType + func (*DropView) StatementTag() string + func (*DropView) StatementType() StatementType + func (n *DropView) String() string + func (node *DropView) Format(ctx *FmtCtx) + func (node *DropView) TelemetryCounter() telemetry.Counter + type EnumValue string + func (n *EnumValue) Format(ctx *FmtCtx) + type EnumValueList []EnumValue + func (l *EnumValueList) Format(ctx *FmtCtx) + type EvalAsOfTimestampOption func(o evalAsOfTimestampOptions) evalAsOfTimestampOptions + var EvalAsOfTimestampOptionAllowBoundedStaleness EvalAsOfTimestampOption = func(o evalAsOfTimestampOptions) evalAsOfTimestampOptions { ... } + type EvalContext struct + Annotations *Annotations + AsOfSystemTime *AsOfSystemTime + ClientNoticeSender ClientNoticeSender + ClusterID uuid.UUID + ClusterName string + Codec keys.SQLCodec + CollationEnv CollationEnvironment + CompactEngineSpan CompactEngineSpanFunc + Context context.Context + DB *kv.DB + IVarContainer IndexedVarContainer + IndexUsageStatsController IndexUsageStatsController + JobExecContext interface{} + JoinTokenCreator JoinTokenCreator + Locality roachpb.Locality + Mon *mon.BytesMonitor + NodeID *base.SQLIDContainer + Placeholders *PlaceholderInfo + Planner EvalPlanner + PrepareOnly bool + PreparedStatementState PreparedStatementState + PrivilegedAccessor PrivilegedAccessor + ReCache *RegexpCache + Regions RegionOperator + SQLLivenessReader sqlliveness.Reader + SQLStatsController SQLStatsController + Sequence SequenceOperators + SessionAccessor EvalSessionAccessor + SessionDataStack *sessiondata.Stack + Settings *cluster.Settings + SingleDatumAggMemAccount *mon.BoundAccount + SkipNormalize bool + StmtTimestamp time.Time + Tenant TenantOperator + TestingKnobs EvalContextTestingKnobs + Tracer *tracing.Tracer + Txn *kv.Txn + TxnImplicit bool + TxnReadOnly bool + TxnState string + TxnTimestamp time.Time + func MakeTestingEvalContext(st *cluster.Settings) EvalContext + func MakeTestingEvalContextWithMon(st *cluster.Settings, monitor *mon.BytesMonitor) EvalContext + func NewTestingEvalContext(st *cluster.Settings) *EvalContext + func (ctx *EvalContext) Copy() *EvalContext + func (ctx *EvalContext) Ctx() context.Context + func (ctx *EvalContext) FmtCtx(f FmtFlags, opts ...FmtCtxOption) *FmtCtx + func (ctx *EvalContext) GetClusterTimestamp() *DDecimal + func (ctx *EvalContext) GetDateStyle() pgdate.DateStyle + func (ctx *EvalContext) GetIntervalStyle() duration.IntervalStyle + func (ctx *EvalContext) GetLocalRegion() (regionName string, ok bool) + func (ctx *EvalContext) GetLocation() *time.Location + func (ctx *EvalContext) GetRelativeParseTime() time.Time + func (ctx *EvalContext) GetStmtTimestamp() time.Time + func (ctx *EvalContext) GetTxnTime(precision time.Duration) *DTimeTZ + func (ctx *EvalContext) GetTxnTimeNoZone(precision time.Duration) *DTime + func (ctx *EvalContext) GetTxnTimestamp(precision time.Duration) *DTimestampTZ + func (ctx *EvalContext) GetTxnTimestampNoZone(precision time.Duration) *DTimestamp + func (ctx *EvalContext) HasPlaceholders() bool + func (ctx *EvalContext) NormalizeExpr(typedExpr TypedExpr) (TypedExpr, error) + func (ctx *EvalContext) PopIVarContainer() + func (ctx *EvalContext) PushIVarContainer(c IndexedVarContainer) + func (ctx *EvalContext) QualityOfService() sessiondatapb.QoSLevel + func (ctx *EvalContext) SessionData() *sessiondata.SessionData + func (ctx *EvalContext) SetStmtTimestamp(ts time.Time) + func (ctx *EvalContext) SetTxnTimestamp(ts time.Time) + func (ctx *EvalContext) Stop(c context.Context) + type EvalContextTestingKnobs struct + AssertBinaryExprReturnTypes bool + AssertFuncExprReturnTypes bool + AssertUnaryExprReturnTypes bool + CallbackGenerators map[string]*CallbackValueGenerator + DisableOptimizerRuleProbability float64 + ForceProductionBatchSizes bool + OptimizerCostPerturbation float64 + func (*EvalContextTestingKnobs) ModuleTestingKnobs() + type EvalDatabase interface + HasAnyPrivilege func(ctx context.Context, specifier HasPrivilegeSpecifier, ...) (HasAnyPrivilegeResult, error) + IsTableVisible func(ctx context.Context, curDB string, searchPath sessiondata.SearchPath, ...) (isVisible bool, exists bool, err error) + IsTypeVisible func(ctx context.Context, curDB string, searchPath sessiondata.SearchPath, ...) (isVisible bool, exists bool, err error) + ParseQualifiedTableName func(sql string) (*TableName, error) + ResolveTableName func(ctx context.Context, tn *TableName) (ID, error) + SchemaExists func(ctx context.Context, dbName, scName string) (found bool, err error) + type EvalPlanner interface + CreateSessionRevivalToken func() (*DBytes, error) + DecodeGist func(gist string) ([]string, error) + DeserializeSessionState func(state *DBytes) (*DBool, error) + EvalSubquery func(expr *Subquery) (Datum, error) + ExecutorConfig func() interface{} + ExternalReadFile func(ctx context.Context, uri string) ([]byte, error) + ExternalWriteFile func(ctx context.Context, uri string, content []byte) error + ForceDeleteTableData func(ctx context.Context, descID int64) error + GetImmutableTableInterfaceByID func(ctx context.Context, id int) (interface{}, error) + GetTypeFromValidSQLSyntax func(sql string) (*types.T, error) + MemberOfWithAdminOption func(ctx context.Context, member security.SQLUsername) (map[security.SQLUsername]bool, error) + QueryIteratorEx func(ctx context.Context, opName string, txn *kv.Txn, ...) (InternalRows, error) + QueryRowEx func(ctx context.Context, opName string, txn *kv.Txn, ...) (Datums, error) + RevalidateUniqueConstraint func(ctx context.Context, tableID int, constraintName string) error + RevalidateUniqueConstraintsInCurrentDB func(ctx context.Context) error + RevalidateUniqueConstraintsInTable func(ctx context.Context, tableID int) error + SerializeSessionState func() (*DBytes, error) + UnsafeDeleteDescriptor func(ctx context.Context, descID int64, force bool) error + UnsafeDeleteNamespaceEntry func(ctx context.Context, parentID, parentSchemaID int64, name string, descID int64, ...) error + UnsafeUpsertDescriptor func(ctx context.Context, descID int64, encodedDescriptor []byte, force bool) error + UnsafeUpsertNamespaceEntry func(ctx context.Context, parentID, parentSchemaID int64, name string, descID int64, ...) error + UserHasAdminRole func(ctx context.Context, user security.SQLUsername) (bool, error) + ValidateSessionRevivalToken func(token *DBytes) (*DBool, error) + type EvalSessionAccessor interface + GetSessionVar func(ctx context.Context, settingName string, missingOk bool) (bool, string, error) + HasAdminRole func(ctx context.Context) (bool, error) + HasRoleOption func(ctx context.Context, roleOption roleoption.Option) (bool, error) + SetSessionVar func(ctx context.Context, settingName, newValue string, isLocal bool) error + type Execute struct + DiscardRows bool + Name Name + Params Exprs + func (*Execute) StatementReturnType() StatementReturnType + func (*Execute) StatementTag() string + func (*Execute) StatementType() StatementType + func (n *Execute) String() string + func (node *Execute) Format(ctx *FmtCtx) + type Explain struct + Statement Statement + func (*Explain) StatementReturnType() StatementReturnType + func (*Explain) StatementTag() string + func (*Explain) StatementType() StatementType + func (n *Explain) String() string + func (node *Explain) Format(ctx *FmtCtx) + type ExplainAnalyze struct + Statement Statement + func (*ExplainAnalyze) StatementReturnType() StatementReturnType + func (*ExplainAnalyze) StatementTag() string + func (*ExplainAnalyze) StatementType() StatementType + func (n *ExplainAnalyze) String() string + func (node *ExplainAnalyze) Format(ctx *FmtCtx) + type ExplainFlag uint8 + const ExplainFlagCatalog + const ExplainFlagDeps + const ExplainFlagEnv + const ExplainFlagJSON + const ExplainFlagMemo + const ExplainFlagShape + const ExplainFlagStages + const ExplainFlagTypes + const ExplainFlagVerbose + func (f ExplainFlag) String() string + type ExplainMode uint8 + const ExplainDDL + const ExplainDebug + const ExplainDistSQL + const ExplainGist + const ExplainOpt + const ExplainPlan + const ExplainVec + func (m ExplainMode) String() string + type ExplainOptions struct + Flags [numExplainFlags + 1]bool + Mode ExplainMode + type Export struct + File Expr + FileFormat string + Options KVOptions + Query *Select + func (*Export) StatementReturnType() StatementReturnType + func (*Export) StatementTag() string + func (*Export) StatementType() StatementType + func (n *Export) String() string + func (node *Export) Format(ctx *FmtCtx) + type Expr interface + TypeCheck func(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + Walk func(Visitor) Expr + func SimpleVisit(expr Expr, preFn SimpleVisitFn) (Expr, error) + func StripMemoizedFuncs(expr Expr) Expr + func StripParens(expr Expr) Expr + func WalkExpr(v Visitor, expr Expr) (newExpr Expr, changed bool) + type Exprs []Expr + func (node *Exprs) Format(ctx *FmtCtx) + func (node *Exprs) String() string + type FamilyTableDef struct + Columns NameList + Name Name + func (node *FamilyTableDef) Format(ctx *FmtCtx) + type FetchCursor struct + func (*FetchCursor) StatementTag() string + func (*FetchCursor) StatementType() StatementType + func (f FetchCursor) Format(ctx *FmtCtx) + func (n *FetchCursor) StatementReturnType() StatementReturnType + func (n *FetchCursor) String() string + type FetchType int + const FetchAbsolute + const FetchAll + const FetchBackwardAll + const FetchFirst + const FetchLast + const FetchNormal + const FetchRelative + func (o FetchType) HasCount() bool + func (o FetchType) String() string + type FmtCtx struct + func NewFmtCtx(f FmtFlags, opts ...FmtCtxOption) *FmtCtx + func (ctx *FmtCtx) Close() + func (ctx *FmtCtx) CloseAndGetString() string + func (ctx *FmtCtx) FormatName(s string) + func (ctx *FmtCtx) FormatNameP(s *string) + func (ctx *FmtCtx) FormatNode(n NodeFormatter) + func (ctx *FmtCtx) FormatNodeSummary(n NodeFormatter) + func (ctx *FmtCtx) FormatTypeReference(ref ResolvableTypeReference) + func (ctx *FmtCtx) HasFlags(f FmtFlags) bool + func (ctx *FmtCtx) Printf(f string, args ...interface{}) + func (ctx *FmtCtx) SetDataConversionConfig(dcc sessiondatapb.DataConversionConfig) sessiondatapb.DataConversionConfig + func (ctx *FmtCtx) WithFlags(flags FmtFlags, fn func()) + func (ctx *FmtCtx) WithReformatTableNames(tableNameFmt func(*FmtCtx, *TableName), fn func()) + type FmtCtxOption func(*FmtCtx) + func FmtAnnotations(ann *Annotations) FmtCtxOption + func FmtDataConversionConfig(dcc sessiondatapb.DataConversionConfig) FmtCtxOption + func FmtIndexedTypeFormat(fn func(*FmtCtx, *OIDTypeReference)) FmtCtxOption + func FmtIndexedVarFormat(fn func(ctx *FmtCtx, idx int)) FmtCtxOption + func FmtPlaceholderFormat(placeholderFn func(_ *FmtCtx, _ *Placeholder)) FmtCtxOption + func FmtReformatTableNames(tableNameFmt func(*FmtCtx, *TableName)) FmtCtxOption + type FmtFlags int + const FmtAlwaysGroupExprs + const FmtAlwaysQualifyTableNames + const FmtAnonymize + const FmtArrayToString + const FmtBareIdentifiers + const FmtBareStrings + const FmtCheckEquivalence + const FmtExport + const FmtHideConstants + const FmtMarkRedactionNode + const FmtOmitNameRedaction + const FmtPGCatalog + const FmtParsable + const FmtParsableNumerics + const FmtPgwireText + const FmtSerializable + const FmtShowPasswords + const FmtShowTableAliases + const FmtShowTypes + const FmtSimple + const FmtSummary + const FmtSymbolicSubqueries + func (f FmtFlags) EncodeFlags() lexbase.EncodeFlags + func (f FmtFlags) HasAnyFlags(subset FmtFlags) bool + func (f FmtFlags) HasFlags(subset FmtFlags) bool + type ForeignKeyConstraintTableDef struct + Actions ReferenceActions + FromCols NameList + IfNotExists bool + Match CompositeKeyMatchMethod + Name Name + Table TableName + ToCols NameList + func (node *ForeignKeyConstraintTableDef) Format(ctx *FmtCtx) + func (node *ForeignKeyConstraintTableDef) SetIfNotExists() + func (node *ForeignKeyConstraintTableDef) SetName(name Name) + type From struct + AsOf AsOfClause + Tables TableExprs + func (node *From) Format(ctx *FmtCtx) + type FullBackupClause struct + AlwaysFull bool + Recurrence Expr + type FuncExpr struct + AggType AggType + Exprs Exprs + Filter Expr + Func ResolvableFunctionReference + OrderBy OrderBy + Type funcType + WindowDef *WindowDef + func NewTypedFuncExpr(ref ResolvableFunctionReference, aggQualifier funcType, exprs TypedExprs, ...) *FuncExpr + func (expr *FuncExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *FuncExpr) EvalArgsAndGetGenerator(ctx *EvalContext) (ValueGenerator, error) + func (expr *FuncExpr) MaybeWrapError(err error) error + func (expr *FuncExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *FuncExpr) Walk(v Visitor) Expr + func (node *FuncExpr) CanHandleNulls() bool + func (node *FuncExpr) Format(ctx *FmtCtx) + func (node *FuncExpr) IsDistSQLBlocklist() bool + func (node *FuncExpr) IsGeneratorApplication() bool + func (node *FuncExpr) IsWindowFunctionApplication() bool + func (node *FuncExpr) ResolvedOverload() *Overload + func (node *FuncExpr) String() string + func (ta FuncExpr) ResolvedType() *types.T + type FunctionClass int + const AggregateClass + const GeneratorClass + const NormalClass + const SQLClass + const WindowClass + type FunctionDefinition struct + Definition []overloadImpl + Name string + func NewFunctionDefinition(name string, props *FunctionProperties, def []Overload) *FunctionDefinition + func (fd *FunctionDefinition) Format(ctx *FmtCtx) + func (fd *FunctionDefinition) String() string + type FunctionProperties struct + AmbiguousReturnType bool + AvailableOnPublicSchema bool + Category string + Class FunctionClass + CompositeInsensitive bool + DistsqlBlocklist bool + HasSequenceArguments bool + NullableArgs bool + Private bool + ReturnLabels []string + Undocumented bool + UnsupportedWithIssue int + func (fp *FunctionProperties) ShouldDocument() bool + type FunctionReference interface + type GeneratedAlwaysAsIdentity struct + SeqOptions SequenceOptions + type GeneratedByDefAsIdentity struct + SeqOptions SequenceOptions + type GeneratedIdentityType int + const GeneratedAlways + const GeneratedByDefault + type GeneratorFactory func(ctx *EvalContext, args Datums) (ValueGenerator, error) + type GeneratorWithExprsFactory func(ctx *EvalContext, args Exprs) (ValueGenerator, error) + type Grant struct + Grantees RoleSpecList + Privileges privilege.List + Targets TargetList + WithGrantOption bool + func (*Grant) StatementReturnType() StatementReturnType + func (*Grant) StatementTag() string + func (*Grant) StatementType() StatementType + func (n *Grant) String() string + func (node *Grant) Format(ctx *FmtCtx) + type GrantRole struct + AdminOption bool + Members RoleSpecList + Roles NameList + func (*GrantRole) StatementReturnType() StatementReturnType + func (*GrantRole) StatementTag() string + func (*GrantRole) StatementType() StatementType + func (n *GrantRole) String() string + func (node *GrantRole) Format(ctx *FmtCtx) + type GroupBy []Expr + func (node *GroupBy) Format(ctx *FmtCtx) + type HasAnyPrivilegeResult = int8 + const HasNoPrivilege + const HasPrivilege + const ObjectNotFound + type HasPrivilegeSpecifier struct + ColumnAttNum *uint32 + ColumnName *Name + DatabaseName *string + DatabaseOID *oid.Oid + IsSequence *bool + SchemaDatabaseName *string + SchemaIsRequired *bool + SchemaName *string + TableName *string + TableOID *oid.Oid + type HiddenConstraint struct + type HiddenFromShowQueries interface + type HomogeneousType struct + func (HomogeneousType) GetAt(i int) *types.T + func (HomogeneousType) Length() int + func (HomogeneousType) Match(types []*types.T) bool + func (HomogeneousType) MatchAt(typ *types.T, i int) bool + func (HomogeneousType) MatchLen(l int) bool + func (HomogeneousType) String() string + func (HomogeneousType) Types() []*types.T + type ID = catid.ColumnID + type IfErrExpr struct + Cond Expr + Else Expr + ErrCode Expr + func NewTypedIfErrExpr(cond, orElse, errCode TypedExpr) *IfErrExpr + func (expr *IfErrExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *IfErrExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *IfErrExpr) Walk(v Visitor) Expr + func (node *IfErrExpr) Format(ctx *FmtCtx) + func (node *IfErrExpr) String() string + func (ta IfErrExpr) ResolvedType() *types.T + type IfExpr struct + Cond Expr + Else Expr + True Expr + func (expr *IfExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *IfExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *IfExpr) Walk(v Visitor) Expr + func (node *IfExpr) Format(ctx *FmtCtx) + func (node *IfExpr) String() string + func (node *IfExpr) TypedCondExpr() TypedExpr + func (node *IfExpr) TypedElseExpr() TypedExpr + func (node *IfExpr) TypedTrueExpr() TypedExpr + func (ta IfExpr) ResolvedType() *types.T + type Import struct + Bundle bool + FileFormat string + Files Exprs + Into bool + IntoCols NameList + Options KVOptions + Table *TableName + func (*Import) StatementReturnType() StatementReturnType + func (*Import) StatementTag() string + func (*Import) StatementType() StatementType + func (n *Import) String() string + func (node *Import) Format(ctx *FmtCtx) + type IndexElem struct + Column Name + Direction Direction + Expr Expr + NullsOrder NullsOrder + func (node *IndexElem) Format(ctx *FmtCtx) + type IndexElemList []IndexElem + func (l *IndexElemList) Format(ctx *FmtCtx) + type IndexFlags struct + Direction Direction + ForceZigzag bool + IgnoreForeignKeys bool + IgnoreUniqueWithoutIndexKeys bool + Index UnrestrictedName + IndexID IndexID + NoFullScan bool + NoIndexJoin bool + NoZigzagJoin bool + ZigzagIndexIDs []IndexID + ZigzagIndexes []UnrestrictedName + func (ih *IndexFlags) Check() error + func (ih *IndexFlags) CombineWith(other *IndexFlags) error + func (ih *IndexFlags) ForceIndex() bool + func (ih *IndexFlags) Format(ctx *FmtCtx) + type IndexID = catid.IndexID + type IndexTableDef struct + Columns IndexElemList + Inverted bool + Name Name + PartitionByIndex *PartitionByIndex + Predicate Expr + Sharded *ShardedIndexDef + StorageParams StorageParams + Storing NameList + func (node *IndexTableDef) Format(ctx *FmtCtx) + type IndexUsageStatsController interface + ResetIndexUsageStats func(ctx context.Context) error + type IndexedRow interface + GetDatum func(idx int) (Datum, error) + GetDatums func(startIdx, endIdx int) (Datums, error) + GetIdx func() int + type IndexedRows interface + GetRow func(ctx context.Context, idx int) (IndexedRow, error) + Len func() int + type IndexedVar struct + Idx int + Used bool + func NewOrdinalReference(r int) *IndexedVar + func NewTypedOrdinalReference(r int, typ *types.T) *IndexedVar + func (*IndexedVar) Variable() + func (node *IndexedVar) String() string + func (v *IndexedVar) Eval(ctx *EvalContext) (Datum, error) + func (v *IndexedVar) Format(ctx *FmtCtx) + func (v *IndexedVar) ResolvedType() *types.T + func (v *IndexedVar) TypeCheck(_ context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (v *IndexedVar) Walk(_ Visitor) Expr + type IndexedVarContainer interface + IndexedVarEval func(idx int, ctx *EvalContext) (Datum, error) + IndexedVarNodeFormatter func(idx int) NodeFormatter + IndexedVarResolvedType func(idx int) *types.T + type IndexedVarHelper struct + func MakeIndexedVarHelper(container IndexedVarContainer, numVars int) IndexedVarHelper + func MakeTypesOnlyIndexedVarHelper(types []*types.T) IndexedVarHelper + func (*IndexedVarHelper) VisitPost(expr Expr) Expr + func (h *IndexedVarHelper) AppendSlot() int + func (h *IndexedVarHelper) BindIfUnbound(ivar *IndexedVar) (*IndexedVar, error) + func (h *IndexedVarHelper) Container() IndexedVarContainer + func (h *IndexedVarHelper) GetIndexedVars() []IndexedVar + func (h *IndexedVarHelper) IndexedVar(idx int) *IndexedVar + func (h *IndexedVarHelper) IndexedVarUsed(idx int) bool + func (h *IndexedVarHelper) IndexedVarWithType(idx int, typ *types.T) *IndexedVar + func (h *IndexedVarHelper) Rebind(expr TypedExpr) TypedExpr + func (h *IndexedVarHelper) VisitPre(expr Expr) (recurse bool, newExpr Expr) + type IndirectionExpr struct + Expr Expr + Indirection ArraySubscripts + func NewTypedIndirectionExpr(expr, index TypedExpr, typ *types.T) *IndirectionExpr + func (expr *IndirectionExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *IndirectionExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *IndirectionExpr) Walk(v Visitor) Expr + func (node *IndirectionExpr) Format(ctx *FmtCtx) + func (node *IndirectionExpr) String() string + func (ta IndirectionExpr) ResolvedType() *types.T + type Insert struct + Columns NameList + OnConflict *OnConflict + Returning ReturningClause + Rows *Select + Table TableExpr + With *With + func (*Insert) StatementTag() string + func (*Insert) StatementType() StatementType + func (n *Insert) StatementReturnType() StatementReturnType + func (n *Insert) String() string + func (node *Insert) DefaultValues() bool + func (node *Insert) Format(ctx *FmtCtx) + type InternalRows interface + Close func() error + Cur func() Datums + Next func(context.Context) (bool, error) + type IsNotNullExpr struct + Expr Expr + func NewTypedIsNotNullExpr(expr TypedExpr) *IsNotNullExpr + func (expr *IsNotNullExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *IsNotNullExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *IsNotNullExpr) Walk(v Visitor) Expr + func (node *IsNotNullExpr) Format(ctx *FmtCtx) + func (node *IsNotNullExpr) String() string + func (node *IsNotNullExpr) TypedInnerExpr() TypedExpr + func (ta IsNotNullExpr) ResolvedType() *types.T + type IsNullExpr struct + Expr Expr + func NewTypedIsNullExpr(expr TypedExpr) *IsNullExpr + func (expr *IsNullExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *IsNullExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *IsNullExpr) Walk(v Visitor) Expr + func (node *IsNullExpr) Format(ctx *FmtCtx) + func (node *IsNullExpr) String() string + func (node *IsNullExpr) TypedInnerExpr() TypedExpr + func (ta IsNullExpr) ResolvedType() *types.T + type IsOfTypeExpr struct + Expr Expr + Not bool + Types []ResolvableTypeReference + func (expr *IsOfTypeExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *IsOfTypeExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *IsOfTypeExpr) Walk(v Visitor) Expr + func (node *IsOfTypeExpr) Format(ctx *FmtCtx) + func (node *IsOfTypeExpr) ResolvedTypes() []*types.T + func (node *IsOfTypeExpr) String() string + func (ta IsOfTypeExpr) ResolvedType() *types.T + type IsolationLevel int + const SerializableIsolation + const UnspecifiedIsolation + func (i IsolationLevel) String() string + type JobCommand int + const CancelJob + const PauseJob + const ResumeJob + type JoinCond interface + type JoinTableExpr struct + Cond JoinCond + Hint string + JoinType string + Left TableExpr + Right TableExpr + func (expr *JoinTableExpr) WalkTableExpr(v Visitor) TableExpr + func (node *JoinTableExpr) Format(ctx *FmtCtx) + func (node *JoinTableExpr) String() string + type JoinTokenCreator interface + CreateJoinToken func(ctx context.Context) (string, error) + type KVOption struct + Key Name + Value Expr + type KVOptions []KVOption + func (o *KVOptions) Format(ctx *FmtCtx) + func (o KVOptions) ToRoleOptions(...) (roleoption.List, error) + type LikeTableDef struct + Name TableName + Options []LikeTableOption + func (def *LikeTableDef) Format(ctx *FmtCtx) + type LikeTableOpt int + const LikeTableOptConstraints + const LikeTableOptDefaults + const LikeTableOptGenerated + const LikeTableOptIndexes + func (o LikeTableOpt) Has(other LikeTableOpt) bool + func (o LikeTableOpt) String() string + type LikeTableOption struct + Excluded bool + Opt LikeTableOpt + func (l LikeTableOption) Format(ctx *FmtCtx) + type Limit struct + Count Expr + LimitAll bool + Offset Expr + func (node *Limit) Format(ctx *FmtCtx) + type LineWidthMode int + type ListPartition struct + Exprs Exprs + Name UnrestrictedName + Subpartition *PartitionBy + func (node *ListPartition) Format(ctx *FmtCtx) + type Locality struct + LocalityLevel LocalityLevel + RegionalByRowColumn Name + TableRegion Name + func (node *Locality) Format(ctx *FmtCtx) + func (node *Locality) TelemetryName() string + type LocalityLevel int + const LocalityLevelGlobal + const LocalityLevelRow + const LocalityLevelTable + type LockingClause []*LockingItem + func (node *LockingClause) Format(ctx *FmtCtx) + type LockingItem struct + Strength LockingStrength + Targets TableNames + WaitPolicy LockingWaitPolicy + func (f *LockingItem) Format(ctx *FmtCtx) + type LockingStrength byte + const ForKeyShare + const ForNoKeyUpdate + const ForNone + const ForShare + const ForUpdate + func (s LockingStrength) Format(ctx *FmtCtx) + func (s LockingStrength) Max(s2 LockingStrength) LockingStrength + func (s LockingStrength) String() string + type LockingWaitPolicy byte + const LockWaitBlock + const LockWaitError + const LockWaitSkip + func (p LockingWaitPolicy) Format(ctx *FmtCtx) + func (p LockingWaitPolicy) Max(p2 LockingWaitPolicy) LockingWaitPolicy + func (p LockingWaitPolicy) String() string + type MaterializeClause struct + Materialize bool + Set bool + type MoveCursor struct + func (*MoveCursor) StatementTag() string + func (*MoveCursor) StatementType() StatementType + func (m MoveCursor) Format(ctx *FmtCtx) + func (n *MoveCursor) StatementReturnType() StatementReturnType + func (n *MoveCursor) String() string + type MultipleResultsError struct + SQL string + func (e *MultipleResultsError) Error() string + type Name string + func (n *Name) Format(ctx *FmtCtx) + func (n Name) Normalize() string + func (node *Name) String() string + type NameList []Name + func (l *NameList) Format(ctx *FmtCtx) + func (l NameList) ToSQLUsernames() ([]security.SQLUsername, error) + func (l NameList) ToStrings() []string + func (list *NameList) String() string + type NameParts = [4]string + type NamedColumnQualification struct + Name Name + Qualification ColumnQualification + type NaturalJoinCond struct + func (NaturalJoinCond) Format(ctx *FmtCtx) + type NewParseTimeContextOption func(ret *simpleParseTimeContext) + func NewParseTimeContextOptionDateStyle(dateStyle pgdate.DateStyle) NewParseTimeContextOption + type NoReturningClause struct + func (*NoReturningClause) Format(_ *FmtCtx) + type NodeFormatter interface + Format func(ctx *FmtCtx) + type NormalizeVisitor struct + func MakeNormalizeVisitor(ctx *EvalContext) NormalizeVisitor + func (v *NormalizeVisitor) Err() error + func (v *NormalizeVisitor) VisitPost(expr Expr) Expr + func (v *NormalizeVisitor) VisitPre(expr Expr) (recurse bool, newExpr Expr) + type NotExpr struct + Expr Expr + func NewTypedNotExpr(expr TypedExpr) *NotExpr + func (expr *NotExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *NotExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *NotExpr) Walk(v Visitor) Expr + func (node *NotExpr) Format(ctx *FmtCtx) + func (node *NotExpr) String() string + func (node *NotExpr) TypedInnerExpr() TypedExpr + func (ta NotExpr) ResolvedType() *types.T + type NotNullConstraint struct + type NullConstraint struct + type NullIfExpr struct + Expr1 Expr + Expr2 Expr + func (expr *NullIfExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *NullIfExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *NullIfExpr) Walk(v Visitor) Expr + func (node *NullIfExpr) Format(ctx *FmtCtx) + func (node *NullIfExpr) String() string + func (ta NullIfExpr) ResolvedType() *types.T + type Nullability int + const NotNull + const Null + const SilentNull + type NullsOrder int8 + const DefaultNullsOrder + const NullsFirst + const NullsLast + func (n NullsOrder) String() string + type NumVal struct + func NewNumVal(value constant.Value, origString string, negative bool) *NumVal + func (expr *NumVal) AsConstantInt() (constant.Value, bool) + func (expr *NumVal) AsConstantValue() constant.Value + func (expr *NumVal) AsInt32() (int32, error) + func (expr *NumVal) AsInt64() (int64, error) + func (expr *NumVal) AvailableTypes() []*types.T + func (expr *NumVal) DesirableTypes() []*types.T + func (expr *NumVal) ExactString() string + func (expr *NumVal) Format(ctx *FmtCtx) + func (expr *NumVal) Kind() constant.Kind + func (expr *NumVal) Negate() + func (expr *NumVal) OrigString() string + func (expr *NumVal) ResolveAsType(ctx context.Context, semaCtx *SemaContext, typ *types.T) (TypedExpr, error) + func (expr *NumVal) SetNegative() + func (expr *NumVal) ShouldBeInt64() bool + func (expr *NumVal) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *NumVal) Walk(_ Visitor) Expr + func (node *NumVal) String() string + type OIDTypeReference struct + OID oid.Oid + func (node *OIDTypeReference) SQLString() string + type ObjectLookupFlags struct + AllowWithoutPrimaryKey bool + DesiredObjectKind DesiredObjectKind + DesiredTableDescKind RequiredTableKind + func ObjectLookupFlagsWithRequired() ObjectLookupFlags + func ObjectLookupFlagsWithRequiredTableKind(kind RequiredTableKind) ObjectLookupFlags + type ObjectName interface + Catalog func() string + FQString func() string + Object func() string + Schema func() string + func NewQualifiedObjectName(catalog, schema, object string, kind DesiredObjectKind) ObjectName + type ObjectNamePrefix struct + CatalogName Name + ExplicitCatalog bool + ExplicitSchema bool + SchemaName Name + func (tp *ObjectNamePrefix) Catalog() string + func (tp *ObjectNamePrefix) Format(ctx *FmtCtx) + func (tp *ObjectNamePrefix) Schema() string + func (tp *ObjectNamePrefix) String() string + type ObjectNamePrefixList []ObjectNamePrefix + func (tp ObjectNamePrefixList) Format(ctx *FmtCtx) + type ObserverStatement interface + type OnConflict struct + ArbiterPredicate Expr + Columns NameList + Constraint Name + DoNothing bool + Exprs UpdateExprs + Where *Where + func (oc *OnConflict) IsUpsertAlias() bool + type OnJoinCond struct + Expr Expr + func (node *OnJoinCond) Format(ctx *FmtCtx) + type Operator interface + Operator func() + type OrExpr struct + Left Expr + Right Expr + func NewTypedOrExpr(left, right TypedExpr) *OrExpr + func (expr *OrExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *OrExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *OrExpr) Walk(v Visitor) Expr + func (node *OrExpr) Format(ctx *FmtCtx) + func (node *OrExpr) String() string + func (node *OrExpr) TypedLeft() TypedExpr + func (node *OrExpr) TypedRight() TypedExpr + func (ta OrExpr) ResolvedType() *types.T + type Order struct + Direction Direction + Expr Expr + Index UnrestrictedName + NullsOrder NullsOrder + OrderType OrderType + Table TableName + func (node *Order) Equal(other *Order) bool + func (node *Order) Format(ctx *FmtCtx) + type OrderBy []*Order + func (node *OrderBy) Format(ctx *FmtCtx) + type OrderType int + const OrderByColumn + const OrderByIndex + type Overload struct + AggregateFunc func([]*types.T, *EvalContext, Datums) AggregateFunc + DistsqlBlocklist bool + Fn func(*EvalContext, Datums) (Datum, error) + FnWithExprs func(*EvalContext, Exprs) (Datum, error) + Generator GeneratorFactory + GeneratorWithExprs GeneratorWithExprsFactory + IgnoreVolatilityCheck bool + Info string + Oid oid.Oid + PreferredOverload bool + ReturnType ReturnTyper + SQLFn func(*EvalContext, Datums) (string, error) + SpecializedVecBuiltin SpecializedVectorizedBuiltin + Types TypeList + Volatility Volatility + WindowFunc func([]*types.T, *EvalContext) WindowFunc + func (b Overload) FixedReturnType() *types.T + func (b Overload) InferReturnTypeFromInputArgTypes(inputTypes []*types.T) *types.T + func (b Overload) IsGenerator() bool + func (b Overload) Signature(simplify bool) string + type ParenExpr struct + Expr Expr + func (expr *ParenExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *ParenExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *ParenExpr) Walk(v Visitor) Expr + func (node *ParenExpr) Format(ctx *FmtCtx) + func (node *ParenExpr) String() string + func (node *ParenExpr) TypedInnerExpr() TypedExpr + func (ta ParenExpr) ResolvedType() *types.T + type ParenSelect struct + Select *Select + func (*ParenSelect) StatementReturnType() StatementReturnType + func (*ParenSelect) StatementTag() string + func (*ParenSelect) StatementType() StatementType + func (n *ParenSelect) String() string + func (node *ParenSelect) Format(ctx *FmtCtx) + type ParenTableExpr struct + Expr TableExpr + func (expr *ParenTableExpr) WalkTableExpr(v Visitor) TableExpr + func (node *ParenTableExpr) Format(ctx *FmtCtx) + func (node *ParenTableExpr) String() string + type ParseTimeContext interface + GetDateStyle func() pgdate.DateStyle + GetIntervalStyle func() duration.IntervalStyle + GetRelativeParseTime func() time.Time + func NewParseTimeContext(relativeParseTime time.Time, opts ...NewParseTimeContextOption) ParseTimeContext + type PartitionBy struct + Fields NameList + List []ListPartition + Range []RangePartition + func (node *PartitionBy) Format(ctx *FmtCtx) + type PartitionByIndex struct + func (node *PartitionByIndex) ContainsPartitioningClause() bool + func (node *PartitionByIndex) ContainsPartitions() bool + type PartitionByTable struct + All bool + func (node *PartitionByTable) ContainsPartitioningClause() bool + func (node *PartitionByTable) ContainsPartitions() bool + func (node *PartitionByTable) Format(ctx *FmtCtx) + type PartitionByType string + const PartitionByList + const PartitionByRange + type PartitionMaxVal struct + func (expr PartitionMaxVal) TypeCheck(_ context.Context, _ *SemaContext, desired *types.T) (TypedExpr, error) + func (expr PartitionMaxVal) Walk(_ Visitor) Expr + func (node PartitionMaxVal) Format(ctx *FmtCtx) + func (node PartitionMaxVal) String() string + type PartitionMinVal struct + func (expr PartitionMinVal) TypeCheck(_ context.Context, _ *SemaContext, desired *types.T) (TypedExpr, error) + func (expr PartitionMinVal) Walk(_ Visitor) Expr + func (node PartitionMinVal) Format(ctx *FmtCtx) + func (node PartitionMinVal) String() string + type PeerGroupChecker interface + InSameGroup func(i, j int) (bool, error) + type PeerGroupsIndicesHelper struct + func (p *PeerGroupsIndicesHelper) GetFirstPeerIdx(peerGroupNum int) int + func (p *PeerGroupsIndicesHelper) GetLastPeerGroupNum() int + func (p *PeerGroupsIndicesHelper) GetRowCount(peerGroupNum int) int + func (p *PeerGroupsIndicesHelper) Init(wfr *WindowFrameRun, peerGrouper PeerGroupChecker) error + func (p *PeerGroupsIndicesHelper) Update(wfr *WindowFrameRun) error + type Persistence int + const PersistencePermanent + const PersistenceTemporary + const PersistenceUnlogged + func (p Persistence) IsTemporary() bool + func (p Persistence) IsUnlogged() bool + type Placeholder struct + Idx PlaceholderIdx + func NewPlaceholder(name string) (*Placeholder, error) + func (d *Placeholder) AmbiguousFormat() bool + func (d *Placeholder) Compare(ctx *EvalContext, other Datum) int + func (d *Placeholder) CompareError(ctx *EvalContext, other Datum) (int, error) + func (d *Placeholder) IsMax(ctx *EvalContext) bool + func (d *Placeholder) IsMin(ctx *EvalContext) bool + func (d *Placeholder) Max(ctx *EvalContext) (Datum, bool) + func (d *Placeholder) Min(ctx *EvalContext) (Datum, bool) + func (d *Placeholder) Next(ctx *EvalContext) (Datum, bool) + func (d *Placeholder) Prev(ctx *EvalContext) (Datum, bool) + func (d *Placeholder) Size() uintptr + func (expr *Placeholder) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *Placeholder) Walk(_ Visitor) Expr + func (node *Placeholder) Format(ctx *FmtCtx) + func (node *Placeholder) ResolvedType() *types.T + func (node *Placeholder) String() string + func (t *Placeholder) Eval(ctx *EvalContext) (Datum, error) + type PlaceholderIdx uint16 + func (idx PlaceholderIdx) String() string + type PlaceholderInfo struct + Values QueryArguments + func (p *PlaceholderInfo) Assign(src *PlaceholderInfo, numPlaceholders int) error + func (p *PlaceholderInfo) Init(numPlaceholders int, typeHints PlaceholderTypes) error + func (p *PlaceholderInfo) IsUnresolvedPlaceholder(expr Expr) bool + func (p *PlaceholderInfo) Value(idx PlaceholderIdx) (TypedExpr, bool) + type PlaceholderTypes []*types.T + func (pt PlaceholderTypes) AssertAllSet() error + func (pt PlaceholderTypes) Identical(other PlaceholderTypes) bool + type PlaceholderTypesInfo struct + TypeHints PlaceholderTypes + Types PlaceholderTypes + func (p *PlaceholderTypesInfo) SetType(idx PlaceholderIdx, typ *types.T) error + func (p *PlaceholderTypesInfo) Type(idx PlaceholderIdx) (_ *types.T, ok bool, _ error) + func (p *PlaceholderTypesInfo) ValueType(idx PlaceholderIdx) (_ *types.T, ok bool) + type Prepare struct + Name Name + Statement Statement + Types []ResolvableTypeReference + func (*Prepare) StatementReturnType() StatementReturnType + func (*Prepare) StatementTag() string + func (*Prepare) StatementType() StatementType + func (n *Prepare) String() string + func (node *Prepare) Format(ctx *FmtCtx) + type PreparedStatementState interface + HasActivePortals func() bool + MigratablePreparedStatements func() []sessiondatapb.MigratableSession_PreparedStatement + type PrettyAlignMode int + type PrettyCfg struct + Align PrettyAlignMode + Case func(string) string + JSONFmt bool + LineWidth int + Simplify bool + TabWidth int + UseTabs bool + func DefaultPrettyCfg() PrettyCfg + func (p *PrettyCfg) Doc(f NodeFormatter) pretty.Doc + func (p *PrettyCfg) Pretty(stmt NodeFormatter) string + type PrimaryKeyConstraint struct + StorageParams StorageParams + type PrivilegedAccessor interface + LookupNamespaceID func(ctx context.Context, parentID int64, parentSchemaID int64, name string) (DInt, bool, error) + LookupZoneConfigByNamespaceID func(ctx context.Context, id int64) (DBytes, bool, error) + type QualifiedNameResolver interface + CurrentDatabase func() string + GetQualifiedTableNameByID func(ctx context.Context, id int64, requiredType RequiredTableKind) (*TableName, error) + type QueryArguments []TypedExpr + func (qa QueryArguments) String() string + type RangeCond struct + From Expr + Left Expr + Not bool + Symmetric bool + To Expr + func (expr *RangeCond) Eval(ctx *EvalContext) (Datum, error) + func (expr *RangeCond) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *RangeCond) Walk(v Visitor) Expr + func (node *RangeCond) Format(ctx *FmtCtx) + func (node *RangeCond) String() string + func (node *RangeCond) TypedFrom() TypedExpr + func (node *RangeCond) TypedLeftFrom() TypedExpr + func (node *RangeCond) TypedLeftTo() TypedExpr + func (node *RangeCond) TypedTo() TypedExpr + func (ta RangeCond) ResolvedType() *types.T + type RangePartition struct + From Exprs + Name UnrestrictedName + Subpartition *PartitionBy + To Exprs + func (node *RangePartition) Format(ctx *FmtCtx) + type ReadWriteMode int + const ReadOnly + const ReadWrite + const UnspecifiedReadWriteMode + func (ro ReadWriteMode) String() string + type ReassignOwnedBy struct + NewRole RoleSpec + OldRoles RoleSpecList + func (*ReassignOwnedBy) StatementReturnType() StatementReturnType + func (*ReassignOwnedBy) StatementTag() string + func (*ReassignOwnedBy) StatementType() StatementType + func (n *ReassignOwnedBy) String() string + func (node *ReassignOwnedBy) Format(ctx *FmtCtx) + type ReferenceAction int + const Cascade + const NoAction + const Restrict + const SetDefault + const SetNull + func (ra ReferenceAction) String() string + type ReferenceActions struct + Delete ReferenceAction + Update ReferenceAction + func (node *ReferenceActions) Format(ctx *FmtCtx) + type RefreshDataOption int + const RefreshDataClear + const RefreshDataDefault + const RefreshDataWithData + type RefreshMaterializedView struct + Concurrently bool + Name *UnresolvedObjectName + RefreshDataOption RefreshDataOption + func (*RefreshMaterializedView) StatementReturnType() StatementReturnType + func (*RefreshMaterializedView) StatementTag() string + func (*RefreshMaterializedView) StatementType() StatementType + func (n *RefreshMaterializedView) String() string + func (node *RefreshMaterializedView) Format(ctx *FmtCtx) + func (node *RefreshMaterializedView) TelemetryCounter() telemetry.Counter + type RegexpCache struct + func NewRegexpCache(size int) *RegexpCache + func (rc *RegexpCache) GetRegexp(key RegexpCacheKey) (*regexp.Regexp, error) + func (rc *RegexpCache) Len() int + type RegexpCacheKey interface + Pattern func() (string, error) + type RegionOperator interface + CurrentDatabaseRegionConfig func(ctx context.Context) (DatabaseRegionConfig, error) + ResetMultiRegionZoneConfigsForDatabase func(ctx context.Context, id int64) error + ResetMultiRegionZoneConfigsForTable func(ctx context.Context, id int64) error + ValidateAllMultiRegionZoneConfigsInCurrentDatabase func(ctx context.Context) error + type ReleaseSavepoint struct + Savepoint Name + func (*ReleaseSavepoint) StatementReturnType() StatementReturnType + func (*ReleaseSavepoint) StatementTag() string + func (*ReleaseSavepoint) StatementType() StatementType + func (n *ReleaseSavepoint) String() string + func (node *ReleaseSavepoint) Format(ctx *FmtCtx) + type Relocate struct + Rows *Select + SubjectReplicas RelocateSubject + TableOrIndex TableIndexName + func (*Relocate) StatementReturnType() StatementReturnType + func (*Relocate) StatementType() StatementType + func (n *Relocate) StatementTag() string + func (n *Relocate) String() string + func (node *Relocate) Format(ctx *FmtCtx) + type RelocateRange struct + FromStoreID Expr + Rows *Select + SubjectReplicas RelocateSubject + ToStoreID Expr + func (*RelocateRange) StatementReturnType() StatementReturnType + func (*RelocateRange) StatementType() StatementType + func (n *RelocateRange) Format(ctx *FmtCtx) + func (n *RelocateRange) StatementTag() string + func (n *RelocateRange) String() string + type RelocateSubject int8 + const RelocateLease + const RelocateNonVoters + const RelocateVoters + func (n *RelocateSubject) Format(ctx *FmtCtx) + func (n RelocateSubject) String() string + type RenameColumn struct + IfExists bool + Name Name + NewName Name + Table TableName + func (*RenameColumn) StatementReturnType() StatementReturnType + func (*RenameColumn) StatementTag() string + func (*RenameColumn) StatementType() StatementType + func (n *RenameColumn) String() string + func (node *RenameColumn) Format(ctx *FmtCtx) + type RenameDatabase struct + Name Name + NewName Name + func (*RenameDatabase) StatementReturnType() StatementReturnType + func (*RenameDatabase) StatementTag() string + func (*RenameDatabase) StatementType() StatementType + func (n *RenameDatabase) String() string + func (node *RenameDatabase) Format(ctx *FmtCtx) + type RenameIndex struct + IfExists bool + Index *TableIndexName + NewName UnrestrictedName + func (*RenameIndex) StatementReturnType() StatementReturnType + func (*RenameIndex) StatementTag() string + func (*RenameIndex) StatementType() StatementType + func (n *RenameIndex) String() string + func (node *RenameIndex) Format(ctx *FmtCtx) + type RenameTable struct + IfExists bool + IsMaterialized bool + IsSequence bool + IsView bool + Name *UnresolvedObjectName + NewName *UnresolvedObjectName + func (*RenameTable) StatementReturnType() StatementReturnType + func (*RenameTable) StatementType() StatementType + func (n *RenameTable) StatementTag() string + func (n *RenameTable) String() string + func (node *RenameTable) Format(ctx *FmtCtx) + type ReparentDatabase struct + Name Name + Parent Name + func (*ReparentDatabase) StatementReturnType() StatementReturnType + func (*ReparentDatabase) StatementTag() string + func (*ReparentDatabase) StatementType() StatementType + func (n *ReparentDatabase) String() string + func (node *ReparentDatabase) Format(ctx *FmtCtx) + type ReplicationOptions struct + Cursor Expr + Detached bool + func (o *ReplicationOptions) CombineWith(other *ReplicationOptions) error + func (o *ReplicationOptions) Format(ctx *FmtCtx) + func (o ReplicationOptions) IsDefault() bool + type ReplicationStream struct + Options ReplicationOptions + SinkURI Expr + Targets TargetList + func (*ReplicationStream) StatementReturnType() StatementReturnType + func (*ReplicationStream) StatementTag() string + func (*ReplicationStream) StatementType() StatementType + func (n *ReplicationStream) Format(ctx *FmtCtx) + func (n *ReplicationStream) String() string + type RequiredTableKind int + const ResolveAnyTableKind + const ResolveRequireSequenceDesc + const ResolveRequireTableDesc + const ResolveRequireTableOrViewDesc + const ResolveRequireViewDesc + func (r RequiredTableKind) String() string + type ResolvableFunctionReference struct + func WrapFunction(n string) ResolvableFunctionReference + func (fn *ResolvableFunctionReference) Format(ctx *FmtCtx) + func (fn *ResolvableFunctionReference) Resolve(searchPath sessiondata.SearchPath) (*FunctionDefinition, error) + func (fn *ResolvableFunctionReference) String() string + type ResolvableTypeReference interface + SQLString func() string + type Restore struct + AsOf AsOfClause + DescriptorCoverage DescriptorCoverage + From []StringOrPlaceholderOptList + Options RestoreOptions + Subdir Expr + SystemUsers bool + Targets TargetList + func (*Restore) StatementReturnType() StatementReturnType + func (*Restore) StatementTag() string + func (*Restore) StatementType() StatementType + func (n *Restore) String() string + func (node *Restore) Format(ctx *FmtCtx) + type RestoreOptions struct + AsTenant Expr + DebugPauseOn Expr + DecryptionKMSURI StringOrPlaceholderOptList + Detached bool + EncryptionPassphrase Expr + IncrementalStorage StringOrPlaceholderOptList + IntoDB Expr + NewDBName Expr + SkipLocalitiesCheck bool + SkipMissingFKs bool + SkipMissingSequenceOwners bool + SkipMissingSequences bool + SkipMissingViews bool + func (o *RestoreOptions) CombineWith(other *RestoreOptions) error + func (o *RestoreOptions) Format(ctx *FmtCtx) + func (o RestoreOptions) IsDefault() bool + type ReturnTyper func(args []TypedExpr) *types.T + func ArrayOfFirstNonNullReturnType() ReturnTyper + func FirstNonNullReturnType() ReturnTyper + func FixedReturnType(typ *types.T) ReturnTyper + func IdentityReturnType(idx int) ReturnTyper + type ReturningClause interface + type ReturningExprs SelectExprs + func (r *ReturningExprs) Format(ctx *FmtCtx) + type ReturningNothing struct + func (*ReturningNothing) Format(ctx *FmtCtx) + type Revoke struct + GrantOptionFor bool + Grantees RoleSpecList + Privileges privilege.List + Targets TargetList + func (*Revoke) StatementReturnType() StatementReturnType + func (*Revoke) StatementTag() string + func (*Revoke) StatementType() StatementType + func (n *Revoke) String() string + func (node *Revoke) Format(ctx *FmtCtx) + type RevokeRole struct + AdminOption bool + Members RoleSpecList + Roles NameList + func (*RevokeRole) StatementReturnType() StatementReturnType + func (*RevokeRole) StatementTag() string + func (*RevokeRole) StatementType() StatementType + func (n *RevokeRole) String() string + func (node *RevokeRole) Format(ctx *FmtCtx) + type RoleSpec struct + Name string + RoleSpecType RoleSpecType + func MakeRoleSpecWithRoleName(name string) RoleSpec + func (r *RoleSpec) Format(ctx *FmtCtx) + func (r RoleSpec) ToSQLUsername(sessionData *sessiondata.SessionData, purpose security.UsernamePurpose) (security.SQLUsername, error) + func (r RoleSpec) Undefined() bool + type RoleSpecList []RoleSpec + func (l *RoleSpecList) Format(ctx *FmtCtx) + func (l RoleSpecList) ToSQLUsernames(sessionData *sessiondata.SessionData, purpose security.UsernamePurpose) ([]security.SQLUsername, error) + type RoleSpecType int + const CurrentUser + const RoleName + const SessionUser + func (r RoleSpecType) String() string + type RollbackToSavepoint struct + Savepoint Name + func (*RollbackToSavepoint) StatementReturnType() StatementReturnType + func (*RollbackToSavepoint) StatementTag() string + func (*RollbackToSavepoint) StatementType() StatementType + func (n *RollbackToSavepoint) String() string + func (node *RollbackToSavepoint) Format(ctx *FmtCtx) + type RollbackTransaction struct + func (*RollbackTransaction) StatementReturnType() StatementReturnType + func (*RollbackTransaction) StatementTag() string + func (*RollbackTransaction) StatementType() StatementType + func (n *RollbackTransaction) String() string + func (node *RollbackTransaction) Format(ctx *FmtCtx) + type RowsFromExpr struct + Items Exprs + func (expr *RowsFromExpr) WalkTableExpr(v Visitor) TableExpr + func (node *RowsFromExpr) Format(ctx *FmtCtx) + type SQLStatsController interface + CreateSQLStatsCompactionSchedule func(ctx context.Context) error + ResetClusterSQLStats func(ctx context.Context) error + type Savepoint struct + Name Name + func (*Savepoint) StatementReturnType() StatementReturnType + func (*Savepoint) StatementTag() string + func (*Savepoint) StatementType() StatementType + func (n *Savepoint) String() string + func (node *Savepoint) Format(ctx *FmtCtx) + type ScalarProperties struct + InWindowFunc bool + SeenAggregate bool + SeenGenerator bool + SeenWindowApplication bool + func (sp *ScalarProperties) Clear() + type Scatter struct + From Exprs + TableOrIndex TableIndexName + To Exprs + func (*Scatter) StatementReturnType() StatementReturnType + func (*Scatter) StatementTag() string + func (*Scatter) StatementType() StatementType + func (n *Scatter) String() string + func (node *Scatter) Format(ctx *FmtCtx) + type ScheduleCommand int + const DropSchedule + const PauseSchedule + const ResumeSchedule + func (c ScheduleCommand) String() string + type ScheduleLabelSpec struct + IfNotExists bool + Label Expr + type ScheduleState int + const ActiveSchedules + const PausedSchedules + const SpecifiedSchedules + func (s ScheduleState) Format(ctx *FmtCtx) + type ScheduledBackup struct + BackupOptions BackupOptions + FullBackup *FullBackupClause + Recurrence Expr + ScheduleLabelSpec ScheduleLabelSpec + ScheduleOptions KVOptions + Targets *TargetList + To StringOrPlaceholderOptList + func (*ScheduledBackup) StatementReturnType() StatementReturnType + func (*ScheduledBackup) StatementTag() string + func (*ScheduledBackup) StatementType() StatementType + func (n *ScheduledBackup) String() string + func (node *ScheduledBackup) Format(ctx *FmtCtx) + func (node ScheduledBackup) Coverage() DescriptorCoverage + type ScheduledJobExecutorType int + const InvalidExecutor + const ScheduledBackupExecutor + const ScheduledRowLevelTTLExecutor + const ScheduledSQLStatsCompactionExecutor + func (t ScheduledJobExecutorType) InternalName() string + func (t ScheduledJobExecutorType) UserName() string + type SchemaFeatureName string + func GetSchemaFeatureNameFromStmt(stmt Statement) SchemaFeatureName + type SchemaLookupFlags = CommonLookupFlags + type Scrub struct + AsOf AsOfClause + Database Name + Options ScrubOptions + Table *UnresolvedObjectName + Typ ScrubType + func (*Scrub) StatementReturnType() StatementReturnType + func (*Scrub) StatementType() StatementType + func (n *Scrub) Format(ctx *FmtCtx) + func (n *Scrub) StatementTag() string + func (n *Scrub) String() string + type ScrubOption interface + type ScrubOptionConstraint struct + ConstraintNames NameList + func (n *ScrubOptionConstraint) Format(ctx *FmtCtx) + func (n *ScrubOptionConstraint) String() string + type ScrubOptionIndex struct + IndexNames NameList + func (n *ScrubOptionIndex) Format(ctx *FmtCtx) + func (n *ScrubOptionIndex) String() string + type ScrubOptionPhysical struct + func (n *ScrubOptionPhysical) Format(ctx *FmtCtx) + func (n *ScrubOptionPhysical) String() string + type ScrubOptions []ScrubOption + func (n *ScrubOptions) Format(ctx *FmtCtx) + func (n *ScrubOptions) String() string + type ScrubType int + type Select struct + Limit *Limit + Locking LockingClause + OrderBy OrderBy + Select SelectStatement + With *With + func (*Select) StatementReturnType() StatementReturnType + func (*Select) StatementTag() string + func (*Select) StatementType() StatementType + func (n *Select) String() string + func (node *Select) Format(ctx *FmtCtx) + type SelectClause struct + Distinct bool + DistinctOn DistinctOn + Exprs SelectExprs + From From + GroupBy GroupBy + Having *Where + TableSelect bool + Where *Where + Window Window + func (*SelectClause) StatementReturnType() StatementReturnType + func (*SelectClause) StatementTag() string + func (*SelectClause) StatementType() StatementType + func (n *SelectClause) String() string + func (node *SelectClause) Format(ctx *FmtCtx) + type SelectExpr struct + As UnrestrictedName + Expr Expr + func StarSelectExpr() SelectExpr + func (node *SelectExpr) Format(ctx *FmtCtx) + func (node *SelectExpr) NormalizeTopLevelVarName() error + type SelectExprs []SelectExpr + func (node *SelectExprs) Format(ctx *FmtCtx) + type SelectStatement interface + type SemaContext struct + Annotations Annotations + DateStyle pgdate.DateStyle + DateStyleEnabled bool + IVarContainer IndexedVarContainer + IntervalStyle duration.IntervalStyle + IntervalStyleEnabled bool + Placeholders PlaceholderInfo + Properties SemaProperties + SearchPath sessiondata.SearchPath + TableNameResolver QualifiedNameResolver + TypeResolver TypeReferenceResolver + func MakeSemaContext() SemaContext + func (sc *SemaContext) GetTypeResolver() TypeReferenceResolver + type SemaProperties struct + Derived ScalarProperties + func (s *SemaProperties) IsSet(rejectFlags SemaRejectFlags) bool + func (s *SemaProperties) Require(context string, rejectFlags SemaRejectFlags) + func (s *SemaProperties) Restore(orig SemaProperties) + type SemaRejectFlags int + const RejectAggregates + const RejectGenerators + const RejectNestedAggregates + const RejectNestedGenerators + const RejectNestedWindowFunctions + const RejectSpecial + const RejectStableOperators + const RejectSubqueries + const RejectVolatileFunctions + const RejectWindowApplications + type SequenceOperators interface + GetLatestValueInSessionForSequenceByID func(ctx context.Context, seqID int64) (int64, error) + GetSerialSequenceNameFromColumn func(ctx context.Context, tableName *TableName, columnName Name) (*TableName, error) + IncrementSequenceByID func(ctx context.Context, seqID int64) (int64, error) + SetSequenceValueByID func(ctx context.Context, seqID uint32, newVal int64, isCalled bool) error + type SequenceOption struct + AsIntegerType *types.T + ColumnItemVal *ColumnItem + IntVal *int64 + Name string + OptionalWord bool + type SequenceOptions []SequenceOption + func (node *SequenceOptions) Format(ctx *FmtCtx) + type SetClusterSetting struct + Name string + Value Expr + func (*SetClusterSetting) StatementReturnType() StatementReturnType + func (*SetClusterSetting) StatementTag() string + func (*SetClusterSetting) StatementType() StatementType + func (n *SetClusterSetting) String() string + func (node *SetClusterSetting) Format(ctx *FmtCtx) + type SetSessionAuthorizationDefault struct + func (*SetSessionAuthorizationDefault) StatementReturnType() StatementReturnType + func (*SetSessionAuthorizationDefault) StatementTag() string + func (*SetSessionAuthorizationDefault) StatementType() StatementType + func (n *SetSessionAuthorizationDefault) String() string + func (node *SetSessionAuthorizationDefault) Format(ctx *FmtCtx) + type SetSessionCharacteristics struct + Modes TransactionModes + func (*SetSessionCharacteristics) StatementReturnType() StatementReturnType + func (*SetSessionCharacteristics) StatementTag() string + func (*SetSessionCharacteristics) StatementType() StatementType + func (n *SetSessionCharacteristics) String() string + func (node *SetSessionCharacteristics) Format(ctx *FmtCtx) + type SetTracing struct + Values Exprs + func (*SetTracing) StatementReturnType() StatementReturnType + func (*SetTracing) StatementTag() string + func (*SetTracing) StatementType() StatementType + func (n *SetTracing) String() string + func (node *SetTracing) Format(ctx *FmtCtx) + type SetTransaction struct + Modes TransactionModes + func (*SetTransaction) StatementReturnType() StatementReturnType + func (*SetTransaction) StatementTag() string + func (*SetTransaction) StatementType() StatementType + func (n *SetTransaction) String() string + func (node *SetTransaction) Format(ctx *FmtCtx) + type SetVar struct + Local bool + Name string + Reset bool + ResetAll bool + Values Exprs + func (*SetVar) StatementReturnType() StatementReturnType + func (*SetVar) StatementType() StatementType + func (n *SetVar) StatementTag() string + func (n *SetVar) String() string + func (node *SetVar) Format(ctx *FmtCtx) + type SetZoneConfig struct + AllIndexes bool + Options KVOptions + SetDefault bool + YAMLConfig Expr + func (*SetZoneConfig) StatementReturnType() StatementReturnType + func (*SetZoneConfig) StatementTag() string + func (*SetZoneConfig) StatementType() StatementType + func (n *SetZoneConfig) String() string + func (node *SetZoneConfig) Format(ctx *FmtCtx) + type ShardedIndexDef struct + ShardBuckets Expr + func (node *ShardedIndexDef) Format(ctx *FmtCtx) + type ShardedPrimaryKeyConstraint struct + ShardBuckets Expr + Sharded bool + StorageParams StorageParams + type ShowBackup struct + Details BackupDetails + InCollection Expr + Options KVOptions + Path Expr + ShouldIncludeSchemas bool + func (*ShowBackup) StatementReturnType() StatementReturnType + func (*ShowBackup) StatementTag() string + func (*ShowBackup) StatementType() StatementType + func (n *ShowBackup) String() string + func (node *ShowBackup) Format(ctx *FmtCtx) + type ShowChangefeedJobs struct + Jobs *Select + func (*ShowChangefeedJobs) StatementReturnType() StatementReturnType + func (*ShowChangefeedJobs) StatementTag() string + func (*ShowChangefeedJobs) StatementType() StatementType + func (n *ShowChangefeedJobs) String() string + func (node *ShowChangefeedJobs) Format(ctx *FmtCtx) + type ShowClusterSetting struct + Name string + func (*ShowClusterSetting) StatementReturnType() StatementReturnType + func (*ShowClusterSetting) StatementTag() string + func (*ShowClusterSetting) StatementType() StatementType + func (n *ShowClusterSetting) String() string + func (node *ShowClusterSetting) Format(ctx *FmtCtx) + type ShowClusterSettingList struct + All bool + func (*ShowClusterSettingList) StatementReturnType() StatementReturnType + func (*ShowClusterSettingList) StatementTag() string + func (*ShowClusterSettingList) StatementType() StatementType + func (n *ShowClusterSettingList) String() string + func (node *ShowClusterSettingList) Format(ctx *FmtCtx) + type ShowColumns struct + Table *UnresolvedObjectName + WithComment bool + func (*ShowColumns) StatementReturnType() StatementReturnType + func (*ShowColumns) StatementTag() string + func (*ShowColumns) StatementType() StatementType + func (n *ShowColumns) String() string + func (node *ShowColumns) Format(ctx *FmtCtx) + type ShowCompletions struct + Offset *NumVal + Statement *StrVal + func (*ShowCompletions) StatementReturnType() StatementReturnType + func (*ShowCompletions) StatementTag() string + func (*ShowCompletions) StatementType() StatementType + func (n *ShowCompletions) String() string + func (s ShowCompletions) Format(ctx *FmtCtx) + type ShowConstraints struct + Table *UnresolvedObjectName + WithComment bool + func (*ShowConstraints) StatementReturnType() StatementReturnType + func (*ShowConstraints) StatementTag() string + func (*ShowConstraints) StatementType() StatementType + func (n *ShowConstraints) String() string + func (node *ShowConstraints) Format(ctx *FmtCtx) + type ShowCreate struct + Mode ShowCreateMode + Name *UnresolvedObjectName + func (*ShowCreate) StatementReturnType() StatementReturnType + func (*ShowCreate) StatementTag() string + func (*ShowCreate) StatementType() StatementType + func (n *ShowCreate) String() string + func (node *ShowCreate) Format(ctx *FmtCtx) + type ShowCreateAllSchemas struct + func (*ShowCreateAllSchemas) StatementReturnType() StatementReturnType + func (*ShowCreateAllSchemas) StatementTag() string + func (*ShowCreateAllSchemas) StatementType() StatementType + func (node *ShowCreateAllSchemas) Format(ctx *FmtCtx) + func (node *ShowCreateAllSchemas) String() string + type ShowCreateAllTables struct + func (*ShowCreateAllTables) StatementReturnType() StatementReturnType + func (*ShowCreateAllTables) StatementTag() string + func (*ShowCreateAllTables) StatementType() StatementType + func (node *ShowCreateAllTables) Format(ctx *FmtCtx) + func (node *ShowCreateAllTables) String() string + type ShowCreateAllTypes struct + func (*ShowCreateAllTypes) StatementReturnType() StatementReturnType + func (*ShowCreateAllTypes) StatementTag() string + func (*ShowCreateAllTypes) StatementType() StatementType + func (node *ShowCreateAllTypes) Format(ctx *FmtCtx) + func (node *ShowCreateAllTypes) String() string + type ShowCreateMode int + const ShowCreateModeDatabase + const ShowCreateModeSequence + const ShowCreateModeTable + const ShowCreateModeView + type ShowCreateSchedules struct + ScheduleID Expr + func (*ShowCreateSchedules) StatementReturnType() StatementReturnType + func (*ShowCreateSchedules) StatementTag() string + func (*ShowCreateSchedules) StatementType() StatementType + func (n *ShowCreateSchedules) String() string + func (node *ShowCreateSchedules) Format(ctx *FmtCtx) + type ShowDatabaseIndexes struct + Database Name + WithComment bool + func (*ShowDatabaseIndexes) StatementReturnType() StatementReturnType + func (*ShowDatabaseIndexes) StatementTag() string + func (*ShowDatabaseIndexes) StatementType() StatementType + func (n *ShowDatabaseIndexes) String() string + func (node *ShowDatabaseIndexes) Format(ctx *FmtCtx) + type ShowDatabases struct + WithComment bool + func (*ShowDatabases) StatementReturnType() StatementReturnType + func (*ShowDatabases) StatementTag() string + func (*ShowDatabases) StatementType() StatementType + func (n *ShowDatabases) String() string + func (node *ShowDatabases) Format(ctx *FmtCtx) + type ShowDefaultPrivileges struct + ForAllRoles bool + Roles RoleSpecList + func (*ShowDefaultPrivileges) StatementReturnType() StatementReturnType + func (*ShowDefaultPrivileges) StatementTag() string + func (*ShowDefaultPrivileges) StatementType() StatementType + func (n *ShowDefaultPrivileges) Format(ctx *FmtCtx) + func (n *ShowDefaultPrivileges) String() string + type ShowEnums struct + func (*ShowEnums) StatementReturnType() StatementReturnType + func (*ShowEnums) StatementTag() string + func (*ShowEnums) StatementType() StatementType + func (n *ShowEnums) String() string + func (node *ShowEnums) Format(ctx *FmtCtx) + type ShowFingerprints struct + Table *UnresolvedObjectName + func (*ShowFingerprints) StatementReturnType() StatementReturnType + func (*ShowFingerprints) StatementTag() string + func (*ShowFingerprints) StatementType() StatementType + func (n *ShowFingerprints) String() string + func (node *ShowFingerprints) Format(ctx *FmtCtx) + type ShowFullTableScans struct + func (*ShowFullTableScans) StatementReturnType() StatementReturnType + func (*ShowFullTableScans) StatementTag() string + func (*ShowFullTableScans) StatementType() StatementType + func (n *ShowFullTableScans) String() string + func (node *ShowFullTableScans) Format(ctx *FmtCtx) + type ShowGrants struct + Grantees RoleSpecList + Targets *TargetList + func (*ShowGrants) StatementReturnType() StatementReturnType + func (*ShowGrants) StatementTag() string + func (*ShowGrants) StatementType() StatementType + func (n *ShowGrants) String() string + func (node *ShowGrants) Format(ctx *FmtCtx) + type ShowHistogram struct + HistogramID int64 + func (*ShowHistogram) StatementReturnType() StatementReturnType + func (*ShowHistogram) StatementTag() string + func (*ShowHistogram) StatementType() StatementType + func (n *ShowHistogram) String() string + func (node *ShowHistogram) Format(ctx *FmtCtx) + type ShowIndexes struct + Table *UnresolvedObjectName + WithComment bool + func (*ShowIndexes) StatementReturnType() StatementReturnType + func (*ShowIndexes) StatementTag() string + func (*ShowIndexes) StatementType() StatementType + func (n *ShowIndexes) String() string + func (node *ShowIndexes) Format(ctx *FmtCtx) + type ShowJobs struct + Automatic bool + Block bool + Jobs *Select + Schedules *Select + func (*ShowJobs) StatementReturnType() StatementReturnType + func (*ShowJobs) StatementTag() string + func (*ShowJobs) StatementType() StatementType + func (n *ShowJobs) String() string + func (node *ShowJobs) Format(ctx *FmtCtx) + type ShowLastQueryStatistics struct + Columns NameList + func (*ShowLastQueryStatistics) StatementReturnType() StatementReturnType + func (*ShowLastQueryStatistics) StatementTag() string + func (*ShowLastQueryStatistics) StatementType() StatementType + func (n *ShowLastQueryStatistics) String() string + func (node *ShowLastQueryStatistics) Format(ctx *FmtCtx) + type ShowPartitions struct + Database Name + Index TableIndexName + IsDB bool + IsIndex bool + IsTable bool + Table *UnresolvedObjectName + func (*ShowPartitions) StatementReturnType() StatementReturnType + func (*ShowPartitions) StatementTag() string + func (*ShowPartitions) StatementType() StatementType + func (n *ShowPartitions) String() string + func (node *ShowPartitions) Format(ctx *FmtCtx) + type ShowQueries struct + All bool + Cluster bool + func (*ShowQueries) StatementReturnType() StatementReturnType + func (*ShowQueries) StatementTag() string + func (*ShowQueries) StatementType() StatementType + func (n *ShowQueries) String() string + func (node *ShowQueries) Format(ctx *FmtCtx) + type ShowRangeForRow struct + Row Exprs + TableOrIndex TableIndexName + func (*ShowRangeForRow) StatementReturnType() StatementReturnType + func (*ShowRangeForRow) StatementTag() string + func (*ShowRangeForRow) StatementType() StatementType + func (n *ShowRangeForRow) String() string + func (node *ShowRangeForRow) Format(ctx *FmtCtx) + type ShowRanges struct + DatabaseName Name + TableOrIndex TableIndexName + func (*ShowRanges) StatementReturnType() StatementReturnType + func (*ShowRanges) StatementTag() string + func (*ShowRanges) StatementType() StatementType + func (n *ShowRanges) String() string + func (node *ShowRanges) Format(ctx *FmtCtx) + type ShowRegions struct + DatabaseName Name + ShowRegionsFrom ShowRegionsFrom + func (*ShowRegions) StatementReturnType() StatementReturnType + func (*ShowRegions) StatementTag() string + func (*ShowRegions) StatementType() StatementType + func (n *ShowRegions) String() string + func (node *ShowRegions) Format(ctx *FmtCtx) + type ShowRegionsFrom int + const ShowRegionsFromAllDatabases + const ShowRegionsFromCluster + const ShowRegionsFromDatabase + const ShowRegionsFromDefault + type ShowRoleGrants struct + Grantees RoleSpecList + Roles RoleSpecList + func (*ShowRoleGrants) StatementReturnType() StatementReturnType + func (*ShowRoleGrants) StatementTag() string + func (*ShowRoleGrants) StatementType() StatementType + func (n *ShowRoleGrants) String() string + func (node *ShowRoleGrants) Format(ctx *FmtCtx) + type ShowRoles struct + func (*ShowRoles) StatementReturnType() StatementReturnType + func (*ShowRoles) StatementTag() string + func (*ShowRoles) StatementType() StatementType + func (n *ShowRoles) String() string + func (node *ShowRoles) Format(ctx *FmtCtx) + type ShowSavepointStatus struct + func (*ShowSavepointStatus) StatementReturnType() StatementReturnType + func (*ShowSavepointStatus) StatementTag() string + func (*ShowSavepointStatus) StatementType() StatementType + func (n *ShowSavepointStatus) String() string + func (node *ShowSavepointStatus) Format(ctx *FmtCtx) + type ShowSchedules struct + ExecutorType ScheduledJobExecutorType + ScheduleID Expr + WhichSchedules ScheduleState + func (*ShowSchedules) StatementReturnType() StatementReturnType + func (*ShowSchedules) StatementTag() string + func (*ShowSchedules) StatementType() StatementType + func (n *ShowSchedules) Format(ctx *FmtCtx) + func (n *ShowSchedules) String() string + type ShowSchemas struct + Database Name + func (*ShowSchemas) StatementReturnType() StatementReturnType + func (*ShowSchemas) StatementTag() string + func (*ShowSchemas) StatementType() StatementType + func (n *ShowSchemas) String() string + func (node *ShowSchemas) Format(ctx *FmtCtx) + type ShowSequences struct + Database Name + func (*ShowSequences) StatementReturnType() StatementReturnType + func (*ShowSequences) StatementTag() string + func (*ShowSequences) StatementType() StatementType + func (n *ShowSequences) String() string + func (node *ShowSequences) Format(ctx *FmtCtx) + type ShowSessions struct + All bool + Cluster bool + func (*ShowSessions) StatementReturnType() StatementReturnType + func (*ShowSessions) StatementTag() string + func (*ShowSessions) StatementType() StatementType + func (n *ShowSessions) String() string + func (node *ShowSessions) Format(ctx *FmtCtx) + type ShowSurvivalGoal struct + DatabaseName Name + func (*ShowSurvivalGoal) StatementReturnType() StatementReturnType + func (*ShowSurvivalGoal) StatementTag() string + func (*ShowSurvivalGoal) StatementType() StatementType + func (n *ShowSurvivalGoal) String() string + func (node *ShowSurvivalGoal) Format(ctx *FmtCtx) + type ShowSyntax struct + Statement string + func (*ShowSyntax) StatementReturnType() StatementReturnType + func (*ShowSyntax) StatementTag() string + func (*ShowSyntax) StatementType() StatementType + func (n *ShowSyntax) String() string + func (node *ShowSyntax) Format(ctx *FmtCtx) + type ShowTableStats struct + Table *UnresolvedObjectName + UsingJSON bool + func (*ShowTableStats) StatementReturnType() StatementReturnType + func (*ShowTableStats) StatementTag() string + func (*ShowTableStats) StatementType() StatementType + func (n *ShowTableStats) String() string + func (node *ShowTableStats) Format(ctx *FmtCtx) + type ShowTables struct + WithComment bool + func (*ShowTables) StatementReturnType() StatementReturnType + func (*ShowTables) StatementTag() string + func (*ShowTables) StatementType() StatementType + func (n *ShowTables) String() string + func (node *ShowTables) Format(ctx *FmtCtx) + type ShowTenantClusterSetting struct + TenantID Expr + func (*ShowTenantClusterSetting) StatementReturnType() StatementReturnType + func (*ShowTenantClusterSetting) StatementTag() string + func (*ShowTenantClusterSetting) StatementType() StatementType + func (n *ShowTenantClusterSetting) String() string + func (node *ShowTenantClusterSetting) Format(ctx *FmtCtx) + type ShowTenantClusterSettingList struct + TenantID Expr + func (*ShowTenantClusterSettingList) StatementReturnType() StatementReturnType + func (*ShowTenantClusterSettingList) StatementTag() string + func (*ShowTenantClusterSettingList) StatementType() StatementType + func (n *ShowTenantClusterSettingList) String() string + func (node *ShowTenantClusterSettingList) Format(ctx *FmtCtx) + type ShowTraceForSession struct + Compact bool + TraceType ShowTraceType + func (*ShowTraceForSession) StatementReturnType() StatementReturnType + func (*ShowTraceForSession) StatementTag() string + func (*ShowTraceForSession) StatementType() StatementType + func (n *ShowTraceForSession) String() string + func (node *ShowTraceForSession) Format(ctx *FmtCtx) + type ShowTraceType string + const ShowTraceKV + const ShowTraceRaw + const ShowTraceReplica + type ShowTransactionStatus struct + func (*ShowTransactionStatus) StatementReturnType() StatementReturnType + func (*ShowTransactionStatus) StatementTag() string + func (*ShowTransactionStatus) StatementType() StatementType + func (n *ShowTransactionStatus) String() string + func (node *ShowTransactionStatus) Format(ctx *FmtCtx) + type ShowTransactions struct + All bool + Cluster bool + func (*ShowTransactions) StatementReturnType() StatementReturnType + func (*ShowTransactions) StatementTag() string + func (*ShowTransactions) StatementType() StatementType + func (n *ShowTransactions) String() string + func (node *ShowTransactions) Format(ctx *FmtCtx) + type ShowTransferState struct + TransferKey *StrVal + func (*ShowTransferState) StatementReturnType() StatementReturnType + func (*ShowTransferState) StatementTag() string + func (*ShowTransferState) StatementType() StatementType + func (n *ShowTransferState) String() string + func (node *ShowTransferState) Format(ctx *FmtCtx) + type ShowTypes struct + func (*ShowTypes) StatementReturnType() StatementReturnType + func (*ShowTypes) StatementTag() string + func (*ShowTypes) StatementType() StatementType + func (n *ShowTypes) String() string + func (node *ShowTypes) Format(ctx *FmtCtx) + type ShowUsers struct + func (*ShowUsers) StatementReturnType() StatementReturnType + func (*ShowUsers) StatementTag() string + func (*ShowUsers) StatementType() StatementType + func (n *ShowUsers) String() string + func (node *ShowUsers) Format(ctx *FmtCtx) + type ShowVar struct + Name string + func (*ShowVar) StatementReturnType() StatementReturnType + func (*ShowVar) StatementTag() string + func (*ShowVar) StatementType() StatementType + func (n *ShowVar) String() string + func (node *ShowVar) Format(ctx *FmtCtx) + type ShowZoneConfig struct + func (*ShowZoneConfig) StatementReturnType() StatementReturnType + func (*ShowZoneConfig) StatementTag() string + func (*ShowZoneConfig) StatementType() StatementType + func (n *ShowZoneConfig) String() string + func (node *ShowZoneConfig) Format(ctx *FmtCtx) + type SimpleVisitFn func(expr Expr) (recurse bool, newExpr Expr, err error) + type SpecializedVectorizedBuiltin int + const SubstringStringIntInt + type Split struct + ExpireExpr Expr + Rows *Select + TableOrIndex TableIndexName + func (*Split) StatementReturnType() StatementReturnType + func (*Split) StatementTag() string + func (*Split) StatementType() StatementType + func (n *Split) String() string + func (node *Split) Format(ctx *FmtCtx) + type Statement interface + StatementReturnType func() StatementReturnType + StatementTag func() string + StatementType func() StatementType + func MakeExplain(options []string, stmt Statement) (Statement, error) + func SimpleStmtVisit(stmt Statement, preFn SimpleVisitFn) (Statement, error) + type StatementReturnType int + const Ack + const CopyIn + const DDL + const Rows + const RowsAffected + const Unknown + func (i StatementReturnType) String() string + type StatementSource struct + Statement Statement + func (expr *StatementSource) WalkTableExpr(v Visitor) TableExpr + func (node *StatementSource) Format(ctx *FmtCtx) + type StatementType int + const TypeDCL + const TypeDDL + const TypeDML + const TypeTCL + func (i StatementType) String() string + type StorageParam struct + Key Name + Value Expr + type StorageParams []StorageParam + func (o *StorageParams) Format(ctx *FmtCtx) + func (o *StorageParams) GetVal(key string) Expr + type StrVal struct + func NewBytesStrVal(s string) *StrVal + func NewStrVal(s string) *StrVal + func (expr *StrVal) AvailableTypes() []*types.T + func (expr *StrVal) DesirableTypes() []*types.T + func (expr *StrVal) Format(ctx *FmtCtx) + func (expr *StrVal) RawString() string + func (expr *StrVal) ResolveAsType(ctx context.Context, semaCtx *SemaContext, typ *types.T) (TypedExpr, error) + func (expr *StrVal) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *StrVal) Walk(_ Visitor) Expr + func (node *StrVal) String() string + type StreamIngestion struct + AsOf AsOfClause + From StringOrPlaceholderOptList + Targets TargetList + func (*StreamIngestion) StatementReturnType() StatementReturnType + func (*StreamIngestion) StatementTag() string + func (*StreamIngestion) StatementType() StatementType + func (n *StreamIngestion) String() string + func (node *StreamIngestion) Format(ctx *FmtCtx) + type StringOrPlaceholderOptList []Expr + func (node *StringOrPlaceholderOptList) Format(ctx *FmtCtx) + type Subquery struct + Exists bool + Idx int + Select SelectStatement + func (*Subquery) SubqueryExpr() + func (*Subquery) Variable() + func (expr *Subquery) Eval(ctx *EvalContext) (Datum, error) + func (expr *Subquery) TypeCheck(_ context.Context, sc *SemaContext, _ *types.T) (TypedExpr, error) + func (expr *Subquery) Walk(v Visitor) Expr + func (expr *Subquery) WalkTableExpr(v Visitor) TableExpr + func (node *Subquery) Format(ctx *FmtCtx) + func (node *Subquery) SetType(t *types.T) + func (node *Subquery) String() string + func (ta Subquery) ResolvedType() *types.T + type SubqueryExpr interface + SubqueryExpr func() + type SurvivalGoal uint32 + const SurvivalGoalDefault + const SurvivalGoalRegionFailure + const SurvivalGoalZoneFailure + func (node *SurvivalGoal) Format(ctx *FmtCtx) + func (node *SurvivalGoal) TelemetryName() string + type TableDef interface + type TableDefs []TableDef + func (node *TableDefs) Format(ctx *FmtCtx) + type TableExpr interface + WalkTableExpr func(Visitor) TableExpr + func StripTableParens(expr TableExpr) TableExpr + type TableExprs []TableExpr + func (node *TableExprs) Format(ctx *FmtCtx) + type TableIndexName struct + Index UnrestrictedName + Table TableName + func (n *TableIndexName) Format(ctx *FmtCtx) + func (n *TableIndexName) String() string + type TableIndexNames []*TableIndexName + func (n *TableIndexNames) Format(ctx *FmtCtx) + type TableName struct + func MakeTableNameFromPrefix(prefix ObjectNamePrefix, object Name) TableName + func MakeTableNameWithSchema(db, schema, tbl Name) TableName + func MakeUnqualifiedTableName(tbl Name) TableName + func NewTableNameWithSchema(db, sc, tbl Name) *TableName + func NewUnqualifiedTableName(tbl Name) *TableName + func (expr *TableName) WalkTableExpr(_ Visitor) TableExpr + func (o *TableName) Object() string + func (o *TableName) ToUnresolvedObjectName() *UnresolvedObjectName + func (t *TableName) Equals(other *TableName) bool + func (t *TableName) FQString() string + func (t *TableName) Format(ctx *FmtCtx) + func (t *TableName) NormalizeTablePattern() (TablePattern, error) + func (t *TableName) String() string + func (t *TableName) Table() string + type TableNames []TableName + func (ts *TableNames) Format(ctx *FmtCtx) + func (ts *TableNames) String() string + type TablePattern interface + NormalizeTablePattern func() (TablePattern, error) + type TablePatterns []TablePattern + func (tt *TablePatterns) Format(ctx *FmtCtx) + type TableRef struct + As AliasClause + Columns []ColumnID + TableID int64 + func (expr *TableRef) WalkTableExpr(_ Visitor) TableExpr + func (n *TableRef) Format(ctx *FmtCtx) + func (n *TableRef) String() string + type TargetList struct + AllTablesInSchema bool + Databases NameList + ForRoles bool + Roles RoleSpecList + Schemas ObjectNamePrefixList + SystemUser bool + Tables TablePatterns + TenantID TenantID + Types []*UnresolvedObjectName + func (tl *TargetList) Format(ctx *FmtCtx) + type TenantID struct + Specified bool + func (t *TenantID) Format(ctx *FmtCtx) + type TenantOperator interface + CreateTenant func(ctx context.Context, tenantID uint64) error + DestroyTenant func(ctx context.Context, tenantID uint64, synchronous bool) error + GCTenant func(ctx context.Context, tenantID uint64) error + UpdateTenantResourceLimits func(ctx context.Context, tenantID uint64, availableRU float64, refillRate float64, ...) error + type TestingMapTypeResolver struct + func (dtr *TestingMapTypeResolver) ResolveType(_ context.Context, name *UnresolvedObjectName) (*types.T, error) + func (dtr *TestingMapTypeResolver) ResolveTypeByOID(context.Context, oid.Oid) (*types.T, error) + type TransactionModes struct + AsOf AsOfClause + Deferrable DeferrableMode + Isolation IsolationLevel + ReadWriteMode ReadWriteMode + UserPriority UserPriority + func (node *TransactionModes) Format(ctx *FmtCtx) + func (node *TransactionModes) Merge(other TransactionModes) error + type Truncate struct + DropBehavior DropBehavior + Tables TableNames + func (*Truncate) StatementReturnType() StatementReturnType + func (*Truncate) StatementTag() string + func (*Truncate) StatementType() StatementType + func (n *Truncate) String() string + func (node *Truncate) Format(ctx *FmtCtx) + type Tuple struct + Exprs Exprs + Labels []string + Row bool + func NewTypedTuple(typ *types.T, typedExprs Exprs) *Tuple + func (expr *Tuple) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *Tuple) Walk(v Visitor) Expr + func (node *Tuple) Format(ctx *FmtCtx) + func (node *Tuple) ResolvedType() *types.T + func (node *Tuple) String() string + func (t *Tuple) Eval(ctx *EvalContext) (Datum, error) + type TupleStar struct + Expr Expr + func (expr *TupleStar) Eval(ctx *EvalContext) (Datum, error) + func (expr *TupleStar) ResolvedType() *types.T + func (expr *TupleStar) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *TupleStar) Walk(v Visitor) Expr + func (node *TupleStar) Format(ctx *FmtCtx) + func (node *TupleStar) NormalizeVarName() (VarName, error) + func (node *TupleStar) String() string + type TwoArgFn func(*EvalContext, Datum, Datum) (Datum, error) + func FindEqualComparisonFunction(leftType, rightType *types.T) (TwoArgFn, bool) + type TypeCollectorVisitor struct + OIDs map[oid.Oid]struct{} + func (v *TypeCollectorVisitor) VisitPost(e Expr) Expr + func (v *TypeCollectorVisitor) VisitPre(expr Expr) (bool, Expr) + type TypeList interface + GetAt func(i int) *types.T + Length func() int + Match func(types []*types.T) bool + MatchAt func(typ *types.T, i int) bool + MatchLen func(l int) bool + String func() string + Types func() []*types.T + type TypeName struct + func MakeQualifiedTypeName(db, schema, typ string) TypeName + func MakeSchemaQualifiedTypeName(schema, typ string) TypeName + func MakeTypeNameWithPrefix(prefix ObjectNamePrefix, typ string) TypeName + func MakeUnqualifiedTypeName(typ string) TypeName + func NewQualifiedTypeName(db, schema, typ string) *TypeName + func NewUnqualifiedTypeName(typ string) *TypeName + func (o *TypeName) Object() string + func (o *TypeName) ToUnresolvedObjectName() *UnresolvedObjectName + func (t *TypeName) FQString() string + func (t *TypeName) Format(ctx *FmtCtx) + func (t *TypeName) SQLString() string + func (t *TypeName) String() string + func (t *TypeName) Type() string + type TypeReferenceResolver interface + ResolveType func(ctx context.Context, name *UnresolvedObjectName) (*types.T, error) + ResolveTypeByOID func(ctx context.Context, oid oid.Oid) (*types.T, error) + func MakeTestingMapTypeResolver(typeMap map[string]*types.T) TypeReferenceResolver + type TypeResolver interface + ResolveOIDFromOID func(ctx context.Context, resultType *types.T, toResolve *DOid) (*DOid, error) + ResolveOIDFromString func(ctx context.Context, resultType *types.T, toResolve *DString) (*DOid, error) + type TypedDummy struct + Typ *types.T + func (node *TypedDummy) Eval(*EvalContext) (Datum, error) + func (node *TypedDummy) Format(ctx *FmtCtx) + func (node *TypedDummy) ResolvedType() *types.T + func (node *TypedDummy) String() string + func (node *TypedDummy) TypeCheck(context.Context, *SemaContext, *types.T) (TypedExpr, error) + func (node *TypedDummy) Walk(Visitor) Expr + type TypedExpr interface + Eval func(*EvalContext) (Datum, error) + ResolvedType func() *types.T + func ReType(expr TypedExpr, wantedType *types.T) (_ TypedExpr, ok bool) + func TypeCheck(ctx context.Context, expr Expr, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func TypeCheckAndRequire(ctx context.Context, expr Expr, semaCtx *SemaContext, required *types.T, ...) (TypedExpr, error) + func TypeCheckSameTypedExprs(ctx context.Context, semaCtx *SemaContext, desired *types.T, exprs ...Expr) ([]TypedExpr, *types.T, error) + type TypedExprs []TypedExpr + func (node *TypedExprs) String() string + type UnaryExpr struct + Expr Expr + Operator UnaryOperator + func NewTypedUnaryExpr(op UnaryOperator, expr TypedExpr, typ *types.T) *UnaryExpr + func (expr *UnaryExpr) Eval(ctx *EvalContext) (Datum, error) + func (expr *UnaryExpr) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *UnaryExpr) Walk(v Visitor) Expr + func (node *UnaryExpr) Format(ctx *FmtCtx) + func (node *UnaryExpr) String() string + func (node *UnaryExpr) TypedInnerExpr() TypedExpr + func (ta UnaryExpr) ResolvedType() *types.T + type UnaryOp struct + Fn func(*EvalContext, Datum) (Datum, error) + ReturnType *types.T + Typ *types.T + Volatility Volatility + type UnaryOperator struct + IsExplicitOperator bool + Symbol UnaryOperatorSymbol + func MakeUnaryOperator(symbol UnaryOperatorSymbol) UnaryOperator + func (UnaryOperator) Operator() + func (o UnaryOperator) String() string + type UnaryOperatorSymbol uint8 + const NumUnaryOperatorSymbols + const UnaryCbrt + const UnaryComplement + const UnaryMinus + const UnaryPlus + const UnarySqrt + func (i UnaryOperatorSymbol) String() string + type UnionClause struct + All bool + Left *Select + Right *Select + Type UnionType + func (*UnionClause) StatementReturnType() StatementReturnType + func (*UnionClause) StatementTag() string + func (*UnionClause) StatementType() StatementType + func (n *UnionClause) String() string + func (node *UnionClause) Format(ctx *FmtCtx) + type UnionType int + const ExceptOp + const IntersectOp + const UnionOp + func (i UnionType) String() string + type UniqueConstraint struct + WithoutIndex bool + type UniqueConstraintTableDef struct + IfNotExists bool + PrimaryKey bool + WithoutIndex bool + func (node *UniqueConstraintTableDef) Format(ctx *FmtCtx) + func (node *UniqueConstraintTableDef) SetIfNotExists() + func (node *UniqueConstraintTableDef) SetName(name Name) + type UnqualifiedStar struct + func (UnqualifiedStar) Format(ctx *FmtCtx) + func (UnqualifiedStar) ResolvedType() *types.T + func (UnqualifiedStar) Variable() + func (expr UnqualifiedStar) Eval(ctx *EvalContext) (Datum, error) + func (expr UnqualifiedStar) TypeCheck(_ context.Context, _ *SemaContext, desired *types.T) (TypedExpr, error) + func (expr UnqualifiedStar) Walk(_ Visitor) Expr + func (u UnqualifiedStar) NormalizeVarName() (VarName, error) + func (u UnqualifiedStar) String() string + type UnresolvedName struct + NumParts int + Parts NameParts + Star bool + func MakeUnresolvedName(args ...string) UnresolvedName + func NewUnresolvedName(args ...string) *UnresolvedName + func (*UnresolvedName) ResolvedType() *types.T + func (*UnresolvedName) Variable() + func (expr *UnresolvedName) Eval(ctx *EvalContext) (Datum, error) + func (expr *UnresolvedName) TypeCheck(ctx context.Context, semaCtx *SemaContext, desired *types.T) (TypedExpr, error) + func (expr *UnresolvedName) Walk(_ Visitor) Expr + func (n *UnresolvedName) NormalizeTablePattern() (TablePattern, error) + func (n *UnresolvedName) NormalizeVarName() (VarName, error) + func (n *UnresolvedName) ResolveFunction(searchPath sessiondata.SearchPath) (*FunctionDefinition, error) + func (u *UnresolvedName) Format(ctx *FmtCtx) + func (u *UnresolvedName) String() string + func (u *UnresolvedName) ToUnresolvedObjectName(idx AnnotationIdx) (*UnresolvedObjectName, error) + type UnresolvedObjectName struct + NumParts int + Parts [3]string + func NewUnresolvedObjectName(numParts int, parts [3]string, annotationIdx AnnotationIdx) (*UnresolvedObjectName, error) + func (expr *UnresolvedObjectName) WalkTableExpr(_ Visitor) TableExpr + func (name *UnresolvedObjectName) SQLString() string + func (u *UnresolvedObjectName) Catalog() string + func (u *UnresolvedObjectName) Format(ctx *FmtCtx) + func (u *UnresolvedObjectName) HasExplicitCatalog() bool + func (u *UnresolvedObjectName) HasExplicitSchema() bool + func (u *UnresolvedObjectName) Object() string + func (u *UnresolvedObjectName) Resolved(ann *Annotations) ObjectName + func (u *UnresolvedObjectName) Schema() string + func (u *UnresolvedObjectName) String() string + func (u *UnresolvedObjectName) ToTableName() TableName + func (u *UnresolvedObjectName) ToUnresolvedName() *UnresolvedName + type UnrestrictedName string + func (node *UnrestrictedName) String() string + func (u *UnrestrictedName) Format(ctx *FmtCtx) + type Unsplit struct + All bool + Rows *Select + TableOrIndex TableIndexName + func (*Unsplit) StatementReturnType() StatementReturnType + func (*Unsplit) StatementTag() string + func (*Unsplit) StatementType() StatementType + func (n *Unsplit) String() string + func (node *Unsplit) Format(ctx *FmtCtx) + type UnsupportedError struct + Err error + FeatureName string + func (u *UnsupportedError) Cause() error + func (u *UnsupportedError) Error() string + func (u *UnsupportedError) Unwrap() error + type Update struct + Exprs UpdateExprs + From TableExprs + Limit *Limit + OrderBy OrderBy + Returning ReturningClause + Table TableExpr + Where *Where + With *With + func (*Update) StatementTag() string + func (*Update) StatementType() StatementType + func (n *Update) StatementReturnType() StatementReturnType + func (n *Update) String() string + func (node *Update) Format(ctx *FmtCtx) + type UpdateExpr struct + Expr Expr + Names NameList + Tuple bool + func (node *UpdateExpr) Format(ctx *FmtCtx) + type UpdateExprs []*UpdateExpr + func (node *UpdateExprs) Format(ctx *FmtCtx) + type UserPriority int + const High + const Low + const Normal + const UnspecifiedUserPriority + func UserPriorityFromString(val string) (_ UserPriority, ok bool) + func (up UserPriority) String() string + type UsingJoinCond struct + Cols NameList + func (node *UsingJoinCond) Format(ctx *FmtCtx) + type ValidationBehavior int + const ValidationDefault + const ValidationSkip + type ValueGenerator interface + Close func(ctx context.Context) + Next func(context.Context) (bool, error) + ResolvedType func() *types.T + Start func(ctx context.Context, txn *kv.Txn) error + Values func() (Datums, error) + type ValuesClause struct + Rows []Exprs + func (*ValuesClause) StatementReturnType() StatementReturnType + func (*ValuesClause) StatementTag() string + func (*ValuesClause) StatementType() StatementType + func (n *ValuesClause) String() string + func (node *ValuesClause) Format(ctx *FmtCtx) + type VarName interface + NormalizeVarName func() (VarName, error) + func StarExpr() VarName + type VariableExpr interface + Variable func() + type VariadicType struct + FixedTypes []*types.T + VarType *types.T + func (v VariadicType) GetAt(i int) *types.T + func (v VariadicType) Length() int + func (v VariadicType) Match(types []*types.T) bool + func (v VariadicType) MatchAt(typ *types.T, i int) bool + func (v VariadicType) MatchLen(l int) bool + func (v VariadicType) String() string + func (v VariadicType) Types() []*types.T + type Visitor interface + VisitPost func(expr Expr) (newNode Expr) + VisitPre func(expr Expr) (recurse bool, newExpr Expr) + type Volatility int8 + const VolatilityImmutable + const VolatilityLeakProof + const VolatilityStable + const VolatilityVolatile + func LookupCastVolatility(from, to *types.T, sd *sessiondata.SessionData) (_ Volatility, ok bool) + func VolatilityFromPostgres(provolatile string, proleakproof bool) (Volatility, error) + func (v Volatility) String() string + func (v Volatility) ToPostgres() (provolatile string, proleakproof bool) + type When struct + Cond Expr + Val Expr + func (node *When) Format(ctx *FmtCtx) + type Where struct + Expr Expr + Type string + func NewWhere(typ string, expr Expr) *Where + func (node *Where) Format(ctx *FmtCtx) + type Window []*WindowDef + func (node *Window) Format(ctx *FmtCtx) + type WindowDef struct + Frame *WindowFrame + Name Name + OrderBy OrderBy + Partitions Exprs + RefName Name + func OverrideWindowDef(base *WindowDef, override WindowDef) (WindowDef, error) + func (node *WindowDef) Format(ctx *FmtCtx) + type WindowFrame struct + Bounds WindowFrameBounds + Exclusion treewindow.WindowFrameExclusion + Mode treewindow.WindowFrameMode + func (f *WindowFrame) DefaultFrameExclusion() bool + func (f *WindowFrame) IsDefaultFrame() bool + func (node *WindowFrame) Format(ctx *FmtCtx) + type WindowFrameBound struct + BoundType treewindow.WindowFrameBoundType + OffsetExpr Expr + func (node *WindowFrameBound) Format(ctx *FmtCtx) + func (node *WindowFrameBound) HasOffset() bool + type WindowFrameBounds struct + EndBound *WindowFrameBound + StartBound *WindowFrameBound + func (node *WindowFrameBounds) HasOffset() bool + type WindowFrameRangeOps struct + func (o WindowFrameRangeOps) LookupImpl(left, right *types.T) (*BinOp, *BinOp, bool) + type WindowFrameRun struct + ArgsIdxs []uint32 + CurRowPeerGroupNum int + EndBoundOffset Datum + FilterColIdx int + Frame *WindowFrame + MinusOp *BinOp + OrdColIdx int + OrdDirection encoding.Direction + PeerHelper PeerGroupsIndicesHelper + PlusOp *BinOp + RowIdx int + Rows IndexedRows + StartBoundOffset Datum + func (wfr *WindowFrameRun) Args(ctx context.Context) (Datums, error) + func (wfr *WindowFrameRun) ArgsByRowIdx(ctx context.Context, idx int) (Datums, error) + func (wfr *WindowFrameRun) ArgsWithRowOffset(ctx context.Context, offset int) (Datums, error) + func (wfr *WindowFrameRun) DefaultFrameSize() int + func (wfr *WindowFrameRun) FirstInPeerGroup() bool + func (wfr *WindowFrameRun) FrameEndIdx(ctx context.Context, evalCtx *EvalContext) (int, error) + func (wfr *WindowFrameRun) FrameSize(ctx context.Context, evalCtx *EvalContext) (int, error) + func (wfr *WindowFrameRun) FrameStartIdx(ctx context.Context, evalCtx *EvalContext) (int, error) + func (wfr *WindowFrameRun) FullPartitionIsInWindow() bool + func (wfr *WindowFrameRun) IsRowSkipped(ctx context.Context, idx int) (bool, error) + func (wfr *WindowFrameRun) PartitionSize() int + func (wfr *WindowFrameRun) RangeModeWithOffsets() bool + func (wfr *WindowFrameRun) Rank() int + type WindowFunc interface + Close func(context.Context, *EvalContext) + Compute func(context.Context, *EvalContext, *WindowFrameRun) (Datum, error) + Reset func(context.Context) + type With struct + CTEList []*CTE + Recursive bool + func (node *With) Format(ctx *FmtCtx) + type ZoneSpecifier struct + Database Name + NamedZone UnrestrictedName + Partition Name + TableOrIndex TableIndexName + func (node *ZoneSpecifier) Format(ctx *FmtCtx) + func (node *ZoneSpecifier) String() string + func (node ZoneSpecifier) TargetsIndex() bool + func (node ZoneSpecifier) TargetsPartition() bool + func (node ZoneSpecifier) TargetsTable() bool + func (node ZoneSpecifier) TelemetryName() string
Go to main page