schema

package
v2.0.0 Latest Latest
Warning

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

 Go to latest Published: Aug 18, 2025 License: Apache-2.0 Imports: 7 Imported by: 6

Documentation

Index

Constants

View Source 
const (
	// XHasuraNDCVersion is the name of header that the engine includes in every request.
	// It indicates the expected NDC spec version from the engine.
	XHasuraNDCVersion = "X-Hasura-NDC-Version"

	// NDCVersion holds the current supported version of the NDC Go SDK.
	NDCVersion = "0.2.10"
)

Variables

This section is empty.

Functions

This section is empty.

Types

type Aggregate 

type Aggregate map[string]any

Aggregate represents an aggregated query object

func (Aggregate) AsColumnCount 

func (j Aggregate) AsColumnCount() (*AggregateColumnCount, error)

AsColumnCount tries to convert the instance to AggregateColumnCount type.

func (Aggregate) AsSingleColumn 

func (j Aggregate) AsSingleColumn() (*AggregateSingleColumn, error)

AsSingleColumn tries to convert the instance to AggregateSingleColumn type.

func (Aggregate) AsStarCount 

func (j Aggregate) AsStarCount() (*AggregateStarCount, error)

AsStarCount tries to convert the instance to AggregateStarCount type.

func (*Aggregate) FromValue 

func (j *Aggregate) FromValue(raw map[string]any) error

FromValue parses values from a raw object.

func (Aggregate) Interface 

func (j Aggregate) Interface() AggregateEncoder

Interface tries to convert the instance to AggregateEncoder interface.

func (Aggregate) InterfaceT 

func (j Aggregate) InterfaceT() (AggregateEncoder, error)

InterfaceT tries to convert the instance to AggregateEncoder interface safely with explicit error.

func (Aggregate) Type 

func (j Aggregate) Type() (AggregateType, error)

Type gets the type enum of the current type.

func (*Aggregate) UnmarshalJSON 

func (j *Aggregate) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type AggregateCapabilities 

type AggregateCapabilities struct {
	// Does the connector support filtering based on aggregated values
	FilterBy *LeafCapability `json:"filter_by,omitempty" yaml:"filter_by,omitempty" mapstructure:"filter_by,omitempty"`

	// Does the connector support aggregations over groups
	GroupBy *GroupByCapabilities `json:"group_by,omitempty" yaml:"group_by,omitempty" mapstructure:"group_by,omitempty"`
}

type AggregateCapabilitiesSchemaInfo 

type AggregateCapabilitiesSchemaInfo struct {
	// The scalar type which should be used for the return type of count (star_count
	// and column_count) operations.
	CountScalarType string `json:"count_scalar_type" yaml:"count_scalar_type" mapstructure:"count_scalar_type"`
}

func (*AggregateCapabilitiesSchemaInfo) UnmarshalJSON 

func (j *AggregateCapabilitiesSchemaInfo) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type AggregateColumnCount 

type AggregateColumnCount struct {
	// The column to apply the aggregation function to
	Column string `json:"column"               mapstructure:"column"     yaml:"column"`
	// Whether or not only distinct items should be counted.
	Distinct bool `json:"distinct"             mapstructure:"distinct"   yaml:"distinct"`
	// Path to a nested field within an object column.
	FieldPath []string `json:"field_path,omitempty" mapstructure:"field_path" yaml:"field_path,omitempty"`
	// Arguments to satisfy the column specified by 'column'
	Arguments map[string]Argument `json:"arguments,omitempty"  mapstructure:"arguments"  yaml:"arguments,omitempty"`
}

AggregateColumnCount represents an aggregate object which count the number of rows with non-null values in the specified columns. If the distinct flag is set, then the count should only count unique non-null values of those columns.

func NewAggregateColumnCount 

func NewAggregateColumnCount(column string, distinct bool) *AggregateColumnCount

NewAggregateColumnCount creates a new AggregateColumnCount instance.

func (AggregateColumnCount) Encode 

func (ag AggregateColumnCount) Encode() Aggregate

Encode converts the instance to raw Aggregate.

func (AggregateColumnCount) Type 

func (ag AggregateColumnCount) Type() AggregateType

Type return the type name of the instance.

func (AggregateColumnCount) WithArgument 

func (f AggregateColumnCount) WithArgument(
	key string,
	argument ArgumentEncoder,
) *AggregateColumnCount

WithArgument return a new instance with an arguments set.

func (AggregateColumnCount) WithArguments 

func (f AggregateColumnCount) WithArguments(
	arguments map[string]ArgumentEncoder,
) *AggregateColumnCount

WithArguments return a new instance with arguments set.

func (AggregateColumnCount) WithFieldPath 

func (f AggregateColumnCount) WithFieldPath(fieldPath []string) *AggregateColumnCount

WithFieldPath returns a new instance with field_path set.

type AggregateEncoder 

type AggregateEncoder interface {
	Type() AggregateType
	Encode() Aggregate
}

AggregateEncoder abstracts the serialization interface for Aggregate.

type AggregateFunctionDefinition 

type AggregateFunctionDefinition map[string]any

AggregateFunctionDefinition represents the definition of an aggregation function on a scalar type.

func (AggregateFunctionDefinition) AsAverage 

func (j AggregateFunctionDefinition) AsAverage() (*AggregateFunctionDefinitionAverage, error)

AsAverage tries to convert the current type to AggregateFunctionDefinitionAverage.

func (AggregateFunctionDefinition) AsCustom 

func (j AggregateFunctionDefinition) AsCustom() (*AggregateFunctionDefinitionCustom, error)

AsCustom tries to convert the current type to AggregateFunctionDefinitionCustom.

func (AggregateFunctionDefinition) AsMax 

func (j AggregateFunctionDefinition) AsMax() (*AggregateFunctionDefinitionMax, error)

AsMax tries to convert the current type to AggregateFunctionDefinitionMax.

func (AggregateFunctionDefinition) AsMin 

func (j AggregateFunctionDefinition) AsMin() (*AggregateFunctionDefinitionMin, error)

AsMin tries to convert the current type to AggregateFunctionDefinitionMin.

func (AggregateFunctionDefinition) AsSum 

func (j AggregateFunctionDefinition) AsSum() (*AggregateFunctionDefinitionSum, error)

AsSum tries to convert the current type to AggregateFunctionDefinitionSum.

func (AggregateFunctionDefinition) Interface 

func (j AggregateFunctionDefinition) Interface() AggregateFunctionDefinitionEncoder

Interface converts the comparison value to its generic interface.

func (AggregateFunctionDefinition) InterfaceT 

func (j AggregateFunctionDefinition) InterfaceT() (AggregateFunctionDefinitionEncoder, error)

InterfaceT converts the comparison value to its generic interface safely with explicit error.

func (AggregateFunctionDefinition) Type 

func (j AggregateFunctionDefinition) Type() (AggregateFunctionDefinitionType, error)

Type gets the type enum of the current type.

func (*AggregateFunctionDefinition) UnmarshalJSON 

func (j *AggregateFunctionDefinition) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type AggregateFunctionDefinitionAverage 

type AggregateFunctionDefinitionAverage struct {
	// The scalar type of the result of this function, which should have the type representation Float64
	ResultType string `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

AggregateFunctionDefinitionAverage represents an average aggregate function definition.

func NewAggregateFunctionDefinitionAverage 

func NewAggregateFunctionDefinitionAverage(resultType string) *AggregateFunctionDefinitionAverage

NewAggregateFunctionDefinitionAverage creates an AggregateFunctionDefinitionAverage instance.

func (AggregateFunctionDefinitionAverage) Encode 

func (j AggregateFunctionDefinitionAverage) Encode() AggregateFunctionDefinition

Encode converts the instance to raw AggregateFunctionDefinition.

func (AggregateFunctionDefinitionAverage) Type 

func (j AggregateFunctionDefinitionAverage) Type() AggregateFunctionDefinitionType

Type return the type name of the instance.

type AggregateFunctionDefinitionCustom 

type AggregateFunctionDefinitionCustom struct {
	// The scalar or object type of the result of this function.
	ResultType Type `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

AggregateFunctionDefinitionCustom represents a sum aggregate function definition.

func NewAggregateFunctionDefinitionCustom 

func NewAggregateFunctionDefinitionCustom[T TypeEncoder](
	resultType T,
) *AggregateFunctionDefinitionCustom

NewAggregateFunctionDefinitionCustom creates an AggregateFunctionDefinitionCustom instance.

func (AggregateFunctionDefinitionCustom) Encode 

func (j AggregateFunctionDefinitionCustom) Encode() AggregateFunctionDefinition

Encode converts the instance to raw AggregateFunctionDefinition.

func (AggregateFunctionDefinitionCustom) Type 

func (j AggregateFunctionDefinitionCustom) Type() AggregateFunctionDefinitionType

Type return the type name of the instance.

type AggregateFunctionDefinitionEncoder 

type AggregateFunctionDefinitionEncoder interface {
	Type() AggregateFunctionDefinitionType
	Encode() AggregateFunctionDefinition
}

AggregateFunctionDefinitionEncoder abstracts a generic interface of AggregateFunctionDefinition.

type AggregateFunctionDefinitionMax 

type AggregateFunctionDefinitionMax struct{}

AggregateFunctionDefinitionMax represents a max aggregate function definition.

func NewAggregateFunctionDefinitionMax 

func NewAggregateFunctionDefinitionMax() *AggregateFunctionDefinitionMax

NewAggregateFunctionDefinitionMax creates an AggregateFunctionDefinitionMax instance.

func (AggregateFunctionDefinitionMax) Encode 

func (j AggregateFunctionDefinitionMax) Encode() AggregateFunctionDefinition

Encode converts the instance to raw AggregateFunctionDefinition.

func (AggregateFunctionDefinitionMax) Type 

func (j AggregateFunctionDefinitionMax) Type() AggregateFunctionDefinitionType

Type return the type name of the instance.

type AggregateFunctionDefinitionMin 

type AggregateFunctionDefinitionMin struct{}

AggregateFunctionDefinitionMin represents a min aggregate function definition.

func NewAggregateFunctionDefinitionMin 

func NewAggregateFunctionDefinitionMin() *AggregateFunctionDefinitionMin

NewAggregateFunctionDefinitionMin creates an AggregateFunctionDefinitionMin instance.

func (AggregateFunctionDefinitionMin) Encode 

func (j AggregateFunctionDefinitionMin) Encode() AggregateFunctionDefinition

Encode converts the instance to raw AggregateFunctionDefinition.

func (AggregateFunctionDefinitionMin) Type 

func (j AggregateFunctionDefinitionMin) Type() AggregateFunctionDefinitionType

Type return the type name of the instance.

type AggregateFunctionDefinitionSum 

type AggregateFunctionDefinitionSum struct {
	// The scalar type of the result of this function, which should have one of the type representations Int64 or Float64, depending on whether this function is defined on a scalar type with an integer or floating-point representation, respectively.
	ResultType string `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

AggregateFunctionDefinitionSum represents a sum aggregate function definition.

func NewAggregateFunctionDefinitionSum 

func NewAggregateFunctionDefinitionSum(resultType string) *AggregateFunctionDefinitionSum

NewAggregateFunctionDefinitionSum creates an AggregateFunctionDefinitionSum instance.

func (AggregateFunctionDefinitionSum) Encode 

func (j AggregateFunctionDefinitionSum) Encode() AggregateFunctionDefinition

Encode converts the instance to raw AggregateFunctionDefinition.

func (AggregateFunctionDefinitionSum) Type 

func (j AggregateFunctionDefinitionSum) Type() AggregateFunctionDefinitionType

Type return the type name of the instance.

type AggregateFunctionDefinitionType 

type AggregateFunctionDefinitionType string

AggregateFunctionDefinitionType represents a type of AggregateFunctionDefinition. 

const (
	AggregateFunctionDefinitionTypeMin     AggregateFunctionDefinitionType = "min"
	AggregateFunctionDefinitionTypeMax     AggregateFunctionDefinitionType = "max"
	AggregateFunctionDefinitionTypeSum     AggregateFunctionDefinitionType = "sum"
	AggregateFunctionDefinitionTypeAverage AggregateFunctionDefinitionType = "average"
	AggregateFunctionDefinitionTypeCustom  AggregateFunctionDefinitionType = "custom"
)

func ParseAggregateFunctionDefinitionType 

func ParseAggregateFunctionDefinitionType(input string) (AggregateFunctionDefinitionType, error)

ParseAggregateFunctionDefinitionType parses a AggregateFunctionDefinitionType from string.

func (AggregateFunctionDefinitionType) IsValid 

func (j AggregateFunctionDefinitionType) IsValid() bool

IsValid checks if the value is invalid.

func (*AggregateFunctionDefinitionType) UnmarshalJSON 

func (j *AggregateFunctionDefinitionType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type AggregateSingleColumn 

type AggregateSingleColumn struct {
	// The column to apply the aggregation function to
	Column string `json:"column"               mapstructure:"column"     yaml:"column"`
	// Single column aggregate function name.
	Function string `json:"function"             mapstructure:"function"   yaml:"function"`
	// Path to a nested field within an object column.
	FieldPath []string `json:"field_path,omitempty" mapstructure:"field_path" yaml:"field_path,omitempty"`
	// Arguments to satisfy the column specified by 'column'
	Arguments map[string]Argument `json:"arguments,omitempty"  mapstructure:"arguments"  yaml:"arguments,omitempty"`
}

AggregateSingleColumn represents an aggregate object which applies an aggregation function (as defined by the column's scalar type in the schema response) to a column.

func NewAggregateSingleColumn 

func NewAggregateSingleColumn(column string, function string) *AggregateSingleColumn

NewAggregateSingleColumn creates a new AggregateSingleColumn instance.

func (AggregateSingleColumn) Encode 

func (ag AggregateSingleColumn) Encode() Aggregate

Encode converts the instance to raw Aggregate.

func (AggregateSingleColumn) Type 

func (ag AggregateSingleColumn) Type() AggregateType

Type return the type name of the instance.

func (AggregateSingleColumn) WithArgument 

func (f AggregateSingleColumn) WithArgument(
	key string,
	argument ArgumentEncoder,
) *AggregateSingleColumn

WithArgument return a new instance with an arguments set.

func (AggregateSingleColumn) WithArguments 

func (f AggregateSingleColumn) WithArguments(
	arguments map[string]ArgumentEncoder,
) *AggregateSingleColumn

WithArguments return a new instance with arguments set.

func (AggregateSingleColumn) WithFieldPath 

func (f AggregateSingleColumn) WithFieldPath(fieldPath []string) *AggregateSingleColumn

WithFieldPath returns a new instance with field_path set.

type AggregateStarCount 

type AggregateStarCount struct{}

AggregateStarCount represents an aggregate object which counts all matched rows.

func NewAggregateStarCount 

func NewAggregateStarCount() *AggregateStarCount

NewAggregateStarCount creates a new AggregateStarCount instance.

func (AggregateStarCount) Encode 

func (ag AggregateStarCount) Encode() Aggregate

Encode converts the instance to raw Aggregate.

func (AggregateStarCount) Type 

func (ag AggregateStarCount) Type() AggregateType

Type return the type name of the instance.

type AggregateType 

type AggregateType string

AggregateType represents an aggregate type. 

const (
	// AggregateTypeColumnCount aggregates count the number of rows with non-null values in the specified columns.
	// If the distinct flag is set, then the count should only count unique non-null values of those columns,.
	AggregateTypeColumnCount AggregateType = "column_count"
	// AggregateTypeSingleColumn aggregates apply an aggregation function (as defined by the column's scalar type in the schema response) to a column.
	AggregateTypeSingleColumn AggregateType = "single_column"
	// AggregateTypeStarCount aggregates count all matched rows.
	AggregateTypeStarCount AggregateType = "star_count"
)

func ParseAggregateType 

func ParseAggregateType(input string) (AggregateType, error)

ParseAggregateType parses an aggregate type argument type from string.

func (AggregateType) IsValid 

func (j AggregateType) IsValid() bool

IsValid checks if the value is invalid.

func (*AggregateType) UnmarshalJSON 

func (j *AggregateType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type Argument 

type Argument map[string]any

Argument is provided by reference to a variable or as a literal value.

func (Argument) AsLiteral 

func (j Argument) AsLiteral() (*ArgumentLiteral, error)

AsLiteral converts the instance to ArgumentLiteral.

func (Argument) AsVariable 

func (j Argument) AsVariable() (*ArgumentVariable, error)

AsVariable converts the instance to ArgumentVariable.

func (*Argument) FromValue 

func (j *Argument) FromValue(raw map[string]any) error

FromValue parses values from the raw object.

func (Argument) Interface 

func (j Argument) Interface() ArgumentEncoder

Interface converts the comparison value to its generic interface.

func (Argument) InterfaceT 

func (j Argument) InterfaceT() (ArgumentEncoder, error)

InterfaceT converts the comparison value to its generic interface safely with explicit error.

func (Argument) Type 

func (j Argument) Type() (ArgumentType, error)

Type gets the type enum of the current type.

func (*Argument) UnmarshalJSON 

func (j *Argument) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ArgumentEncoder 

type ArgumentEncoder interface {
	Type() ArgumentType
	Encode() Argument
}

ArgumentEncoder abstracts the interface for Argument.

type ArgumentInfo 

type ArgumentInfo struct {
	// Argument description
	Description *string `json:"description,omitempty" yaml:"description,omitempty" mapstructure:"description,omitempty"`

	// The name of the type of this argument
	Type Type `json:"type" yaml:"type" mapstructure:"type"`
}

func (*ArgumentInfo) UnmarshalJSON 

func (j *ArgumentInfo) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ArgumentLiteral 

type ArgumentLiteral struct {
	Value any `json:"value" mapstructure:"value" yaml:"value"`
}

ArgumentLiteral represents the literal argument.

func NewArgumentLiteral 

func NewArgumentLiteral(value any) *ArgumentLiteral

NewArgumentLiteral creates an argument with a literal value.

func (ArgumentLiteral) Encode 

func (j ArgumentLiteral) Encode() Argument

Encode converts the instance to raw Field.

func (ArgumentLiteral) Type 

func (j ArgumentLiteral) Type() ArgumentType

Type return the type name of the instance.

type ArgumentType 

type ArgumentType string

ArgumentType represents an argument type enum. 

const (
	ArgumentTypeLiteral  ArgumentType = "literal"
	ArgumentTypeVariable ArgumentType = "variable"
)

func ParseArgumentType 

func ParseArgumentType(input string) (ArgumentType, error)

ParseArgumentType parses an argument type from string.

func (ArgumentType) IsValid 

func (j ArgumentType) IsValid() bool

IsValid checks if the value is invalid.

func (*ArgumentType) UnmarshalJSON 

func (j *ArgumentType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ArgumentVariable 

type ArgumentVariable struct {
	Name string `json:"name" mapstructure:"name" yaml:"name"`
}

ArgumentVariable represents the variable argument.

func NewArgumentVariable 

func NewArgumentVariable(name string) *ArgumentVariable

NewArgumentVariable creates an argument with a variable name.

func (ArgumentVariable) Encode 

func (j ArgumentVariable) Encode() Argument

Encode converts the instance to raw Field.

func (ArgumentVariable) Type 

func (j ArgumentVariable) Type() ArgumentType

Type return the type name of the instance.

type ArrayComparison 

type ArrayComparison map[string]any

ArrayComparison represents an array comparison.

func (ArrayComparison) AsContains 

func (j ArrayComparison) AsContains() (*ArrayComparisonContains, error)

AsContains tries to convert the current type to ArrayComparisonContains.

func (ArrayComparison) AsIsEmpty 

func (j ArrayComparison) AsIsEmpty() (*ArrayComparisonIsEmpty, error)

AsIsEmpty tries to convert the current type to ArrayComparisonIsEmpty.

func (*ArrayComparison) FromValue 

func (j *ArrayComparison) FromValue(raw map[string]any) error

FromValue maps the raw object value to the instance.

func (ArrayComparison) Interface 

func (j ArrayComparison) Interface() ArrayComparisonEncoder

Interface converts the comparison value to its generic interface.

func (ArrayComparison) InterfaceT 

func (j ArrayComparison) InterfaceT() (ArrayComparisonEncoder, error)

InterfaceT converts the comparison value to its generic interface safely with explicit error.

func (ArrayComparison) Type 

func (j ArrayComparison) Type() (ArrayComparisonType, error)

Type gets the type enum of the current type.

func (*ArrayComparison) UnmarshalJSON 

func (j *ArrayComparison) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ArrayComparisonContains 

type ArrayComparisonContains struct {
	Value ComparisonValue `json:"value" mapstructure:"value" yaml:"value"`
}

ArrayComparisonContains check if the array contains the specified value. Only used if the 'query.nested_fields.filter_by.nested_arrays.contains' capability is supported.

func NewArrayComparisonContains 

func NewArrayComparisonContains[T ComparisonValueEncoder](value T) *ArrayComparisonContains

NewArrayComparisonContains creates an ArrayComparisonContains instance.

func (ArrayComparisonContains) Encode 

func (j ArrayComparisonContains) Encode() ArrayComparison

Encode converts the instance to raw ArrayComparison.

func (ArrayComparisonContains) Type 

func (j ArrayComparisonContains) Type() ArrayComparisonType

Type return the type name of the instance.

type ArrayComparisonEncoder 

type ArrayComparisonEncoder interface {
	Type() ArrayComparisonType
	Encode() ArrayComparison
}

ArrayComparisonEncoder abstracts a generic interface of ArrayComparison.

type ArrayComparisonIsEmpty 

type ArrayComparisonIsEmpty struct{}

ArrayComparisonIsEmpty checks if the array is empty. Only used if the 'query.nested_fields.filter_by.nested_arrays.is_empty' capability is supported.

func NewArrayComparisonIsEmpty 

func NewArrayComparisonIsEmpty() *ArrayComparisonIsEmpty

NewArrayComparisonIsEmpty creates an ArrayComparisonIsEmpty instance.

func (ArrayComparisonIsEmpty) Encode 

func (j ArrayComparisonIsEmpty) Encode() ArrayComparison

Encode converts the instance to raw ArrayComparison.

func (ArrayComparisonIsEmpty) Type 

func (j ArrayComparisonIsEmpty) Type() ArrayComparisonType

Type return the type name of the instance.

type ArrayComparisonType 

type ArrayComparisonType string

ArrayComparisonType represents a type of ArrayComparison. 

const (
	// Check if the array contains the specified value. Only used if the 'query.nested_fields.filter_by.nested_arrays.contains' capability is supported.
	ArrayComparisonTypeContains ArrayComparisonType = "contains"
	// Check is the array is empty. Only used if the 'query.nested_fields.filter_by.nested_arrays.is_empty' capability is supported.
	ArrayComparisonTypeIsEmpty ArrayComparisonType = "is_empty"
)

func ParseArrayComparisonType 

func ParseArrayComparisonType(input string) (ArrayComparisonType, error)

ParseArrayComparisonType parses an ArrayComparisonType from string.

func (ArrayComparisonType) IsValid 

func (j ArrayComparisonType) IsValid() bool

IsValid checks if the value is invalid.

func (*ArrayComparisonType) UnmarshalJSON 

func (j *ArrayComparisonType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ArrayType 

type ArrayType struct {
	// The type of the elements of the array
	ElementType Type `json:"element_type" mapstructure:"element_type" yaml:"element_type"`
}

ArrayType represents an array type.

func NewArrayType 

func NewArrayType[T TypeEncoder](elementType T) *ArrayType

NewArrayType creates a new ArrayType instance.

func (ArrayType) Encode 

func (ty ArrayType) Encode() Type

Encode returns the raw Type instance.

func (ArrayType) String 

func (ty ArrayType) String() string

String implements the fmt.Stringer interface.

func (ArrayType) Type 

func (ty ArrayType) Type() TypeEnum

Type return the type name of the instance.

type Capabilities 

type Capabilities struct {
	// Mutation corresponds to the JSON schema field "mutation".
	Mutation MutationCapabilities `json:"mutation" yaml:"mutation" mapstructure:"mutation"`

	// Query corresponds to the JSON schema field "query".
	Query QueryCapabilities `json:"query" yaml:"query" mapstructure:"query"`

	// Does the connector support the relational mutation API? This feature is
	// experimental and subject to breaking changes within minor versions.
	RelationalMutation *RelationalMutationCapabilities `json:"relational_mutation,omitempty" yaml:"relational_mutation,omitempty" mapstructure:"relational_mutation,omitempty"`

	// Does the connector support the relational query API? This feature is
	// experimental and subject to breaking changes within minor versions.
	RelationalQuery *RelationalQueryCapabilities `json:"relational_query,omitempty" yaml:"relational_query,omitempty" mapstructure:"relational_query,omitempty"`

	// Relationships corresponds to the JSON schema field "relationships".
	Relationships *RelationshipCapabilities `json:"relationships,omitempty" yaml:"relationships,omitempty" mapstructure:"relationships,omitempty"`
}

Describes the features of the specification which a data connector implements.

func (*Capabilities) UnmarshalJSON 

func (j *Capabilities) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type CapabilitiesResponse 

type CapabilitiesResponse struct {
	// Capabilities corresponds to the JSON schema field "capabilities".
	Capabilities Capabilities `json:"capabilities" yaml:"capabilities" mapstructure:"capabilities"`

	// Version corresponds to the JSON schema field "version".
	Version string `json:"version" yaml:"version" mapstructure:"version"`
}

func (CapabilitiesResponse) MarshalCapabilitiesJSON 

func (j CapabilitiesResponse) MarshalCapabilitiesJSON() ([]byte, error)

MarshalCapabilitiesJSON encodes the NDC schema response to JSON.

func (*CapabilitiesResponse) UnmarshalJSON 

func (j *CapabilitiesResponse) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type CapabilitiesResponseMarshaler 

type CapabilitiesResponseMarshaler interface {
	MarshalCapabilitiesJSON() ([]byte, error)
}

CapabilitiesResponseMarshaler abstract the response for /capabilities handler.

type CapabilitySchemaInfo 

type CapabilitySchemaInfo struct {
	// Schema information relevant to query capabilities
	Query *QueryCapabilitiesSchemaInfo `json:"query,omitempty" yaml:"query,omitempty" mapstructure:"query,omitempty"`
}

type CaseWhen 

type CaseWhen struct {
	// Then corresponds to the JSON schema field "then".
	Then RelationalExpression `json:"then" yaml:"then" mapstructure:"then"`

	// When corresponds to the JSON schema field "when".
	When RelationalExpression `json:"when" yaml:"when" mapstructure:"when"`
}

func (*CaseWhen) UnmarshalJSON 

func (j *CaseWhen) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type CastType 

type CastType struct {
	// contains filtered or unexported fields
}

CastType is provided by reference to a relational expression.

func NewCastType 

func NewCastType[T CastTypeInner](inner T) CastType

NewCastType creates a CastType instance.

func (CastType) Interface 

func (j CastType) Interface() CastTypeInner

Interface tries to convert the instance to AggregateInner interface.

func (CastType) IsEmpty 

func (j CastType) IsEmpty() bool

IsEmpty checks if the inner type is empty.

func (CastType) MarshalJSON 

func (j CastType) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler interface.

func (CastType) Type 

func (j CastType) Type() CastTypeEnum

Type gets the type enum of the current type.

func (*CastType) UnmarshalJSON 

func (j *CastType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type CastTypeBoolean 

type CastTypeBoolean struct{}

CastTypeBoolean represents a CastType with the boolean type.

func NewCastTypeBoolean 

func NewCastTypeBoolean() *CastTypeBoolean

NewCastTypeBoolean creates a CastTypeBoolean instance.

func (CastTypeBoolean) ToMap 

func (j CastTypeBoolean) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeBoolean) Type 

func (j CastTypeBoolean) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeBoolean) Wrap 

func (j CastTypeBoolean) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeDate 

type CastTypeDate struct{}

CastTypeDate represents a CastType with the date type.

func NewCastTypeDate 

func NewCastTypeDate() *CastTypeDate

NewCastTypeDate creates a CastTypeDate instance.

func (CastTypeDate) ToMap 

func (j CastTypeDate) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeDate) Type 

func (j CastTypeDate) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeDate) Wrap 

func (j CastTypeDate) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeDecimal128 

type CastTypeDecimal128 struct {
	Scale int8  `json:"scale" mapstructure:"scale" yaml:"scale"`
	Spec  uint8 `json:"prec"  mapstructure:"prec"  yaml:"prec"`
}

CastTypeDecimal128 represents a CastType with unsigned 128-bit decimal.

func NewCastTypeDecimal128 

func NewCastTypeDecimal128(scale int8, spec uint8) *CastTypeDecimal128

NewCastTypeDecimal128 creates a CastTypeDecimal128 instance.

func (CastTypeDecimal128) ToMap 

func (j CastTypeDecimal128) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeDecimal128) Type 

func (j CastTypeDecimal128) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeDecimal128) Wrap 

func (j CastTypeDecimal128) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeDecimal256 

type CastTypeDecimal256 struct {
	Scale int8  `json:"scale" mapstructure:"scale" yaml:"scale"`
	Spec  uint8 `json:"prec"  mapstructure:"prec"  yaml:"prec"`
}

CastTypeDecimal256 represents a CastType with unsigned 256-bit decimal.

func NewCastTypeDecimal256 

func NewCastTypeDecimal256(scale int8, spec uint8) *CastTypeDecimal256

NewCastTypeDecimal256 creates a CastTypeDecimal256 instance.

func (CastTypeDecimal256) ToMap 

func (j CastTypeDecimal256) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeDecimal256) Type 

func (j CastTypeDecimal256) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeDecimal256) Wrap 

func (j CastTypeDecimal256) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeDuration 

type CastTypeDuration struct{}

CastTypeDuration represents a CastType with the duration type.

func NewCastTypeDuration 

func NewCastTypeDuration() *CastTypeDuration

NewCastTypeDuration creates a CastTypeDuration instance.

func (CastTypeDuration) ToMap 

func (j CastTypeDuration) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeDuration) Type 

func (j CastTypeDuration) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeDuration) Wrap 

func (j CastTypeDuration) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeEnum 

type CastTypeEnum string

CastTypeEnum represents a cast enum. 

const (
	CastTypeEnumBoolean    CastTypeEnum = "boolean"
	CastTypeEnumUTF8       CastTypeEnum = "utf8"
	CastTypeEnumInt8       CastTypeEnum = "int8"
	CastTypeEnumInt16      CastTypeEnum = "int16"
	CastTypeEnumInt32      CastTypeEnum = "int32"
	CastTypeEnumInt64      CastTypeEnum = "int64"
	CastTypeEnumUint8      CastTypeEnum = "uint8"
	CastTypeEnumUint16     CastTypeEnum = "uint16"
	CastTypeEnumUint32     CastTypeEnum = "uint32"
	CastTypeEnumUint64     CastTypeEnum = "uint64"
	CastTypeEnumFloat32    CastTypeEnum = "float32"
	CastTypeEnumFloat64    CastTypeEnum = "float64"
	CastTypeEnumDecimal128 CastTypeEnum = "decimal128"
	CastTypeEnumDecimal256 CastTypeEnum = "decimal256"
	CastTypeEnumDate       CastTypeEnum = "date"
	CastTypeEnumTime       CastTypeEnum = "time"
	CastTypeEnumTimestamp  CastTypeEnum = "timestamp"
	CastTypeEnumDuration   CastTypeEnum = "duration"
	CastTypeEnumInterval   CastTypeEnum = "interval"
)

func ParseCastTypeEnum 

func ParseCastTypeEnum(input string) (CastTypeEnum, error)

ParseCastTypeEnum parses a cast type enum from string.

func (CastTypeEnum) IsValid 

func (j CastTypeEnum) IsValid() bool

IsValid checks if the value is invalid.

func (*CastTypeEnum) UnmarshalJSON 

func (j *CastTypeEnum) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type CastTypeFloat32 

type CastTypeFloat32 struct{}

CastTypeFloat32 represents a CastType with the float32 type.

func NewCastTypeFloat32 

func NewCastTypeFloat32() *CastTypeFloat32

NewCastTypeFloat32 creates a CastTypeFloat32 instance.

func (CastTypeFloat32) ToMap 

func (j CastTypeFloat32) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeFloat32) Type 

func (j CastTypeFloat32) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeFloat32) Wrap 

func (j CastTypeFloat32) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeFloat64 

type CastTypeFloat64 struct{}

CastTypeFloat64 represents a CastType with the float64 type.

func NewCastTypeFloat64 

func NewCastTypeFloat64() *CastTypeFloat64

NewCastTypeFloat64 creates a CastTypeFloat64 instance.

func (CastTypeFloat64) ToMap 

func (j CastTypeFloat64) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeFloat64) Type 

func (j CastTypeFloat64) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeFloat64) Wrap 

func (j CastTypeFloat64) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeInner 

type CastTypeInner interface {
	Type() CastTypeEnum
	ToMap() map[string]any
	Wrap() CastType
}

CastTypeInner abstracts the interface for CastType.

type CastTypeInt8 

type CastTypeInt8 struct{}

CastTypeInt8 represents a CastType with the int8 type.

func NewCastTypeInt8 

func NewCastTypeInt8() *CastTypeInt8

NewCastTypeInt8 creates a CastTypeInt8 instance.

func (CastTypeInt8) ToMap 

func (j CastTypeInt8) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeInt8) Type 

func (j CastTypeInt8) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeInt8) Wrap 

func (j CastTypeInt8) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeInt16 

type CastTypeInt16 struct{}

CastTypeInt16 represents a CastType with the int16 type.

func NewCastTypeInt16 

func NewCastTypeInt16() *CastTypeInt16

NewCastTypeInt16 creates a CastTypeInt16 instance.

func (CastTypeInt16) ToMap 

func (j CastTypeInt16) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeInt16) Type 

func (j CastTypeInt16) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeInt16) Wrap 

func (j CastTypeInt16) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeInt32 

type CastTypeInt32 struct{}

CastTypeInt32 represents a CastType with the int32 type.

func NewCastTypeInt32 

func NewCastTypeInt32() *CastTypeInt32

NewCastTypeInt32 creates a CastTypeInt32 instance.

func (CastTypeInt32) ToMap 

func (j CastTypeInt32) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeInt32) Type 

func (j CastTypeInt32) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeInt32) Wrap 

func (j CastTypeInt32) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeInt64 

type CastTypeInt64 struct{}

CastTypeInt64 represents a CastType with the int64 type.

func NewCastTypeInt64 

func NewCastTypeInt64() *CastTypeInt64

NewCastTypeInt64 creates a CastTypeInt64 instance.

func (CastTypeInt64) ToMap 

func (j CastTypeInt64) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeInt64) Type 

func (j CastTypeInt64) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeInt64) Wrap 

func (j CastTypeInt64) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeInterval 

type CastTypeInterval struct{}

CastTypeInterval represents a CastType with the interval type.

func NewCastTypeInterval 

func NewCastTypeInterval() *CastTypeInterval

NewCastTypeInterval creates a CastTypeInterval instance.

func (CastTypeInterval) ToMap 

func (j CastTypeInterval) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeInterval) Type 

func (j CastTypeInterval) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeInterval) Wrap 

func (j CastTypeInterval) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeTime 

type CastTypeTime struct{}

CastTypeTime represents a CastType with the time type.

func NewCastTypeTime 

func NewCastTypeTime() *CastTypeTime

NewCastTypeTime creates a CastTypeTime instance.

func (CastTypeTime) ToMap 

func (j CastTypeTime) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeTime) Type 

func (j CastTypeTime) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeTime) Wrap 

func (j CastTypeTime) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeTimestamp 

type CastTypeTimestamp struct{}

CastTypeTimestamp represents a CastType with the timestamp type.

func NewCastTypeTimestamp 

func NewCastTypeTimestamp() *CastTypeTimestamp

NewCastTypeTimestamp creates a CastTypeTimestamp instance.

func (CastTypeTimestamp) ToMap 

func (j CastTypeTimestamp) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeTimestamp) Type 

func (j CastTypeTimestamp) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeTimestamp) Wrap 

func (j CastTypeTimestamp) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeUTF8 

type CastTypeUTF8 struct{}

CastTypeUTF8 represents a CastType with the utf8 type.

func NewCastTypeUTF8 

func NewCastTypeUTF8() *CastTypeUTF8

NewCastTypeUTF8 creates a CastTypeUTF8 instance.

func (CastTypeUTF8) ToMap 

func (j CastTypeUTF8) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeUTF8) Type 

func (j CastTypeUTF8) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeUTF8) Wrap 

func (j CastTypeUTF8) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeUint8 

type CastTypeUint8 struct{}

CastTypeUint8 represents a CastType with the uint8 type.

func NewCastTypeUint8 

func NewCastTypeUint8() *CastTypeUint8

NewCastTypeUint8 creates a CastTypeUint8 instance.

func (CastTypeUint8) ToMap 

func (j CastTypeUint8) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeUint8) Type 

func (j CastTypeUint8) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeUint8) Wrap 

func (j CastTypeUint8) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeUint16 

type CastTypeUint16 struct{}

CastTypeUint16 represents a CastType with the uint16 type.

func NewCastTypeUint16 

func NewCastTypeUint16() *CastTypeUint16

NewCastTypeUint16 creates a CastTypeUint16 instance.

func (CastTypeUint16) ToMap 

func (j CastTypeUint16) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeUint16) Type 

func (j CastTypeUint16) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeUint16) Wrap 

func (j CastTypeUint16) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeUint32 

type CastTypeUint32 struct{}

CastTypeUint32 represents a CastType with the uint32 type.

func NewCastTypeUint32 

func NewCastTypeUint32() *CastTypeUint32

NewCastTypeUint32 creates a CastTypeUint32 instance.

func (CastTypeUint32) ToMap 

func (j CastTypeUint32) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeUint32) Type 

func (j CastTypeUint32) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeUint32) Wrap 

func (j CastTypeUint32) Wrap() CastType

Encode returns the relation wrapper.

type CastTypeUint64 

type CastTypeUint64 struct{}

CastTypeUint64 represents a CastType with the uint64 type.

func NewCastTypeUint64 

func NewCastTypeUint64() *CastTypeUint64

NewCastTypeUint64 creates a CastTypeUint64 instance.

func (CastTypeUint64) ToMap 

func (j CastTypeUint64) ToMap() map[string]any

ToMap converts the instance to raw map.

func (CastTypeUint64) Type 

func (j CastTypeUint64) Type() CastTypeEnum

Type return the type name of the instance.

func (CastTypeUint64) Wrap 

func (j CastTypeUint64) Wrap() CastType

Encode returns the relation wrapper.

type CollectionInfo 

type CollectionInfo struct {
	// Any arguments that this collection requires
	Arguments CollectionInfoArguments `json:"arguments" yaml:"arguments" mapstructure:"arguments"`

	// Description of the collection
	Description *string `json:"description,omitempty" yaml:"description,omitempty" mapstructure:"description,omitempty"`

	// The name of the collection
	//
	// Note: these names are abstract - there is no requirement that this name
	// correspond to the name of an actual collection in the database.
	Name string `json:"name" yaml:"name" mapstructure:"name"`

	// Information about relational mutation capabilities for this collection
	RelationalMutations *RelationalMutationInfo `json:"relational_mutations,omitempty" yaml:"relational_mutations,omitempty" mapstructure:"relational_mutations,omitempty"`

	// The name of the collection's object type
	Type string `json:"type" yaml:"type" mapstructure:"type"`

	// Any uniqueness constraints enforced on this collection
	UniquenessConstraints CollectionInfoUniquenessConstraints `json:"uniqueness_constraints" yaml:"uniqueness_constraints" mapstructure:"uniqueness_constraints"`
}

func (*CollectionInfo) UnmarshalJSON 

func (j *CollectionInfo) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type CollectionInfoArguments 

type CollectionInfoArguments map[string]ArgumentInfo

Any arguments that this collection requires

type CollectionInfoUniquenessConstraints 

type CollectionInfoUniquenessConstraints map[string]UniquenessConstraint

Any uniqueness constraints enforced on this collection

type ColumnField 

type ColumnField struct {
	// Column name
	Column string `json:"column"           mapstructure:"column" yaml:"column"`
	// When the type of the column is a (possibly-nullable) array or object,
	// the caller can request a subset of the complete column data, by specifying fields to fetch here.
	// If omitted, the column data will be fetched in full.
	Fields NestedField `json:"fields,omitempty" mapstructure:"fields" yaml:"fields,omitempty"`

	Arguments map[string]Argument `json:"arguments,omitempty" mapstructure:"fields" yaml:"arguments,omitempty"`
}

ColumnField represents a column field.

func NewColumnField 

func NewColumnField(column string) *ColumnField

NewColumnField creates a new ColumnField instance.

func (ColumnField) Encode 

func (f ColumnField) Encode() Field

Encode converts the instance to raw Field.

func (ColumnField) Type 

func (f ColumnField) Type() FieldType

Type return the type name of the instance.

func (ColumnField) WithArgument 

func (f ColumnField) WithArgument(key string, argument ArgumentEncoder) *ColumnField

WithArgument return a new column field with an arguments set.

func (ColumnField) WithArguments 

func (f ColumnField) WithArguments(arguments map[string]ArgumentEncoder) *ColumnField

WithArguments return a new column field with arguments set.

func (ColumnField) WithNestedField 

func (f ColumnField) WithNestedField(fields NestedFieldEncoder) *ColumnField

WithNestedField return a new column field with nested fields set.

type ComparisonOperatorContains 

type ComparisonOperatorContains struct{}

ComparisonOperatorContains presents a contains comparison operator.

func NewComparisonOperatorContains 

func NewComparisonOperatorContains() *ComparisonOperatorContains

NewComparisonOperatorContains create a new ComparisonOperatorContains instance.

func (ComparisonOperatorContains) Encode 

func (ob ComparisonOperatorContains) Encode() ComparisonOperatorDefinition

Encode converts the instance to raw ComparisonOperatorDefinition.

func (ComparisonOperatorContains) Type 

func (ob ComparisonOperatorContains) Type() ComparisonOperatorDefinitionType

Type return the type name of the instance.

type ComparisonOperatorContainsInsensitive 

type ComparisonOperatorContainsInsensitive struct{}

ComparisonOperatorContainsInsensitive presents a contains_insensitive comparison operator.

func NewComparisonOperatorContainsInsensitive 

func NewComparisonOperatorContainsInsensitive() *ComparisonOperatorContainsInsensitive

NewComparisonOperatorContainsInsensitive create a new ComparisonOperatorContainsInsensitive instance.

func (ComparisonOperatorContainsInsensitive) Encode 

func (ob ComparisonOperatorContainsInsensitive) Encode() ComparisonOperatorDefinition

Encode converts the instance to raw ComparisonOperatorDefinition.

func (ComparisonOperatorContainsInsensitive) Type 

func (ob ComparisonOperatorContainsInsensitive) Type() ComparisonOperatorDefinitionType

Type return the type name of the instance.

type ComparisonOperatorCustom 

type ComparisonOperatorCustom struct {
	// The type of the argument to this operator
	ArgumentType Type `json:"argument_type" mapstructure:"argument_type" yaml:"argument_type"`
}

ComparisonOperatorCustom presents a custom comparison operator.

func NewComparisonOperatorCustom 

func NewComparisonOperatorCustom[T TypeEncoder](argumentType T) *ComparisonOperatorCustom

NewComparisonOperatorCustom create a new ComparisonOperatorCustom instance.

func (ComparisonOperatorCustom) Encode 

func (ob ComparisonOperatorCustom) Encode() ComparisonOperatorDefinition

Encode converts the instance to raw ComparisonOperatorDefinition.

func (ComparisonOperatorCustom) Type 

func (ob ComparisonOperatorCustom) Type() ComparisonOperatorDefinitionType

Type return the type name of the instance.

type ComparisonOperatorDefinition 

type ComparisonOperatorDefinition map[string]any

ComparisonOperatorDefinition the definition of a comparison operator on a scalar type.

func (ComparisonOperatorDefinition) AsContains 

func (j ComparisonOperatorDefinition) AsContains() (*ComparisonOperatorContains, error)

AsContains tries to convert the instance to ComparisonOperatorContains type.

func (ComparisonOperatorDefinition) AsContainsInsensitive 

func (j ComparisonOperatorDefinition) AsContainsInsensitive() (*ComparisonOperatorContainsInsensitive, error)

AsContainsInsensitive tries to convert the instance to ComparisonOperatorContainsInsensitive type.

func (ComparisonOperatorDefinition) AsCustom 

func (j ComparisonOperatorDefinition) AsCustom() (*ComparisonOperatorCustom, error)

AsCustom tries to convert the instance to ComparisonOperatorIn type.

func (ComparisonOperatorDefinition) AsEndsWith 

func (j ComparisonOperatorDefinition) AsEndsWith() (*ComparisonOperatorEndsWith, error)

AsEndsWith tries to convert the instance to ComparisonOperatorEndsWith type.

func (ComparisonOperatorDefinition) AsEndsWithInsensitive 

func (j ComparisonOperatorDefinition) AsEndsWithInsensitive() (*ComparisonOperatorEndsWithInsensitive, error)

AsEndsWithInsensitive tries to convert the instance to ComparisonOperatorEndsWithInsensitive type.

func (ComparisonOperatorDefinition) AsEqual 

func (j ComparisonOperatorDefinition) AsEqual() (*ComparisonOperatorEqual, error)

AsEqual tries to convert the instance to ComparisonOperatorEqual type.

func (ComparisonOperatorDefinition) AsGreaterThan 

func (j ComparisonOperatorDefinition) AsGreaterThan() (*ComparisonOperatorGreaterThan, error)

AsGreaterThan tries to convert the instance to ComparisonOperatorGreaterThan type.

func (ComparisonOperatorDefinition) AsGreaterThanOrEqual 

func (j ComparisonOperatorDefinition) AsGreaterThanOrEqual() (*ComparisonOperatorGreaterThanOrEqual, error)

AsGreaterThanOrEqual tries to convert the instance to ComparisonOperatorGreaterThanOrEqual type.

func (ComparisonOperatorDefinition) AsIn 

func (j ComparisonOperatorDefinition) AsIn() (*ComparisonOperatorIn, error)

AsIn tries to convert the instance to ComparisonOperatorIn type.

func (ComparisonOperatorDefinition) AsLessThan 

func (j ComparisonOperatorDefinition) AsLessThan() (*ComparisonOperatorLessThan, error)

AsLessThan tries to convert the instance to ComparisonOperatorLessThan type.

func (ComparisonOperatorDefinition) AsLessThanOrEqual 

func (j ComparisonOperatorDefinition) AsLessThanOrEqual() (*ComparisonOperatorLessThanOrEqual, error)

AsLessThanOrEqual tries to convert the instance to ComparisonOperatorLessThanOrEqual type.

func (ComparisonOperatorDefinition) AsStartsWith 

func (j ComparisonOperatorDefinition) AsStartsWith() (*ComparisonOperatorStartsWith, error)

AsStartsWith tries to convert the instance to ComparisonOperatorStartsWith type.

func (ComparisonOperatorDefinition) AsStartsWithInsensitive 

func (j ComparisonOperatorDefinition) AsStartsWithInsensitive() (*ComparisonOperatorStartsWithInsensitive, error)

AsStartsWithInsensitive tries to convert the instance to ComparisonOperatorStartsWithInsensitive type.

func (ComparisonOperatorDefinition) Interface 

func (j ComparisonOperatorDefinition) Interface() ComparisonOperatorDefinitionEncoder

Interface tries to convert the instance to ComparisonOperatorDefinitionEncoder interface.

func (ComparisonOperatorDefinition) InterfaceT 

func (j ComparisonOperatorDefinition) InterfaceT() (ComparisonOperatorDefinitionEncoder, error)

InterfaceT tries to convert the instance to ComparisonOperatorDefinitionEncoder interface safely with explicit error.

func (ComparisonOperatorDefinition) Type 

func (j ComparisonOperatorDefinition) Type() (ComparisonOperatorDefinitionType, error)

Type gets the type enum of the current type.

func (*ComparisonOperatorDefinition) UnmarshalJSON 

func (j *ComparisonOperatorDefinition) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ComparisonOperatorDefinitionEncoder 

type ComparisonOperatorDefinitionEncoder interface {
	Type() ComparisonOperatorDefinitionType
	Encode() ComparisonOperatorDefinition
}

ComparisonOperatorDefinitionEncoder abstracts the serialization interface for ComparisonOperatorDefinition.

type ComparisonOperatorDefinitionType 

type ComparisonOperatorDefinitionType string

ComparisonOperatorDefinitionType represents a binary comparison operator type enum. 

const (
	ComparisonOperatorDefinitionTypeEqual                 ComparisonOperatorDefinitionType = "equal"
	ComparisonOperatorDefinitionTypeIn                    ComparisonOperatorDefinitionType = "in"
	ComparisonOperatorDefinitionTypeLessThan              ComparisonOperatorDefinitionType = "less_than"
	ComparisonOperatorDefinitionTypeLessThanOrEqual       ComparisonOperatorDefinitionType = "less_than_or_equal"
	ComparisonOperatorDefinitionTypeGreaterThan           ComparisonOperatorDefinitionType = "greater_than"
	ComparisonOperatorDefinitionTypeGreaterThanOrEqual    ComparisonOperatorDefinitionType = "greater_than_or_equal"
	ComparisonOperatorDefinitionTypeContains              ComparisonOperatorDefinitionType = "contains"
	ComparisonOperatorDefinitionTypeContainsInsensitive   ComparisonOperatorDefinitionType = "contains_insensitive"
	ComparisonOperatorDefinitionTypeStartsWith            ComparisonOperatorDefinitionType = "starts_with"
	ComparisonOperatorDefinitionTypeStartsWithInsensitive ComparisonOperatorDefinitionType = "starts_with_insensitive"
	ComparisonOperatorDefinitionTypeEndsWith              ComparisonOperatorDefinitionType = "ends_with"
	ComparisonOperatorDefinitionTypeEndsWithInsensitive   ComparisonOperatorDefinitionType = "ends_with_insensitive"
	ComparisonOperatorDefinitionTypeCustom                ComparisonOperatorDefinitionType = "custom"
)

func ParseComparisonOperatorDefinitionType 

func ParseComparisonOperatorDefinitionType(input string) (ComparisonOperatorDefinitionType, error)

ParseComparisonOperatorDefinitionType parses a type of a comparison operator definition.

func (ComparisonOperatorDefinitionType) IsValid 

func (j ComparisonOperatorDefinitionType) IsValid() bool

IsValid checks if the value is invalid.

func (*ComparisonOperatorDefinitionType) UnmarshalJSON 

func (j *ComparisonOperatorDefinitionType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ComparisonOperatorEndsWith 

type ComparisonOperatorEndsWith struct{}

ComparisonOperatorEndsWith presents an ends_with comparison operator.

func NewComparisonOperatorEndsWith 

func NewComparisonOperatorEndsWith() *ComparisonOperatorEndsWith

NewComparisonOperatorEndsWith create a new ComparisonOperatorEndsWith instance.

func (ComparisonOperatorEndsWith) Encode 

func (ob ComparisonOperatorEndsWith) Encode() ComparisonOperatorDefinition

Encode converts the instance to raw ComparisonOperatorDefinition.

func (ComparisonOperatorEndsWith) Type 

func (ob ComparisonOperatorEndsWith) Type() ComparisonOperatorDefinitionType

Type return the type name of the instance.

type ComparisonOperatorEndsWithInsensitive 

type ComparisonOperatorEndsWithInsensitive struct{}

ComparisonOperatorEndsWithInsensitive presents an ends_with_insensitive comparison operator.

func NewComparisonOperatorEndsWithInsensitive 

func NewComparisonOperatorEndsWithInsensitive() *ComparisonOperatorEndsWithInsensitive

NewComparisonOperatorEndsWithInsensitive create a new ComparisonOperatorEndsWith instance.

func (ComparisonOperatorEndsWithInsensitive) Encode 

func (ob ComparisonOperatorEndsWithInsensitive) Encode() ComparisonOperatorDefinition

Encode converts the instance to raw ComparisonOperatorDefinition.

func (ComparisonOperatorEndsWithInsensitive) Type 

func (ob ComparisonOperatorEndsWithInsensitive) Type() ComparisonOperatorDefinitionType

Type return the type name of the instance.

type ComparisonOperatorEqual 

type ComparisonOperatorEqual struct{}

ComparisonOperatorEqual presents an equal comparison operator.

func NewComparisonOperatorEqual 

func NewComparisonOperatorEqual() *ComparisonOperatorEqual

NewComparisonOperatorEqual create a new ComparisonOperatorEqual instance.

func (ComparisonOperatorEqual) Encode 

func (ob ComparisonOperatorEqual) Encode() ComparisonOperatorDefinition

Encode converts the instance to raw ComparisonOperatorDefinition.

func (ComparisonOperatorEqual) Type 

func (ob ComparisonOperatorEqual) Type() ComparisonOperatorDefinitionType

Type return the type name of the instance.

type ComparisonOperatorGreaterThan 

type ComparisonOperatorGreaterThan struct{}

ComparisonOperatorGreaterThan presents a greater_than comparison operator.

func NewComparisonOperatorGreaterThan 

func NewComparisonOperatorGreaterThan() *ComparisonOperatorGreaterThan

NewComparisonOperatorGreaterThan create a new ComparisonOperatorGreaterThan instance.

func (ComparisonOperatorGreaterThan) Encode 

func (ob ComparisonOperatorGreaterThan) Encode() ComparisonOperatorDefinition

Encode converts the instance to raw ComparisonOperatorDefinition.

func (ComparisonOperatorGreaterThan) Type 

func (ob ComparisonOperatorGreaterThan) Type() ComparisonOperatorDefinitionType

Type return the type name of the instance.

type ComparisonOperatorGreaterThanOrEqual 

type ComparisonOperatorGreaterThanOrEqual struct{}

ComparisonOperatorGreaterThanOrEqual presents a greater_than_or_equal comparison operator.

func NewComparisonOperatorGreaterThanOrEqual 

func NewComparisonOperatorGreaterThanOrEqual() *ComparisonOperatorGreaterThanOrEqual

NewComparisonOperatorGreaterThanOrEqual create a new ComparisonOperatorGreaterThanOrEqual instance.

func (ComparisonOperatorGreaterThanOrEqual) Encode 

func (ob ComparisonOperatorGreaterThanOrEqual) Encode() ComparisonOperatorDefinition

Encode converts the instance to raw ComparisonOperatorDefinition.

func (ComparisonOperatorGreaterThanOrEqual) Type 

func (ob ComparisonOperatorGreaterThanOrEqual) Type() ComparisonOperatorDefinitionType

Type return the type name of the instance.

type ComparisonOperatorIn 

type ComparisonOperatorIn struct{}

ComparisonOperatorIn presents an in comparison operator.

func NewComparisonOperatorIn 

func NewComparisonOperatorIn() *ComparisonOperatorIn

NewComparisonOperatorIn create a new ComparisonOperatorIn instance.

func (ComparisonOperatorIn) Encode 

func (ob ComparisonOperatorIn) Encode() ComparisonOperatorDefinition

Encode converts the instance to raw ComparisonOperatorDefinition.

func (ComparisonOperatorIn) Type 

func (ob ComparisonOperatorIn) Type() ComparisonOperatorDefinitionType

Type return the type name of the instance.

type ComparisonOperatorLessThan 

type ComparisonOperatorLessThan struct{}

ComparisonOperatorLessThan presents a less_than comparison operator.

func NewComparisonOperatorLessThan 

func NewComparisonOperatorLessThan() *ComparisonOperatorLessThan

NewComparisonOperatorLessThan create a new ComparisonOperatorLessThan instance.

func (ComparisonOperatorLessThan) Encode 

func (ob ComparisonOperatorLessThan) Encode() ComparisonOperatorDefinition

Encode converts the instance to raw ComparisonOperatorDefinition.

func (ComparisonOperatorLessThan) Type 

func (ob ComparisonOperatorLessThan) Type() ComparisonOperatorDefinitionType

Type return the type name of the instance.

type ComparisonOperatorLessThanOrEqual 

type ComparisonOperatorLessThanOrEqual struct{}

ComparisonOperatorLessThanOrEqual presents a less_than_or_equal comparison operator.

func NewComparisonOperatorLessThanOrEqual 

func NewComparisonOperatorLessThanOrEqual() *ComparisonOperatorLessThanOrEqual

NewComparisonOperatorLessThanOrEqual create a new ComparisonOperatorLessThanOrEqual instance.

func (ComparisonOperatorLessThanOrEqual) Encode 

func (ob ComparisonOperatorLessThanOrEqual) Encode() ComparisonOperatorDefinition

Encode converts the instance to raw ComparisonOperatorDefinition.

func (ComparisonOperatorLessThanOrEqual) Type 

func (ob ComparisonOperatorLessThanOrEqual) Type() ComparisonOperatorDefinitionType

Type return the type name of the instance.

type ComparisonOperatorStartsWith 

type ComparisonOperatorStartsWith struct{}

ComparisonOperatorStartsWith presents a starts_with comparison operator.

func NewComparisonOperatorStartsWith 

func NewComparisonOperatorStartsWith() *ComparisonOperatorStartsWith

NewComparisonOperatorStartsWith create a new ComparisonOperatorStartsWith instance.

func (ComparisonOperatorStartsWith) Encode 

func (ob ComparisonOperatorStartsWith) Encode() ComparisonOperatorDefinition

Encode converts the instance to raw ComparisonOperatorDefinition.

func (ComparisonOperatorStartsWith) Type 

func (ob ComparisonOperatorStartsWith) Type() ComparisonOperatorDefinitionType

Type return the type name of the instance.

type ComparisonOperatorStartsWithInsensitive 

type ComparisonOperatorStartsWithInsensitive struct{}

ComparisonOperatorStartsWithInsensitive presents a starts_with_insensitive comparison operator.

func NewComparisonOperatorStartsWithInsensitive 

func NewComparisonOperatorStartsWithInsensitive() *ComparisonOperatorStartsWithInsensitive

NewComparisonOperatorStartsWithInsensitive create a new ComparisonOperatorStartsWith instance.

func (ComparisonOperatorStartsWithInsensitive) Encode 

func (ob ComparisonOperatorStartsWithInsensitive) Encode() ComparisonOperatorDefinition

Encode converts the instance to raw ComparisonOperatorDefinition.

func (ComparisonOperatorStartsWithInsensitive) Type 

func (ob ComparisonOperatorStartsWithInsensitive) Type() ComparisonOperatorDefinitionType

Type return the type name of the instance.

type ComparisonTarget 

type ComparisonTarget map[string]any

ComparisonTarget represents a comparison target object.

func (ComparisonTarget) AsAggregate 

func (j ComparisonTarget) AsAggregate() (*ComparisonTargetAggregate, error)

AsAggregate tries to convert the current type to ComparisonTargetAggregate.

func (ComparisonTarget) AsColumn 

func (j ComparisonTarget) AsColumn() (*ComparisonTargetColumn, error)

AsColumn tries to convert the current type to ComparisonTargetColumn.

func (*ComparisonTarget) FromValue 

func (j *ComparisonTarget) FromValue(raw map[string]any) error

FromValue parses values from the raw object.

func (ComparisonTarget) Interface 

func (j ComparisonTarget) Interface() ComparisonTargetEncoder

Interface converts the comparison value to its generic interface.

func (ComparisonTarget) InterfaceT 

func (j ComparisonTarget) InterfaceT() (ComparisonTargetEncoder, error)

InterfaceT converts the comparison value to its generic interface safely with explicit error.

func (ComparisonTarget) Type 

func (j ComparisonTarget) Type() (ComparisonTargetType, error)

Type gets the type enum of the current type.

func (*ComparisonTarget) UnmarshalJSON 

func (j *ComparisonTarget) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ComparisonTargetAggregate 

type ComparisonTargetAggregate struct {
	// The aggregation method to use
	Aggregate Aggregate `json:"aggregate" mapstructure:"aggregate" yaml:"aggregate"`
	// Non-empty collection of relationships to traverse
	Path []PathElement `json:"path"      mapstructure:"path"      yaml:"path"`
}

ComparisonTargetAggregate represents a comparison that targets the result of aggregation. Only used if the 'query.aggregates.filter_by' capability is supported.

func NewComparisonTargetAggregate 

func NewComparisonTargetAggregate[T AggregateEncoder](
	aggregate T,
	path []PathElement,
) *ComparisonTargetAggregate

NewComparisonTargetAggregate creates a ComparisonTargetAggregate instance.

func (ComparisonTargetAggregate) Encode 

func (f ComparisonTargetAggregate) Encode() ComparisonTarget

Encode converts the instance to raw Field.

func (ComparisonTargetAggregate) Type 

func (f ComparisonTargetAggregate) Type() ComparisonTargetType

Type return the type name of the instance.

type ComparisonTargetColumn 

type ComparisonTargetColumn struct {
	// The name of the column
	Name string `json:"name"                 mapstructure:"name"       yaml:"name"`
	// Arguments to satisfy the column specified by 'name'
	Arguments map[string]Argument `json:"arguments,omitempty"  mapstructure:"arguments"  yaml:"arguments,omitempty"`
	// Path to a nested field within an object column. Only non-empty if the 'query.nested_fields.filter_by' capability is supported.
	FieldPath []string `json:"field_path,omitempty" mapstructure:"field_path" yaml:"field_path,omitempty"`
}

ComparisonTargetColumn represents a comparison targets a column.

func NewComparisonTargetColumn 

func NewComparisonTargetColumn(name string) *ComparisonTargetColumn

NewComparisonTargetColumn creates a ComparisonTarget with column type.

func (ComparisonTargetColumn) Encode 

func (f ComparisonTargetColumn) Encode() ComparisonTarget

Encode converts the instance to raw Field.

func (ComparisonTargetColumn) Type 

func (f ComparisonTargetColumn) Type() ComparisonTargetType

Type return the type name of the instance.

func (ComparisonTargetColumn) WithArgument 

func (f ComparisonTargetColumn) WithArgument(
	key string,
	argument ArgumentEncoder,
) *ComparisonTargetColumn

WithArgument return a new instance with an arguments set.

func (ComparisonTargetColumn) WithArguments 

func (f ComparisonTargetColumn) WithArguments(
	arguments map[string]ArgumentEncoder,
) *ComparisonTargetColumn

WithArguments return a new instance with arguments set.

func (ComparisonTargetColumn) WithFieldPath 

func (f ComparisonTargetColumn) WithFieldPath(fieldPath []string) *ComparisonTargetColumn

WithFieldPath returns a new instance with field_path set.

type ComparisonTargetEncoder 

type ComparisonTargetEncoder interface {
	Type() ComparisonTargetType
	Encode() ComparisonTarget
}

ComparisonTargetEncoder abstracts the serialization interface for ComparisonTarget family.

type ComparisonTargetType 

type ComparisonTargetType string

ComparisonTargetType represents comparison target enums. 

const (
	ComparisonTargetTypeColumn    ComparisonTargetType = "column"
	ComparisonTargetTypeAggregate ComparisonTargetType = "aggregate"
)

func ParseComparisonTargetType 

func ParseComparisonTargetType(input string) (ComparisonTargetType, error)

ParseComparisonTargetType parses a comparison target type argument type from string.

func (ComparisonTargetType) IsValid 

func (j ComparisonTargetType) IsValid() bool

IsValid checks if the value is invalid.

func (*ComparisonTargetType) UnmarshalJSON 

func (j *ComparisonTargetType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ComparisonValue 

type ComparisonValue map[string]any

ComparisonValue represents a raw comparison value object with validation.

func (ComparisonValue) AsColumn 

func (cv ComparisonValue) AsColumn() (*ComparisonValueColumn, error)

AsColumn tries to convert the comparison value to column.

func (ComparisonValue) AsScalar 

func (cv ComparisonValue) AsScalar() (*ComparisonValueScalar, error)

AsScalar tries to convert the comparison value to scalar.

func (ComparisonValue) AsVariable 

func (cv ComparisonValue) AsVariable() (*ComparisonValueVariable, error)

AsVariable tries to convert the comparison value to column.

func (*ComparisonValue) FromValue 

func (cv *ComparisonValue) FromValue(input map[string]any) error

FromValue decodes values from any map.

func (ComparisonValue) Interface 

func (cv ComparisonValue) Interface() ComparisonValueEncoder

Interface converts the comparison value to its generic interface.

func (ComparisonValue) InterfaceT 

func (cv ComparisonValue) InterfaceT() (ComparisonValueEncoder, error)

InterfaceT converts the comparison value to its generic interface safely with explicit error.

func (ComparisonValue) Type 

func (cv ComparisonValue) Type() (ComparisonValueType, error)

GetType gets the type of comparison value.

func (*ComparisonValue) UnmarshalJSON 

func (cv *ComparisonValue) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ComparisonValueColumn 

type ComparisonValueColumn struct {
	// The name of the column
	Name string `json:"name"                 mapstructure:"name"       yaml:"name"`
	// Any relationships to traverse to reach this column.
	// Only non-empty if the 'relationships.relation_comparisons' is supported.
	Path []PathElement `json:"path"                 mapstructure:"path"       yaml:"path"`
	// Arguments to satisfy the column specified by 'name'
	Arguments map[string]Argument `json:"arguments,omitempty"  mapstructure:"arguments"  yaml:"arguments,omitempty"`
	// Path to a nested field within an object column. Only non-empty if the 'query.nested_fields.filter_by' capability is supported.
	FieldPath []string `json:"field_path,omitempty" mapstructure:"field_path" yaml:"field_path,omitempty"`
	// The scope in which this column exists, identified by an top-down index into the stack of scopes.
	// The stack grows inside each `Expression::Exists`, so scope 0 (the default) refers to the current collection,
	// and each subsequent index refers to the collection outside its predecessor's immediately enclosing `Expression::Exists` expression.
	// Only used if the 'query.exists.named_scopes' capability is supported.
	Scope *uint `json:"scope,omitempty"      mapstructure:"scope"      yaml:"scope,omitempty"`
}

The value to compare against should be drawn from another column.

func NewComparisonValueColumn 

func NewComparisonValueColumn(name string, path []PathElement) *ComparisonValueColumn

NewComparisonValueColumn creates a new ComparisonValueColumn instance.

func (ComparisonValueColumn) Encode 

func (cv ComparisonValueColumn) Encode() ComparisonValue

Encode converts to the raw comparison value.

func (ComparisonValueColumn) Type 

func (cv ComparisonValueColumn) Type() ComparisonValueType

Type return the type name of the instance.

func (ComparisonValueColumn) WithArgument 

func (f ComparisonValueColumn) WithArgument(
	key string,
	argument ArgumentEncoder,
) *ComparisonValueColumn

WithArgument return a new instance with an arguments set.

func (ComparisonValueColumn) WithArguments 

func (f ComparisonValueColumn) WithArguments(
	arguments map[string]ArgumentEncoder,
) *ComparisonValueColumn

WithArguments return a new instance with arguments set.

func (ComparisonValueColumn) WithFieldPath 

func (f ComparisonValueColumn) WithFieldPath(fieldPath []string) *ComparisonValueColumn

WithFieldPath returns a new instance with field_path set.

func (ComparisonValueColumn) WithScope 

func (f ComparisonValueColumn) WithScope(scope *uint) *ComparisonValueColumn

WithScope return a new instance with a scope set.

type ComparisonValueEncoder 

type ComparisonValueEncoder interface {
	Type() ComparisonValueType
	Encode() ComparisonValue
}

ComparisonValueEncoder represents a comparison value encoder interface.

type ComparisonValueScalar 

type ComparisonValueScalar struct {
	Value any `json:"value" mapstructure:"value" yaml:"value"`
}

ComparisonValueScalar represents a comparison value with scalar type.

func NewComparisonValueScalar 

func NewComparisonValueScalar(value any) *ComparisonValueScalar

NewComparisonValueScalar creates a new ComparisonValueScalar instance.

func (ComparisonValueScalar) Encode 

func (cv ComparisonValueScalar) Encode() ComparisonValue

Encode converts to the raw comparison value.

func (ComparisonValueScalar) Type 

func (cv ComparisonValueScalar) Type() ComparisonValueType

Type return the type name of the instance.

type ComparisonValueType 

type ComparisonValueType string

ComparisonValueType represents a comparison value type enum. 

const (
	ComparisonValueTypeColumn   ComparisonValueType = "column"
	ComparisonValueTypeScalar   ComparisonValueType = "scalar"
	ComparisonValueTypeVariable ComparisonValueType = "variable"
)

func ParseComparisonValueType 

func ParseComparisonValueType(input string) (ComparisonValueType, error)

ParseComparisonValueType parses a comparison value type from string.

func (ComparisonValueType) IsValid 

func (j ComparisonValueType) IsValid() bool

IsValid checks if the value is invalid.

func (*ComparisonValueType) UnmarshalJSON 

func (j *ComparisonValueType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ComparisonValueVariable 

type ComparisonValueVariable struct {
	Name string `json:"name" mapstructure:"name" yaml:"name"`
}

ComparisonValueVariable represents a comparison value with variable type.

func NewComparisonValueVariable 

func NewComparisonValueVariable(name string) *ComparisonValueVariable

NewComparisonValueVariable creates a new ComparisonValueVariable instance.

func (ComparisonValueVariable) Encode 

func (cv ComparisonValueVariable) Encode() ComparisonValue

Encode converts to the raw comparison value.

func (ComparisonValueVariable) Type 

func (cv ComparisonValueVariable) Type() ComparisonValueType

Type return the type name of the instance.

type ConnectorError 

type ConnectorError struct {

	// A human-readable summary of the error
	Message string `json:"message" mapstructure:"message" yaml:"message"`
	// Any additional structured information about the error
	Details map[string]any `json:"details" mapstructure:"details" yaml:"details"`
	// contains filtered or unexported fields
}

ConnectorError represents a connector error that follows NDC error handling specs

func BadGatewayError 

func BadGatewayError(message string, details map[string]any) *ConnectorError

BadGatewayError returns an error when the request could not be handled because an upstream service was unavailable or returned an unexpected response, e.g., a connection to a database server failed.

func BadRequestError 

func BadRequestError(message string, details map[string]any) *ConnectorError

BadRequestError returns an error when the request did not match the data connector's expectation based on this specification.

func ConflictError 

func ConflictError(message string, details map[string]any) *ConnectorError

ConflictError returns an error when the request could not be handled because it would create a conflicting state for the data source, for example, a mutation might fail because a foreign key constraint was not met.

func ForbiddenError 

func ForbiddenError(message string, details map[string]any) *ConnectorError

ForbiddenError returns an error when the request could not be handled because a permission check failed, for example, a mutation might fail because a check constraint was not met.

func InternalServerError 

func InternalServerError(message string, details map[string]any) *ConnectorError

InternalServerError returns an error when the request could not be handled because of an error on the server.

func NewConnectorError 

func NewConnectorError(statusCode int, message string, details map[string]any) *ConnectorError

NewConnectorError creates a ConnectorError instance.

func NotSupportedError 

func NotSupportedError(message string, details map[string]any) *ConnectorError

NotSupportedError returns an error when the request could not be handled because it relies on an unsupported capability. Note: this ought to indicate an error on the caller side, since the caller should not generate requests which are incompatible with the indicated capabilities.

func UnauthorizeError 

func UnauthorizeError(message string, details map[string]any) *ConnectorError

UnauthorizeError returns an unauthorized error.

func UnprocessableContentError 

func UnprocessableContentError(message string, details map[string]any) *ConnectorError

UnprocessableContentError returns an error when the request could not be handled because, while the request was well-formed, it was not semantically correct. For example, a value for a custom scalar type was provided, but with an incorrect type.

func (ConnectorError) Error 

func (ce ConnectorError) Error() string

Error implements the Error interface.

func (ConnectorError) StatusCode 

func (ce ConnectorError) StatusCode() int

StatusCode gets the inner status code.

func (ConnectorError) String 

func (ce ConnectorError) String() string

String implements the Stringer interface.

type DatePartScalarExpressionCapability 

type DatePartScalarExpressionCapability struct {
	// Day corresponds to the JSON schema field "day".
	Day *LeafCapability `json:"day,omitempty" yaml:"day,omitempty" mapstructure:"day,omitempty"`

	// DayOfWeek corresponds to the JSON schema field "day_of_week".
	DayOfWeek *LeafCapability `json:"day_of_week,omitempty" yaml:"day_of_week,omitempty" mapstructure:"day_of_week,omitempty"`

	// DayOfYear corresponds to the JSON schema field "day_of_year".
	DayOfYear *LeafCapability `json:"day_of_year,omitempty" yaml:"day_of_year,omitempty" mapstructure:"day_of_year,omitempty"`

	// Epoch corresponds to the JSON schema field "epoch".
	Epoch *LeafCapability `json:"epoch,omitempty" yaml:"epoch,omitempty" mapstructure:"epoch,omitempty"`

	// Hour corresponds to the JSON schema field "hour".
	Hour *LeafCapability `json:"hour,omitempty" yaml:"hour,omitempty" mapstructure:"hour,omitempty"`

	// Microsecond corresponds to the JSON schema field "microsecond".
	Microsecond *LeafCapability `json:"microsecond,omitempty" yaml:"microsecond,omitempty" mapstructure:"microsecond,omitempty"`

	// Millisecond corresponds to the JSON schema field "millisecond".
	Millisecond *LeafCapability `json:"millisecond,omitempty" yaml:"millisecond,omitempty" mapstructure:"millisecond,omitempty"`

	// Minute corresponds to the JSON schema field "minute".
	Minute *LeafCapability `json:"minute,omitempty" yaml:"minute,omitempty" mapstructure:"minute,omitempty"`

	// Month corresponds to the JSON schema field "month".
	Month *LeafCapability `json:"month,omitempty" yaml:"month,omitempty" mapstructure:"month,omitempty"`

	// Nanosecond corresponds to the JSON schema field "nanosecond".
	Nanosecond *LeafCapability `json:"nanosecond,omitempty" yaml:"nanosecond,omitempty" mapstructure:"nanosecond,omitempty"`

	// Quarter corresponds to the JSON schema field "quarter".
	Quarter *LeafCapability `json:"quarter,omitempty" yaml:"quarter,omitempty" mapstructure:"quarter,omitempty"`

	// Second corresponds to the JSON schema field "second".
	Second *LeafCapability `json:"second,omitempty" yaml:"second,omitempty" mapstructure:"second,omitempty"`

	// Week corresponds to the JSON schema field "week".
	Week *LeafCapability `json:"week,omitempty" yaml:"week,omitempty" mapstructure:"week,omitempty"`

	// Year corresponds to the JSON schema field "year".
	Year *LeafCapability `json:"year,omitempty" yaml:"year,omitempty" mapstructure:"year,omitempty"`
}

type DatePartUnit 

type DatePartUnit string
const DatePartUnitDay DatePartUnit = "day"
const DatePartUnitDayOfWeek DatePartUnit = "day_of_week"
const DatePartUnitDayOfYear DatePartUnit = "day_of_year"
const DatePartUnitEpoch DatePartUnit = "epoch"
const DatePartUnitHour DatePartUnit = "hour"
const DatePartUnitMicrosecond DatePartUnit = "microsecond"
const DatePartUnitMillisecond DatePartUnit = "millisecond"
const DatePartUnitMinute DatePartUnit = "minute"
const DatePartUnitMonth DatePartUnit = "month"
const DatePartUnitNanosecond DatePartUnit = "nanosecond"
const DatePartUnitQuarter DatePartUnit = "quarter"
const DatePartUnitSecond DatePartUnit = "second"
const DatePartUnitWeek DatePartUnit = "week"
const DatePartUnitYear DatePartUnit = "year"

func (*DatePartUnit) UnmarshalJSON 

func (j *DatePartUnit) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type Dimension 

type Dimension struct {
	// contains filtered or unexported fields
}

Dimension represents a dimension object.

func NewDimension 

func NewDimension[T DimensionInner](inner T) Dimension

NewDimension creates a new Dimension instance.

func (Dimension) Equal 

func (j Dimension) Equal(value Dimension) bool

Equal checks whether instances are the same.

func (Dimension) Interface 

func (j Dimension) Interface() DimensionInner

Interface converts the comparison value to its generic interface.

func (Dimension) IsEmpty 

func (j Dimension) IsEmpty() bool

IsEmpty checks if the inner type is empty.

func (Dimension) MarshalJSON 

func (j Dimension) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler interface.

func (Dimension) Type 

func (j Dimension) Type() DimensionType

Type gets the type enum of the current type.

func (*Dimension) UnmarshalJSON 

func (j *Dimension) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type DimensionColumn 

type DimensionColumn struct {
	// Any (object) relationships to traverse to reach this column. Only non-empty if the 'relationships' capability is supported.
	Path []PathElement `json:"path"                 mapstructure:"path"        yaml:"path"`
	// The name of the column
	ColumnName string `json:"column_name"          mapstructure:"column_name" yaml:"column_name"`
	// Arguments to satisfy the column specified by 'column_name'
	Arguments map[string]Argument `json:"arguments,omitempty"  mapstructure:"arguments"   yaml:"arguments,omitempty"`
	// Path to a nested field within an object column.
	FieldPath []string `json:"field_path,omitempty" mapstructure:"field_path"  yaml:"field_path,omitempty"`
	// The name of the extraction function to apply to the selected value, if any.
	Extraction string `json:"extraction,omitempty" mapstructure:"extraction"  yaml:"extraction,omitempty"`
}

DimensionColumn represents a dimension column.

func NewDimensionColumn 

func NewDimensionColumn(columnName string, path []PathElement) *DimensionColumn

NewDimensionColumn creates a DimensionColumn instance.

func (DimensionColumn) ToMap 

func (j DimensionColumn) ToMap() map[string]any

Encode converts the instance to a raw map.

func (DimensionColumn) Type 

func (j DimensionColumn) Type() DimensionType

Type return the type name of the instance.

func (DimensionColumn) WithArgument 

func (f DimensionColumn) WithArgument(key string, argument ArgumentEncoder) *DimensionColumn

WithArgument return a new column field with an arguments set.

func (DimensionColumn) WithArguments 

func (f DimensionColumn) WithArguments(arguments map[string]ArgumentEncoder) *DimensionColumn

WithArguments return a new column field with arguments set.

func (DimensionColumn) WithExtraction 

func (f DimensionColumn) WithExtraction(extraction string) *DimensionColumn

WithExtraction return a new column field with extraction set.

func (DimensionColumn) WithFieldPath 

func (f DimensionColumn) WithFieldPath(fieldPath []string) *DimensionColumn

WithFieldPath return a new column field with field_path set.

func (DimensionColumn) Wrap 

func (j DimensionColumn) Wrap() Dimension

Encode returns the relation wrapper.

type DimensionInner 

type DimensionInner interface {
	Type() DimensionType
	ToMap() map[string]any
	Wrap() Dimension
}

DimensionInner abstracts a generic interface of Dimension.

type DimensionType 

type DimensionType string

DimensionType represents a type of Dimension. 

const (
	DimensionTypeColumn DimensionType = "column"
)

func ParseDimensionType 

func ParseDimensionType(input string) (DimensionType, error)

ParseDimensionType parses a DimensionType from string.

func (DimensionType) IsValid 

func (j DimensionType) IsValid() bool

IsValid checks if the value is invalid.

func (*DimensionType) UnmarshalJSON 

func (j *DimensionType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ErrorResponse 

type ErrorResponse struct {
	// Any additional structured information about the error
	Details interface{} `json:"details" yaml:"details" mapstructure:"details"`

	// A human-readable summary of the error
	Message string `json:"message" yaml:"message" mapstructure:"message"`
}

func (ErrorResponse) Error 

func (ce ErrorResponse) Error() string

Error implements the Error interface.

func (ErrorResponse) String 

func (ce ErrorResponse) String() string

String implements the Stringer interface.

func (*ErrorResponse) UnmarshalJSON 

func (j *ErrorResponse) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ExistsCapabilities 

type ExistsCapabilities struct {
	// Does the connector support named scopes in column references inside EXISTS
	// predicates
	NamedScopes *LeafCapability `json:"named_scopes,omitempty" yaml:"named_scopes,omitempty" mapstructure:"named_scopes,omitempty"`

	// Does the connector support ExistsInCollection::NestedCollection
	NestedCollections *LeafCapability `json:"nested_collections,omitempty" yaml:"nested_collections,omitempty" mapstructure:"nested_collections,omitempty"`

	// Does the connector support filtering over nested scalar arrays using
	// existential quantification. This means the connector must support
	// ExistsInCollection::NestedScalarCollection.
	NestedScalarCollections *LeafCapability `` /* 136-byte string literal not displayed */

	// Does the connector support ExistsInCollection::Unrelated
	Unrelated *LeafCapability `json:"unrelated,omitempty" yaml:"unrelated,omitempty" mapstructure:"unrelated,omitempty"`
}

type ExistsInCollection 

type ExistsInCollection map[string]any

ExistsInCollection represents an Exists In Collection object.

func (ExistsInCollection) AsNestedCollection 

func (j ExistsInCollection) AsNestedCollection() (*ExistsInCollectionNestedCollection, error)

AsNestedCollection tries to convert the instance to nested_collection type.

func (ExistsInCollection) AsNestedScalarCollection 

func (j ExistsInCollection) AsNestedScalarCollection() (*ExistsInCollectionNestedScalarCollection, error)

AsNestedScalarCollection tries to convert the instance to nested_scalar_collection type.

func (ExistsInCollection) AsRelated 

func (j ExistsInCollection) AsRelated() (*ExistsInCollectionRelated, error)

AsRelated tries to convert the instance to related type.

func (ExistsInCollection) AsUnrelated 

func (j ExistsInCollection) AsUnrelated() (*ExistsInCollectionUnrelated, error)

AsRelated tries to convert the instance to unrelated type.

func (*ExistsInCollection) FromValue 

func (j *ExistsInCollection) FromValue(input map[string]any) error

FromValue decodes values from any map.

func (ExistsInCollection) Interface 

func (j ExistsInCollection) Interface() ExistsInCollectionEncoder

Interface tries to convert the instance to the ExistsInCollectionEncoder interface.

func (ExistsInCollection) InterfaceT 

func (j ExistsInCollection) InterfaceT() (ExistsInCollectionEncoder, error)

InterfaceT tries to convert the instance to the ExistsInCollectionEncoder interface safely with explicit error.

func (ExistsInCollection) Type 

func (j ExistsInCollection) Type() (ExistsInCollectionType, error)

Type gets the type enum of the current type.

func (*ExistsInCollection) UnmarshalJSON 

func (j *ExistsInCollection) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ExistsInCollectionEncoder 

type ExistsInCollectionEncoder interface {
	Type() ExistsInCollectionType
	Encode() ExistsInCollection
}

ExistsInCollectionEncoder abstracts the ExistsInCollection serialization interface.

type ExistsInCollectionNestedCollection 

type ExistsInCollectionNestedCollection struct {
	// The name of column
	ColumnName string `json:"column_name"          mapstructure:"column_name" yaml:"column_name"`
	// Values to be provided to any collection arguments
	Arguments map[string]Argument `json:"arguments,omitempty"  mapstructure:"arguments"   yaml:"arguments,omitempty"`
	// Path to a nested collection via object columns
	FieldPath []string `json:"field_path,omitempty" mapstructure:"field_path"  yaml:"field_path,omitempty"`
}

ExistsInCollectionNestedCollection represents nested collections expression.

func NewExistsInCollectionNestedCollection 

func NewExistsInCollectionNestedCollection(columnName string) *ExistsInCollectionNestedCollection

NewExistsInCollectionNestedCollection creates an ExistsInCollectionNestedCollection instance.

func (ExistsInCollectionNestedCollection) Encode 

func (ei ExistsInCollectionNestedCollection) Encode() ExistsInCollection

Encode converts the instance to its raw type.

func (ExistsInCollectionNestedCollection) Type 

func (ei ExistsInCollectionNestedCollection) Type() ExistsInCollectionType

Type return the type name of the instance.

func (ExistsInCollectionNestedCollection) WithArgument 

func (f ExistsInCollectionNestedCollection) WithArgument(
	key string,
	argument ArgumentEncoder,
) *ExistsInCollectionNestedCollection

WithArgument return a new instance with an arguments set.

func (ExistsInCollectionNestedCollection) WithArguments 

func (f ExistsInCollectionNestedCollection) WithArguments(
	arguments map[string]ArgumentEncoder,
) *ExistsInCollectionNestedCollection

WithArguments return a new instance with arguments set.

func (ExistsInCollectionNestedCollection) WithFieldPath 

func (f ExistsInCollectionNestedCollection) WithFieldPath(
	fieldPath []string,
) *ExistsInCollectionNestedCollection

WithFieldPath returns a new instance with field_path set.

type ExistsInCollectionNestedScalarCollection 

type ExistsInCollectionNestedScalarCollection struct {
	// The name of column
	ColumnName string `json:"column_name"          mapstructure:"column_name" yaml:"column_name"`
	// Values to be provided to any collection arguments
	Arguments map[string]Argument `json:"arguments,omitempty"  mapstructure:"arguments"   yaml:"arguments,omitempty"`
	// Path to a nested collection via object columns
	FieldPath []string `json:"field_path,omitempty" mapstructure:"field_path"  yaml:"field_path,omitempty"`
}

ExistsInCollectionNestedScalarCollection Specifies a column that contains a nested array of scalars. The array will be brought into scope of the nested expression where each element becomes an object with one '__value' column that contains the element value. 

Only used if the 'query.exists.nested_scalar_collections' capability is supported.

func NewExistsInCollectionNestedScalarCollection 

func NewExistsInCollectionNestedScalarCollection(
	columnName string,
) *ExistsInCollectionNestedScalarCollection

NewExistsInCollectionNestedScalarCollection creates an ExistsInCollectionNestedScalarCollection instance.

func (ExistsInCollectionNestedScalarCollection) Encode 

func (ei ExistsInCollectionNestedScalarCollection) Encode() ExistsInCollection

Encode converts the instance to its raw type.

func (ExistsInCollectionNestedScalarCollection) Type 

func (ei ExistsInCollectionNestedScalarCollection) Type() ExistsInCollectionType

Type return the type name of the instance.

func (ExistsInCollectionNestedScalarCollection) WithArgument 

func (f ExistsInCollectionNestedScalarCollection) WithArgument(
	key string,
	argument ArgumentEncoder,
) *ExistsInCollectionNestedScalarCollection

WithArgument return a new instance with an arguments set.

func (ExistsInCollectionNestedScalarCollection) WithArguments 

func (f ExistsInCollectionNestedScalarCollection) WithArguments(
	arguments map[string]ArgumentEncoder,
) *ExistsInCollectionNestedScalarCollection

WithArguments return a new instance with arguments set.

func (ExistsInCollectionNestedScalarCollection) WithFieldPath 

func (f ExistsInCollectionNestedScalarCollection) WithFieldPath(
	fieldPath []string,
) *ExistsInCollectionNestedScalarCollection

WithFieldPath returns a new instance with field_path set.

type ExistsInCollectionRelated 

type ExistsInCollectionRelated struct {
	Relationship string `json:"relationship"         mapstructure:"relationship" yaml:"relationship"`
	// Values to be provided to any collection arguments
	Arguments map[string]RelationshipArgument `json:"arguments"            mapstructure:"arguments"    yaml:"arguments"`
	// Path to a nested field within an object column that must be navigated before the relationship is navigated.
	// Only non-empty if the 'relationships.nested.filtering' capability is supported.
	FieldPath []string `json:"field_path,omitempty" mapstructure:"field_path"   yaml:"field_path,omitempty"`
}

ExistsInCollectionRelated represents Related collections that are related to the original collection by a relationship in the collection_relationships field of the top-level QueryRequest.

func NewExistsInCollectionRelated 

func NewExistsInCollectionRelated(
	relationship string,
	arguments map[string]RelationshipArgument,
) *ExistsInCollectionRelated

NewExistsInCollectionRelated creates an ExistsInCollectionRelated instance.

func (ExistsInCollectionRelated) Encode 

func (ei ExistsInCollectionRelated) Encode() ExistsInCollection

Encode converts the instance to its raw type.

func (ExistsInCollectionRelated) Type 

func (ei ExistsInCollectionRelated) Type() ExistsInCollectionType

Type return the type name of the instance.

type ExistsInCollectionType 

type ExistsInCollectionType string

ExistsInCollectionType represents an exists in collection type enum. 

const (
	ExistsInCollectionTypeRelated                ExistsInCollectionType = "related"
	ExistsInCollectionTypeUnrelated              ExistsInCollectionType = "unrelated"
	ExistsInCollectionTypeNestedCollection       ExistsInCollectionType = "nested_collection"
	ExistsInCollectionTypeNestedScalarCollection ExistsInCollectionType = "nested_scalar_collection"
)

func ParseExistsInCollectionType 

func ParseExistsInCollectionType(input string) (ExistsInCollectionType, error)

ParseExistsInCollectionType parses a comparison value type from string.

func (ExistsInCollectionType) IsValid 

func (j ExistsInCollectionType) IsValid() bool

IsValid checks if the value is invalid.

func (*ExistsInCollectionType) UnmarshalJSON 

func (j *ExistsInCollectionType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ExistsInCollectionUnrelated 

type ExistsInCollectionUnrelated struct {
	// The name of a collection
	Collection string `json:"collection" mapstructure:"collection" yaml:"collection"`
	// Values to be provided to any collection arguments
	Arguments map[string]RelationshipArgument `json:"arguments"  mapstructure:"arguments"  yaml:"arguments"`
}

ExistsInCollectionUnrelated represents unrelated collections.

func NewExistsInCollectionUnrelated 

func NewExistsInCollectionUnrelated(
	collection string,
	arguments map[string]RelationshipArgument,
) *ExistsInCollectionUnrelated

NewExistsInCollectionUnrelated creates an ExistsInCollectionUnrelated instance.

func (ExistsInCollectionUnrelated) Encode 

func (ei ExistsInCollectionUnrelated) Encode() ExistsInCollection

Encode converts the instance to its raw type.

func (ExistsInCollectionUnrelated) Type 

func (ei ExistsInCollectionUnrelated) Type() ExistsInCollectionType

Type return the type name of the instance.

type ExplainResponse 

type ExplainResponse struct {
	// A list of human-readable key-value pairs describing a query execution plan. For
	// example, a connector for a relational database might return the generated SQL
	// and/or the output of the `EXPLAIN` command. An API-based connector might encode
	// a list of statically-known API calls which would be made.
	Details ExplainResponseDetails `json:"details" yaml:"details" mapstructure:"details"`
}

func (*ExplainResponse) UnmarshalJSON 

func (j *ExplainResponse) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ExplainResponseDetails 

type ExplainResponseDetails map[string]string

A list of human-readable key-value pairs describing a query execution plan. For example, a connector for a relational database might return the generated SQL and/or the output of the `EXPLAIN` command. An API-based connector might encode a list of statically-known API calls which would be made.

type Expression 

type Expression map[string]any

Expression represents the query expression object.

func (Expression) AsAnd 

func (j Expression) AsAnd() (*ExpressionAnd, error)

AsAnd tries to convert the instance to and type.

func (Expression) AsArrayComparison 

func (j Expression) AsArrayComparison() (*ExpressionArrayComparison, error)

AsArrayComparison tries to convert the instance to ExpressionArrayComparison instance.

func (Expression) AsBinaryComparisonOperator 

func (j Expression) AsBinaryComparisonOperator() (*ExpressionBinaryComparisonOperator, error)

AsBinaryComparisonOperator tries to convert the instance to ExpressionBinaryComparisonOperator instance.

func (Expression) AsExists 

func (j Expression) AsExists() (*ExpressionExists, error)

AsExists tries to convert the instance to ExpressionExists instance.

func (Expression) AsNot 

func (j Expression) AsNot() (*ExpressionNot, error)

AsNot tries to convert the instance to ExpressionNot instance.

func (Expression) AsOr 

func (j Expression) AsOr() (*ExpressionOr, error)

AsOr tries to convert the instance to ExpressionOr instance.

func (Expression) AsUnaryComparisonOperator 

func (j Expression) AsUnaryComparisonOperator() (*ExpressionUnaryComparisonOperator, error)

AsUnaryComparisonOperator tries to convert the instance to ExpressionUnaryComparisonOperator instance.

func (*Expression) FromValue 

func (j *Expression) FromValue(input map[string]any) error

FromValue decodes values from any map.

func (Expression) Interface 

func (j Expression) Interface() ExpressionEncoder

Interface tries to convert the instance to the ExpressionEncoder interface.

func (Expression) InterfaceT 

func (j Expression) InterfaceT() (ExpressionEncoder, error)

InterfaceT tries to convert the instance to the ExpressionEncoder interface safely with explicit error.

func (Expression) Type 

func (j Expression) Type() (ExpressionType, error)

Type gets the type enum of the current type.

func (*Expression) UnmarshalJSON 

func (j *Expression) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ExpressionAnd 

type ExpressionAnd struct {
	Expressions []Expression `json:"expressions" mapstructure:"expressions" yaml:"expressions"`
}

ExpressionAnd is an object which represents the conjunction of expressions

func NewExpressionAnd 

func NewExpressionAnd(expressions ...ExpressionEncoder) *ExpressionAnd

NewExpressionAnd creates an ExpressionAnd instance.

func (ExpressionAnd) Encode 

func (exp ExpressionAnd) Encode() Expression

Encode converts the instance to a raw Expression.

func (ExpressionAnd) Type 

func (exp ExpressionAnd) Type() ExpressionType

Type return the type name of the instance.

type ExpressionArrayComparison 

type ExpressionArrayComparison struct {
	Column     ComparisonTarget `json:"column"     mapstructure:"column"     yaml:"column"`
	Comparison ArrayComparison  `json:"comparison" mapstructure:"comparison" yaml:"comparison"`
}

ExpressionArrayComparison is comparison against a nested array column. Only used if the 'query.nested_fields.filter_by.nested_arrays' capability is supported.

func NewExpressionArrayComparison 

func NewExpressionArrayComparison[C ComparisonTargetEncoder, A ArrayComparisonEncoder](
	column C,
	comparison A,
) *ExpressionArrayComparison

NewExpressionArrayComparison creates an ExpressionArrayComparison instance.

func (ExpressionArrayComparison) Encode 

func (exp ExpressionArrayComparison) Encode() Expression

Encode converts the instance to a raw Expression.

func (ExpressionArrayComparison) Type 

func (exp ExpressionArrayComparison) Type() ExpressionType

Type return the type name of the instance.

type ExpressionBinaryComparisonOperator 

type ExpressionBinaryComparisonOperator struct {
	Operator string           `json:"operator" mapstructure:"operator" yaml:"operator"`
	Column   ComparisonTarget `json:"column"   mapstructure:"column"   yaml:"column"`
	Value    ComparisonValue  `json:"value"    mapstructure:"value"    yaml:"value"`
}

ExpressionBinaryComparisonOperator is an object which represents an binary operator expression

func NewExpressionBinaryComparisonOperator 

func NewExpressionBinaryComparisonOperator[T ComparisonTargetEncoder, V ComparisonValueEncoder](
	column T,
	operator string,
	value V,
) *ExpressionBinaryComparisonOperator

NewExpressionBinaryComparisonOperator creates an ExpressionBinaryComparisonOperator instance.

func (ExpressionBinaryComparisonOperator) Encode 

func (exp ExpressionBinaryComparisonOperator) Encode() Expression

Encode converts the instance to a raw Expression.

func (ExpressionBinaryComparisonOperator) Type 

func (exp ExpressionBinaryComparisonOperator) Type() ExpressionType

Type return the type name of the instance.

type ExpressionEncoder 

type ExpressionEncoder interface {
	Type() ExpressionType
	Encode() Expression
}

ExpressionEncoder abstracts the expression encoder interface.

type ExpressionExists 

type ExpressionExists struct {
	Predicate    Expression         `json:"predicate"     mapstructure:"predicate"     yaml:"predicate"`
	InCollection ExistsInCollection `json:"in_collection" mapstructure:"in_collection" yaml:"in_collection"`
}

ExpressionExists is an object which represents an EXISTS expression

func NewExpressionExists 

func NewExpressionExists[E ExpressionEncoder, I ExistsInCollectionEncoder](
	predicate E,
	inCollection I,
) *ExpressionExists

NewExpressionExists creates an ExpressionExists instance.

func (ExpressionExists) Encode 

func (exp ExpressionExists) Encode() Expression

Encode converts the instance to a raw Expression.

func (ExpressionExists) Type 

func (exp ExpressionExists) Type() ExpressionType

Type return the type name of the instance.

type ExpressionNot 

type ExpressionNot struct {
	Expression Expression `json:"expression" mapstructure:"expression" yaml:"expression"`
}

ExpressionNot is an object which represents the negation of an expression

func NewExpressionNot 

func NewExpressionNot[E ExpressionEncoder](expression E) *ExpressionNot

NewExpressionNot creates an ExpressionNot instance.

func (ExpressionNot) Encode 

func (exp ExpressionNot) Encode() Expression

Encode converts the instance to a raw Expression.

func (ExpressionNot) Type 

func (exp ExpressionNot) Type() ExpressionType

Type return the type name of the instance.

type ExpressionOr 

type ExpressionOr struct {
	Expressions []Expression `json:"expressions" mapstructure:"expressions" yaml:"expressions"`
}

ExpressionOr is an object which represents the disjunction of expressions

func NewExpressionOr 

func NewExpressionOr(expressions ...ExpressionEncoder) *ExpressionOr

NewExpressionOr creates an ExpressionOr instance.

func (ExpressionOr) Encode 

func (exp ExpressionOr) Encode() Expression

Encode converts the instance to a raw Expression.

func (ExpressionOr) Type 

func (exp ExpressionOr) Type() ExpressionType

Type return the type name of the instance.

type ExpressionType 

type ExpressionType string

ExpressionType represents the filtering expression enums. 

const (
	ExpressionTypeAnd                      ExpressionType = "and"
	ExpressionTypeOr                       ExpressionType = "or"
	ExpressionTypeNot                      ExpressionType = "not"
	ExpressionTypeUnaryComparisonOperator  ExpressionType = "unary_comparison_operator"
	ExpressionTypeBinaryComparisonOperator ExpressionType = "binary_comparison_operator"
	ExpressionTypeArrayComparison          ExpressionType = "array_comparison"
	ExpressionTypeExists                   ExpressionType = "exists"
)

func ParseExpressionType 

func ParseExpressionType(input string) (ExpressionType, error)

ParseExpressionType parses an expression type argument type from string.

func (ExpressionType) IsValid 

func (j ExpressionType) IsValid() bool

IsValid checks if the value is invalid.

func (*ExpressionType) UnmarshalJSON 

func (j *ExpressionType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ExpressionUnaryComparisonOperator 

type ExpressionUnaryComparisonOperator struct {
	Operator UnaryComparisonOperator `json:"operator" mapstructure:"operator" yaml:"operator"`
	Column   ComparisonTarget        `json:"column"   mapstructure:"column"   yaml:"column"`
}

ExpressionUnaryComparisonOperator is an object which represents a unary operator expression

func NewExpressionUnaryComparisonOperator 

func NewExpressionUnaryComparisonOperator[C ComparisonTargetEncoder](
	column C,
	operator UnaryComparisonOperator,
) *ExpressionUnaryComparisonOperator

NewExpressionUnaryComparisonOperator creates an ExpressionUnaryComparisonOperator instance.

func (ExpressionUnaryComparisonOperator) Encode 

func (exp ExpressionUnaryComparisonOperator) Encode() Expression

Encode converts the instance to a raw Expression.

func (ExpressionUnaryComparisonOperator) Type 

func (exp ExpressionUnaryComparisonOperator) Type() ExpressionType

Type return the type name of the instance.

type ExtractionFunctionDefinition 

type ExtractionFunctionDefinition map[string]any

ExtractionFunctionDefinition represents the definition of an aggregation function on a scalar type.

func (ExtractionFunctionDefinition) AsCustom 

func (j ExtractionFunctionDefinition) AsCustom() (*ExtractionFunctionDefinitionCustom, error)

AsCustom tries to convert the instance to ComparisonOperatorIn type.

func (ExtractionFunctionDefinition) AsDay 

func (j ExtractionFunctionDefinition) AsDay() (*ExtractionFunctionDefinitionDay, error)

AsDay tries to convert the instance to ExtractionFunctionDefinitionDay type.

func (ExtractionFunctionDefinition) AsDayOfWeek 

func (j ExtractionFunctionDefinition) AsDayOfWeek() (*ExtractionFunctionDefinitionDayOfWeek, error)

AsDayOfWeek tries to convert the instance to ExtractionFunctionDefinitionDayOfWeek type.

func (ExtractionFunctionDefinition) AsDayOfYear 

func (j ExtractionFunctionDefinition) AsDayOfYear() (*ExtractionFunctionDefinitionDayOfYear, error)

AsDayOfYear tries to convert the instance to ExtractionFunctionDefinitionDayOfYear type.

func (ExtractionFunctionDefinition) AsHour 

func (j ExtractionFunctionDefinition) AsHour() (*ExtractionFunctionDefinitionHour, error)

AsHour tries to convert the instance to ExtractionFunctionDefinitionHour type.

func (ExtractionFunctionDefinition) AsMicrosecond 

func (j ExtractionFunctionDefinition) AsMicrosecond() (*ExtractionFunctionDefinitionMicrosecond, error)

AsMicrosecond tries to convert the instance to ExtractionFunctionDefinitionMicrosecond type.

func (ExtractionFunctionDefinition) AsMillisecond 

func (j ExtractionFunctionDefinition) AsMillisecond() (*ExtractionFunctionDefinitionMillisecond, error)

AsMillisecond tries to convert the instance to ExtractionFunctionDefinitionMillisecond type.

func (ExtractionFunctionDefinition) AsMinute 

func (j ExtractionFunctionDefinition) AsMinute() (*ExtractionFunctionDefinitionMinute, error)

AsMinute tries to convert the instance to ExtractionFunctionDefinitionMinute type.

func (ExtractionFunctionDefinition) AsMonth 

func (j ExtractionFunctionDefinition) AsMonth() (*ExtractionFunctionDefinitionMonth, error)

AsMonth tries to convert the instance to ExtractionFunctionDefinitionMonth type.

func (ExtractionFunctionDefinition) AsNanosecond 

func (j ExtractionFunctionDefinition) AsNanosecond() (*ExtractionFunctionDefinitionNanosecond, error)

AsNanosecond tries to convert the instance to ExtractionFunctionDefinitionNanosecond type.

func (ExtractionFunctionDefinition) AsQuarter 

func (j ExtractionFunctionDefinition) AsQuarter() (*ExtractionFunctionDefinitionQuarter, error)

AsQuarter tries to convert the instance to ExtractionFunctionDefinitionQuarter type.

func (ExtractionFunctionDefinition) AsSecond 

func (j ExtractionFunctionDefinition) AsSecond() (*ExtractionFunctionDefinitionSecond, error)

AsSecond tries to convert the instance to ExtractionFunctionDefinitionSecond type.

func (ExtractionFunctionDefinition) AsWeek 

func (j ExtractionFunctionDefinition) AsWeek() (*ExtractionFunctionDefinitionWeek, error)

AsWeek tries to convert the instance to ExtractionFunctionDefinitionWeek type.

func (ExtractionFunctionDefinition) AsYear 

func (j ExtractionFunctionDefinition) AsYear() (*ExtractionFunctionDefinitionYear, error)

AsYear tries to convert the instance to ExtractionFunctionDefinitionYear type.

func (ExtractionFunctionDefinition) Interface 

func (j ExtractionFunctionDefinition) Interface() ExtractionFunctionDefinitionEncoder

Interface tries to convert the instance to ComparisonOperatorDefinitionEncoder interface.

func (ExtractionFunctionDefinition) InterfaceT 

func (j ExtractionFunctionDefinition) InterfaceT() (ExtractionFunctionDefinitionEncoder, error)

InterfaceT tries to convert the instance to ComparisonOperatorDefinitionEncoder interface safely with explicit error.

func (ExtractionFunctionDefinition) Type 

func (j ExtractionFunctionDefinition) Type() (ExtractionFunctionDefinitionType, error)

Type gets the type enum of the current type.

func (*ExtractionFunctionDefinition) UnmarshalJSON 

func (j *ExtractionFunctionDefinition) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ExtractionFunctionDefinitionCustom 

type ExtractionFunctionDefinitionCustom struct {
	ResultType Type `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

ExtractionFunctionDefinitionCustom presents a custom extraction function definition.

func NewExtractionFunctionDefinitionCustom 

func NewExtractionFunctionDefinitionCustom(
	resultType TypeEncoder,
) *ExtractionFunctionDefinitionCustom

NewExtractionFunctionDefinitionCustom create a new ExtractionFunctionDefinitionCustom instance.

func (ExtractionFunctionDefinitionCustom) Encode 

func (efd ExtractionFunctionDefinitionCustom) Encode() ExtractionFunctionDefinition

Encode converts the instance to raw ExtractionFunctionDefinition.

func (ExtractionFunctionDefinitionCustom) Type 

func (efd ExtractionFunctionDefinitionCustom) Type() ExtractionFunctionDefinitionType

Type return the type name of the instance.

type ExtractionFunctionDefinitionDay 

type ExtractionFunctionDefinitionDay struct {
	ResultType string `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

ExtractionFunctionDefinitionDay presents a day extraction function definition.

func NewExtractionFunctionDefinitionDay 

func NewExtractionFunctionDefinitionDay(resultType string) *ExtractionFunctionDefinitionDay

NewExtractionFunctionDefinitionDay create a new ExtractionFunctionDefinitionDay instance.

func (ExtractionFunctionDefinitionDay) Encode 

func (efd ExtractionFunctionDefinitionDay) Encode() ExtractionFunctionDefinition

Encode converts the instance to raw ExtractionFunctionDefinition.

func (ExtractionFunctionDefinitionDay) Type 

func (efd ExtractionFunctionDefinitionDay) Type() ExtractionFunctionDefinitionType

Type return the type name of the instance.

type ExtractionFunctionDefinitionDayOfWeek 

type ExtractionFunctionDefinitionDayOfWeek struct {
	ResultType string `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

ExtractionFunctionDefinitionDayOfWeek presents a day-of-week extraction function definition.

func NewExtractionFunctionDefinitionDayOfWeek 

func NewExtractionFunctionDefinitionDayOfWeek(
	resultType string,
) *ExtractionFunctionDefinitionDayOfWeek

NewExtractionFunctionDefinitionDayOfWeek create a new ExtractionFunctionDefinitionDayOfWeek instance.

func (ExtractionFunctionDefinitionDayOfWeek) Encode 

func (efd ExtractionFunctionDefinitionDayOfWeek) Encode() ExtractionFunctionDefinition

Encode converts the instance to raw ExtractionFunctionDefinition.

func (ExtractionFunctionDefinitionDayOfWeek) Type 

func (efd ExtractionFunctionDefinitionDayOfWeek) Type() ExtractionFunctionDefinitionType

Type return the type name of the instance.

type ExtractionFunctionDefinitionDayOfYear 

type ExtractionFunctionDefinitionDayOfYear struct {
	ResultType string `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

ExtractionFunctionDefinitionDayOfYear presents a day-of-year extraction function definition.

func NewExtractionFunctionDefinitionDayOfYear 

func NewExtractionFunctionDefinitionDayOfYear(
	resultType string,
) *ExtractionFunctionDefinitionDayOfYear

NewExtractionFunctionDefinitionDayOfYear create a new ExtractionFunctionDefinitionDayOfYear instance.

func (ExtractionFunctionDefinitionDayOfYear) Encode 

func (efd ExtractionFunctionDefinitionDayOfYear) Encode() ExtractionFunctionDefinition

Encode converts the instance to raw ExtractionFunctionDefinition.

func (ExtractionFunctionDefinitionDayOfYear) Type 

func (efd ExtractionFunctionDefinitionDayOfYear) Type() ExtractionFunctionDefinitionType

Type return the type name of the instance.

type ExtractionFunctionDefinitionEncoder 

type ExtractionFunctionDefinitionEncoder interface {
	Type() ExtractionFunctionDefinitionType
	Encode() ExtractionFunctionDefinition
}

ExtractionFunctionDefinitionEncoder abstracts the serialization interface for ExtractionFunctionDefinition.

type ExtractionFunctionDefinitionHour 

type ExtractionFunctionDefinitionHour struct {
	ResultType string `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

ExtractionFunctionDefinitionHour presents an hour extraction function definition.

func NewExtractionFunctionDefinitionHour 

func NewExtractionFunctionDefinitionHour(resultType string) *ExtractionFunctionDefinitionHour

NewExtractionFunctionDefinitionHour create a new ExtractionFunctionDefinitionHour instance.

func (ExtractionFunctionDefinitionHour) Encode 

func (efd ExtractionFunctionDefinitionHour) Encode() ExtractionFunctionDefinition

Encode converts the instance to raw ExtractionFunctionDefinition.

func (ExtractionFunctionDefinitionHour) Type 

func (efd ExtractionFunctionDefinitionHour) Type() ExtractionFunctionDefinitionType

Type return the type name of the instance.

type ExtractionFunctionDefinitionMicrosecond 

type ExtractionFunctionDefinitionMicrosecond struct {
	ResultType string `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

ExtractionFunctionDefinitionMicrosecond presents a microsecond extraction function definition.

func NewExtractionFunctionDefinitionMicrosecond 

func NewExtractionFunctionDefinitionMicrosecond(
	resultType string,
) *ExtractionFunctionDefinitionMicrosecond

NewExtractionFunctionDefinitionMicrosecond create a new ExtractionFunctionDefinitionMicrosecond instance.

func (ExtractionFunctionDefinitionMicrosecond) Encode 

func (efd ExtractionFunctionDefinitionMicrosecond) Encode() ExtractionFunctionDefinition

Encode converts the instance to raw ExtractionFunctionDefinition.

func (ExtractionFunctionDefinitionMicrosecond) Type 

func (efd ExtractionFunctionDefinitionMicrosecond) Type() ExtractionFunctionDefinitionType

Type return the type name of the instance.

type ExtractionFunctionDefinitionMillisecond 

type ExtractionFunctionDefinitionMillisecond struct {
	ResultType string `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

ExtractionFunctionDefinitionMillisecond presents a millisecond extraction function definition.

func NewExtractionFunctionDefinitionMillisecond 

func NewExtractionFunctionDefinitionMillisecond(
	resultType string,
) *ExtractionFunctionDefinitionMillisecond

NewExtractionFunctionDefinitionMillisecond create a new ExtractionFunctionDefinitionMillisecond instance.

func (ExtractionFunctionDefinitionMillisecond) Encode 

func (efd ExtractionFunctionDefinitionMillisecond) Encode() ExtractionFunctionDefinition

Encode converts the instance to raw ExtractionFunctionDefinition.

func (ExtractionFunctionDefinitionMillisecond) Type 

func (efd ExtractionFunctionDefinitionMillisecond) Type() ExtractionFunctionDefinitionType

Type return the type name of the instance.

type ExtractionFunctionDefinitionMinute 

type ExtractionFunctionDefinitionMinute struct {
	ResultType string `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

ExtractionFunctionDefinitionMinute presents a minute extraction function definition.

func NewExtractionFunctionDefinitionMinute 

func NewExtractionFunctionDefinitionMinute(resultType string) *ExtractionFunctionDefinitionMinute

NewExtractionFunctionDefinitionMinute create a new ExtractionFunctionDefinitionMinute instance.

func (ExtractionFunctionDefinitionMinute) Encode 

func (efd ExtractionFunctionDefinitionMinute) Encode() ExtractionFunctionDefinition

Encode converts the instance to raw ExtractionFunctionDefinition.

func (ExtractionFunctionDefinitionMinute) Type 

func (efd ExtractionFunctionDefinitionMinute) Type() ExtractionFunctionDefinitionType

Type return the type name of the instance.

type ExtractionFunctionDefinitionMonth 

type ExtractionFunctionDefinitionMonth struct {
	ResultType string `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

ExtractionFunctionDefinitionMonth presents a month extraction function definition.

func NewExtractionFunctionDefinitionMonth 

func NewExtractionFunctionDefinitionMonth(resultType string) *ExtractionFunctionDefinitionMonth

NewExtractionFunctionDefinitionMonth create a new ExtractionFunctionDefinitionMonth instance.

func (ExtractionFunctionDefinitionMonth) Encode 

func (efd ExtractionFunctionDefinitionMonth) Encode() ExtractionFunctionDefinition

Encode converts the instance to raw ExtractionFunctionDefinition.

func (ExtractionFunctionDefinitionMonth) Type 

func (efd ExtractionFunctionDefinitionMonth) Type() ExtractionFunctionDefinitionType

Type return the type name of the instance.

type ExtractionFunctionDefinitionNanosecond 

type ExtractionFunctionDefinitionNanosecond struct {
	ResultType string `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

ExtractionFunctionDefinitionNanosecond presents a nanosecond extraction function definition.

func NewExtractionFunctionDefinitionNanosecond 

func NewExtractionFunctionDefinitionNanosecond(
	resultType string,
) *ExtractionFunctionDefinitionNanosecond

NewExtractionFunctionDefinitionNanosecond create a new ExtractionFunctionDefinitionNanosecond instance.

func (ExtractionFunctionDefinitionNanosecond) Encode 

func (efd ExtractionFunctionDefinitionNanosecond) Encode() ExtractionFunctionDefinition

Encode converts the instance to raw ExtractionFunctionDefinition.

func (ExtractionFunctionDefinitionNanosecond) Type 

func (efd ExtractionFunctionDefinitionNanosecond) Type() ExtractionFunctionDefinitionType

Type return the type name of the instance.

type ExtractionFunctionDefinitionQuarter 

type ExtractionFunctionDefinitionQuarter struct {
	ResultType string `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

ExtractionFunctionDefinitionQuarter presents a quarter extraction function definition.

func NewExtractionFunctionDefinitionQuarter 

func NewExtractionFunctionDefinitionQuarter(
	resultType string,
) *ExtractionFunctionDefinitionQuarter

NewExtractionFunctionDefinitionQuarter create a new ExtractionFunctionDefinitionQuarter instance.

func (ExtractionFunctionDefinitionQuarter) Encode 

func (efd ExtractionFunctionDefinitionQuarter) Encode() ExtractionFunctionDefinition

Encode converts the instance to raw ExtractionFunctionDefinition.

func (ExtractionFunctionDefinitionQuarter) Type 

func (efd ExtractionFunctionDefinitionQuarter) Type() ExtractionFunctionDefinitionType

Type return the type name of the instance.

type ExtractionFunctionDefinitionSecond 

type ExtractionFunctionDefinitionSecond struct {
	ResultType string `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

ExtractionFunctionDefinitionSecond presents a second extraction function definition.

func NewExtractionFunctionDefinitionSecond 

func NewExtractionFunctionDefinitionSecond(resultType string) *ExtractionFunctionDefinitionSecond

NewExtractionFunctionDefinitionSecond create a new ExtractionFunctionDefinitionMicrosecond instance.

func (ExtractionFunctionDefinitionSecond) Encode 

func (efd ExtractionFunctionDefinitionSecond) Encode() ExtractionFunctionDefinition

Encode converts the instance to raw ExtractionFunctionDefinition.

func (ExtractionFunctionDefinitionSecond) Type 

func (efd ExtractionFunctionDefinitionSecond) Type() ExtractionFunctionDefinitionType

Type return the type name of the instance.

type ExtractionFunctionDefinitionType 

type ExtractionFunctionDefinitionType string

ExtractionFunctionDefinitionType represents an extraction function definition type. 

const (
	ExtractionFunctionDefinitionTypeNanosecond  ExtractionFunctionDefinitionType = "nanosecond"
	ExtractionFunctionDefinitionTypeMicrosecond ExtractionFunctionDefinitionType = "microsecond"
	ExtractionFunctionDefinitionTypeMillisecond ExtractionFunctionDefinitionType = "millisecond"
	ExtractionFunctionDefinitionTypeSecond      ExtractionFunctionDefinitionType = "second"
	ExtractionFunctionDefinitionTypeMinute      ExtractionFunctionDefinitionType = "minute"
	ExtractionFunctionDefinitionTypeHour        ExtractionFunctionDefinitionType = "hour"
	ExtractionFunctionDefinitionTypeDay         ExtractionFunctionDefinitionType = "day"
	ExtractionFunctionDefinitionTypeWeek        ExtractionFunctionDefinitionType = "week"
	ExtractionFunctionDefinitionTypeMonth       ExtractionFunctionDefinitionType = "month"
	ExtractionFunctionDefinitionTypeQuarter     ExtractionFunctionDefinitionType = "quarter"
	ExtractionFunctionDefinitionTypeYear        ExtractionFunctionDefinitionType = "year"
	ExtractionFunctionDefinitionTypeDayOfWeek   ExtractionFunctionDefinitionType = "day_of_week"
	ExtractionFunctionDefinitionTypeDayOfYear   ExtractionFunctionDefinitionType = "day_of_year"
	ExtractionFunctionDefinitionTypeCustom      ExtractionFunctionDefinitionType = "custom"
)

func ParseExtractionFunctionDefinitionType 

func ParseExtractionFunctionDefinitionType(input string) (ExtractionFunctionDefinitionType, error)

ParseExtractionFunctionDefinitionType parses a ordering target type argument type from string.

func (ExtractionFunctionDefinitionType) IsValid 

func (j ExtractionFunctionDefinitionType) IsValid() bool

IsValid checks if the value is invalid.

func (*ExtractionFunctionDefinitionType) UnmarshalJSON 

func (j *ExtractionFunctionDefinitionType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ExtractionFunctionDefinitionWeek 

type ExtractionFunctionDefinitionWeek struct {
	ResultType string `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

ExtractionFunctionDefinitionWeek presents a week extraction function definition.

func NewExtractionFunctionDefinitionWeek 

func NewExtractionFunctionDefinitionWeek(resultType string) *ExtractionFunctionDefinitionWeek

NewExtractionFunctionDefinitionWeek create a new ExtractionFunctionDefinitionWeek instance.

func (ExtractionFunctionDefinitionWeek) Encode 

func (efd ExtractionFunctionDefinitionWeek) Encode() ExtractionFunctionDefinition

Encode converts the instance to raw ExtractionFunctionDefinition.

func (ExtractionFunctionDefinitionWeek) Type 

func (efd ExtractionFunctionDefinitionWeek) Type() ExtractionFunctionDefinitionType

Type return the type name of the instance.

type ExtractionFunctionDefinitionYear 

type ExtractionFunctionDefinitionYear struct {
	ResultType string `json:"result_type" mapstructure:"result_type" yaml:"result_type"`
}

ExtractionFunctionDefinitionYear presents a year extraction function definition.

func NewExtractionFunctionDefinitionYear 

func NewExtractionFunctionDefinitionYear(resultType string) *ExtractionFunctionDefinitionYear

NewExtractionFunctionDefinitionYear create a new ExtractionFunctionDefinitionYear instance.

func (ExtractionFunctionDefinitionYear) Encode 

func (efd ExtractionFunctionDefinitionYear) Encode() ExtractionFunctionDefinition

Encode converts the instance to raw ExtractionFunctionDefinition.

func (ExtractionFunctionDefinitionYear) Type 

func (efd ExtractionFunctionDefinitionYear) Type() ExtractionFunctionDefinitionType

Type return the type name of the instance.

type Field 

type Field map[string]any

Field represents a field.

func (Field) AsColumn 

func (j Field) AsColumn() (*ColumnField, error)

AsColumn tries to convert the current type to ColumnField.

func (Field) AsRelationship 

func (j Field) AsRelationship() (*RelationshipField, error)

AsRelationship tries to convert the current type to RelationshipField.

func (Field) Interface 

func (j Field) Interface() FieldEncoder

Interface converts the comparison value to its generic interface.

func (Field) InterfaceT 

func (j Field) InterfaceT() (FieldEncoder, error)

InterfaceT converts the comparison value to its generic interface safely with explicit error.

func (Field) Type 

func (j Field) Type() (FieldType, error)

Type gets the type enum of the current type.

func (*Field) UnmarshalJSON 

func (j *Field) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type FieldEncoder 

type FieldEncoder interface {
	Type() FieldType
	Encode() Field
}

FieldEncoder abstracts the serialization interface for Field family.

type FieldType 

type FieldType string

FieldType represents a field type. 

const (
	FieldTypeColumn       FieldType = "column"
	FieldTypeRelationship FieldType = "relationship"
)

func ParseFieldType 

func ParseFieldType(input string) (FieldType, error)

ParseFieldType parses a field type from string.

func (FieldType) IsValid 

func (j FieldType) IsValid() bool

IsValid checks if the value is invalid.

func (*FieldType) UnmarshalJSON 

func (j *FieldType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ForeignKeyConstraint 

type ForeignKeyConstraint struct {
	// The columns on which you want want to define the foreign key. This is a mapping
	// between fields on object type to columns on the foreign collection. The column
	// on the foreign collection is specified via a field path (ie. an array of field
	// names that descend through nested object fields). The field path must only
	// contain a single item, meaning a column on the foreign collection's type,
	// unless the 'relationships.nested' capability is supported, in which case
	// multiple items can be used to denote a nested object field.
	ColumnMapping ForeignKeyConstraintColumnMapping `json:"column_mapping" yaml:"column_mapping" mapstructure:"column_mapping"`

	// The name of a collection
	ForeignCollection string `json:"foreign_collection" yaml:"foreign_collection" mapstructure:"foreign_collection"`
}

func (*ForeignKeyConstraint) UnmarshalJSON 

func (j *ForeignKeyConstraint) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ForeignKeyConstraintColumnMapping 

type ForeignKeyConstraintColumnMapping map[string][]string

The columns on which you want want to define the foreign key. This is a mapping between fields on object type to columns on the foreign collection. The column on the foreign collection is specified via a field path (ie. an array of field names that descend through nested object fields). The field path must only contain a single item, meaning a column on the foreign collection's type, unless the 'relationships.nested' capability is supported, in which case multiple items can be used to denote a nested object field.

type FunctionInfo 

type FunctionInfo struct {
	// Any arguments that this collection requires
	Arguments FunctionInfoArguments `json:"arguments" yaml:"arguments" mapstructure:"arguments"`

	// Description of the function
	Description *string `json:"description,omitempty" yaml:"description,omitempty" mapstructure:"description,omitempty"`

	// The name of the function
	Name string `json:"name" yaml:"name" mapstructure:"name"`

	// The name of the function's result type
	ResultType Type `json:"result_type" yaml:"result_type" mapstructure:"result_type"`
}

func (*FunctionInfo) UnmarshalJSON 

func (j *FunctionInfo) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

func (*FunctionInfo) UnmarshalJSONMap 

func (j *FunctionInfo) UnmarshalJSONMap(raw map[string]json.RawMessage) error

UnmarshalJSONMap decodes FunctionInfo from a JSON map.

type FunctionInfoArguments 

type FunctionInfoArguments map[string]ArgumentInfo

Any arguments that this collection requires

type Group 

type Group struct {
	// Aggregates computed within this group
	Aggregates GroupAggregates `json:"aggregates" yaml:"aggregates" mapstructure:"aggregates"`

	// Values of dimensions which identify this group
	Dimensions []interface{} `json:"dimensions" yaml:"dimensions" mapstructure:"dimensions"`
}

func (Group) ToMap 

func (j Group) ToMap() map[string]any

ToMap encodes the struct to a value map.

func (*Group) UnmarshalJSON 

func (j *Group) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type GroupAggregates 

type GroupAggregates map[string]interface{}

Aggregates computed within this group

type GroupByCapabilities 

type GroupByCapabilities struct {
	// Does the connector support post-grouping predicates
	Filter *LeafCapability `json:"filter,omitempty" yaml:"filter,omitempty" mapstructure:"filter,omitempty"`

	// Does the connector support post-grouping ordering
	Order *LeafCapability `json:"order,omitempty" yaml:"order,omitempty" mapstructure:"order,omitempty"`

	// Does the connector support post-grouping pagination
	Paginate *LeafCapability `json:"paginate,omitempty" yaml:"paginate,omitempty" mapstructure:"paginate,omitempty"`
}

type GroupComparisonTarget 

type GroupComparisonTarget struct {
	// contains filtered or unexported fields
}

GroupComparisonTarget represents an aggregate comparison target.

func NewGroupComparisonTarget 

func NewGroupComparisonTarget[T GroupComparisonTargetInner](inner T) GroupComparisonTarget

NewGroupComparisonTarget creates a new GroupComparisonTarget instance.

func (GroupComparisonTarget) Interface 

func (j GroupComparisonTarget) Interface() GroupComparisonTargetInner

Interface converts the comparison value to its generic interface.

func (GroupComparisonTarget) IsEmpty 

func (j GroupComparisonTarget) IsEmpty() bool

IsEmpty checks if the inner type is empty.

func (GroupComparisonTarget) MarshalJSON 

func (j GroupComparisonTarget) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler interface.

func (GroupComparisonTarget) Type 

func (j GroupComparisonTarget) Type() GroupComparisonTargetType

Type gets the type enum of the current type.

func (*GroupComparisonTarget) UnmarshalJSON 

func (j *GroupComparisonTarget) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type GroupComparisonTargetAggregate 

type GroupComparisonTargetAggregate struct {
	// Aggregation method to apply.
	Aggregate Aggregate `json:"aggregate" mapstructure:"aggregate" yaml:"aggregate"`
}

GroupComparisonTargetAggregate represents an aggregate object of GroupComparisonTarget.

func NewGroupComparisonTargetAggregate 

func NewGroupComparisonTargetAggregate(aggregate AggregateEncoder) *GroupComparisonTargetAggregate

NewGroupComparisonTargetAggregate creates a GroupComparisonTargetAggregate instance.

func (GroupComparisonTargetAggregate) ToMap 

func (ob GroupComparisonTargetAggregate) ToMap() map[string]any

ToMap converts the instance to raw map.

func (GroupComparisonTargetAggregate) Type 

func (ob GroupComparisonTargetAggregate) Type() GroupComparisonTargetType

Type return the type name of the instance.

func (GroupComparisonTargetAggregate) Wrap 

func (ob GroupComparisonTargetAggregate) Wrap() GroupComparisonTarget

Encode converts the instance to a raw GroupComparisonTarget.

type GroupComparisonTargetInner 

type GroupComparisonTargetInner interface {
	Type() GroupComparisonTargetType
	ToMap() map[string]any
	Wrap() GroupComparisonTarget
}

GroupComparisonTargetInner abstracts a generic interface of GroupComparisonTarget.

type GroupComparisonTargetType 

type GroupComparisonTargetType string

GroupComparisonTargetType represents a type of GroupComparisonTarget. 

const (
	GroupComparisonTargetTypeAggregate GroupComparisonTargetType = "aggregate"
)

func ParseGroupComparisonTargetType 

func ParseGroupComparisonTargetType(input string) (GroupComparisonTargetType, error)

ParseGroupComparisonTargetType parses a field type from string.

func (GroupComparisonTargetType) IsValid 

func (j GroupComparisonTargetType) IsValid() bool

IsValid checks if the value is invalid.

func (*GroupComparisonTargetType) UnmarshalJSON 

func (j *GroupComparisonTargetType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type GroupComparisonValue 

type GroupComparisonValue struct {
	// contains filtered or unexported fields
}

GroupComparisonValue represents a group comparison value.

func NewGroupComparisonValue 

func NewGroupComparisonValue[T GroupComparisonValueInner](inner T) GroupComparisonValue

NewGroupComparisonValue creates a new GroupComparisonValue instance.

func (GroupComparisonValue) Interface 

func (cv GroupComparisonValue) Interface() GroupComparisonValueInner

Interface converts the comparison value to its generic interface.

func (GroupComparisonValue) IsEmpty 

func (j GroupComparisonValue) IsEmpty() bool

IsEmpty checks if the inner type is empty.

func (GroupComparisonValue) MarshalJSON 

func (j GroupComparisonValue) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler interface.

func (GroupComparisonValue) Type 

func (j GroupComparisonValue) Type() GroupComparisonValueType

Type gets the type enum of the current type.

func (*GroupComparisonValue) UnmarshalJSON 

func (j *GroupComparisonValue) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type GroupComparisonValueInner 

type GroupComparisonValueInner interface {
	Type() GroupComparisonValueType
	ToMap() map[string]any
	Wrap() GroupComparisonValue
}

GroupComparisonValueInner represents a group comparison value Inner interface.

type GroupComparisonValueScalar 

type GroupComparisonValueScalar struct {
	Value any `json:"value" mapstructure:"value" yaml:"value"`
}

GroupComparisonValueScalar represents a group comparison value with scalar type.

func NewGroupComparisonValueScalar 

func NewGroupComparisonValueScalar(value any) *GroupComparisonValueScalar

NewGroupComparisonValueScalar creates a new GroupComparisonValueScalar instance.

func (GroupComparisonValueScalar) ToMap 

func (cv GroupComparisonValueScalar) ToMap() map[string]any

ToMap converts the instance to raw map.

func (GroupComparisonValueScalar) Type 

func (cv GroupComparisonValueScalar) Type() GroupComparisonValueType

Type return the type name of the instance.

func (GroupComparisonValueScalar) Wrap 

func (cv GroupComparisonValueScalar) Wrap() GroupComparisonValue

Encode converts to the raw comparison value.

type GroupComparisonValueType 

type GroupComparisonValueType string

GroupComparisonValueType represents a group comparison value type enum. 

const (
	GroupComparisonValueTypeScalar   GroupComparisonValueType = "scalar"
	GroupComparisonValueTypeVariable GroupComparisonValueType = "variable"
)

func ParseGroupComparisonValueType 

func ParseGroupComparisonValueType(input string) (GroupComparisonValueType, error)

ParseGroupComparisonValueType parses a group comparison value type from string.

func (GroupComparisonValueType) IsValid 

func (j GroupComparisonValueType) IsValid() bool

IsValid checks if the value is invalid.

func (*GroupComparisonValueType) UnmarshalJSON 

func (j *GroupComparisonValueType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type GroupComparisonValueVariable 

type GroupComparisonValueVariable struct {
	Name string `json:"name" mapstructure:"name" yaml:"name"`
}

GroupComparisonValueVariable represents a group comparison value with variable type.

func NewGroupComparisonValueVariable 

func NewGroupComparisonValueVariable(name string) *GroupComparisonValueVariable

NewGroupComparisonValueVariable creates a new GroupComparisonValueVariable instance.

func (GroupComparisonValueVariable) ToMap 

func (cv GroupComparisonValueVariable) ToMap() map[string]any

ToMap converts the instance to raw map.

func (GroupComparisonValueVariable) Type 

func (cv GroupComparisonValueVariable) Type() GroupComparisonValueType

Type return the type name of the instance.

func (GroupComparisonValueVariable) Wrap 

func (cv GroupComparisonValueVariable) Wrap() GroupComparisonValue

Encode converts to the raw comparison value.

type GroupExpression 

type GroupExpression struct {
	// contains filtered or unexported fields
}

GroupExpression represents a group expression.

func NewGroupExpression 

func NewGroupExpression[T GroupExpressionInner](inner T) GroupExpression

NewGroupExpression creates a new GroupExpression instance.

func (GroupExpression) Equal 

func (j GroupExpression) Equal(value GroupExpression) bool

Equal checks whether instances are the same.

func (GroupExpression) Interface 

func (j GroupExpression) Interface() GroupExpressionInner

Interface tries to convert the instance to the GroupExpressionInner interface.

func (GroupExpression) IsEmpty 

func (j GroupExpression) IsEmpty() bool

IsEmpty checks if the inner type is empty.

func (GroupExpression) MarshalJSON 

func (j GroupExpression) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler interface.

func (GroupExpression) Type 

func (j GroupExpression) Type() GroupExpressionType

Type gets the type enum of the current type.

func (*GroupExpression) UnmarshalJSON 

func (j *GroupExpression) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type GroupExpressionAnd 

type GroupExpressionAnd struct {
	Expressions []GroupExpression `json:"expressions" mapstructure:"expressions" yaml:"expressions"`
}

GroupExpressionAnd is an object which represents the conjunction of expressions

func NewGroupExpressionAnd 

func NewGroupExpressionAnd(expressions ...GroupExpressionInner) *GroupExpressionAnd

NewGroupExpressionAnd creates a GroupExpressionAnd instance.

func (GroupExpressionAnd) ToMap 

func (exp GroupExpressionAnd) ToMap() map[string]any

ToMap converts the instance to raw map.

func (GroupExpressionAnd) Type 

func (exp GroupExpressionAnd) Type() GroupExpressionType

Type return the type name of the instance.

func (GroupExpressionAnd) Wrap 

func (exp GroupExpressionAnd) Wrap() GroupExpression

Encode converts the instance to a raw GroupExpression.

type GroupExpressionBinaryComparisonOperator 

type GroupExpressionBinaryComparisonOperator struct {
	Operator string                `json:"operator" mapstructure:"operator" yaml:"operator"`
	Target   GroupComparisonTarget `json:"target"   mapstructure:"target"   yaml:"target"`
	Value    GroupComparisonValue  `json:"value"    mapstructure:"value"    yaml:"value"`
}

GroupExpressionBinaryComparisonOperator is an object which represents an binary operator expression

func NewGroupExpressionBinaryComparisonOperator 

func NewGroupExpressionBinaryComparisonOperator[T GroupComparisonTargetInner, V GroupComparisonValueInner](
	target T,
	operator string,
	value V,
) *GroupExpressionBinaryComparisonOperator

NewGroupExpressionBinaryComparisonOperator creates a GroupExpressionBinaryComparisonOperator instance.

func (GroupExpressionBinaryComparisonOperator) ToMap 

func (exp GroupExpressionBinaryComparisonOperator) ToMap() map[string]any

ToMap converts the instance to raw map.

func (GroupExpressionBinaryComparisonOperator) Type 

func (exp GroupExpressionBinaryComparisonOperator) Type() GroupExpressionType

Type return the type name of the instance.

func (GroupExpressionBinaryComparisonOperator) Wrap 

func (exp GroupExpressionBinaryComparisonOperator) Wrap() GroupExpression

Encode converts the instance to a raw GroupExpression.

type GroupExpressionInner 

type GroupExpressionInner interface {
	Type() GroupExpressionType
	ToMap() map[string]any
	Wrap() GroupExpression
}

GroupExpressionInner abstracts the expression Inner interface.

type GroupExpressionNot 

type GroupExpressionNot struct {
	Expression GroupExpression `json:"expression" mapstructure:"expression" yaml:"expression"`
}

GroupExpressionNot is an object which represents the negation of an expression

func NewGroupExpressionNot 

func NewGroupExpressionNot[E GroupExpressionInner](expression E) *GroupExpressionNot

NewGroupExpressionNot creates a GroupExpressionNot instance.

func (GroupExpressionNot) ToMap 

func (exp GroupExpressionNot) ToMap() map[string]any

ToMap converts the instance to raw map.

func (GroupExpressionNot) Type 

func (exp GroupExpressionNot) Type() GroupExpressionType

Type return the type name of the instance.

func (GroupExpressionNot) Wrap 

func (exp GroupExpressionNot) Wrap() GroupExpression

Encode converts the instance to a raw Expression.

type GroupExpressionOr 

type GroupExpressionOr struct {
	Expressions []GroupExpression `json:"expressions" mapstructure:"expressions" yaml:"expressions"`
}

GroupExpressionOr is an object which represents the disjunction of expressions

func NewGroupExpressionOr 

func NewGroupExpressionOr(expressions ...GroupExpressionInner) *GroupExpressionOr

NewGroupExpressionOr creates a GroupExpressionOr instance.

func (GroupExpressionOr) ToMap 

func (exp GroupExpressionOr) ToMap() map[string]any

ToMap converts the instance to raw map.

func (GroupExpressionOr) Type 

func (exp GroupExpressionOr) Type() GroupExpressionType

Type return the type name of the instance.

func (GroupExpressionOr) Wrap 

func (exp GroupExpressionOr) Wrap() GroupExpression

Encode converts the instance to a raw Expression.

type GroupExpressionType 

type GroupExpressionType string

GroupExpressionType represents the group expression filter enums. 

const (
	GroupExpressionTypeAnd                      GroupExpressionType = "and"
	GroupExpressionTypeOr                       GroupExpressionType = "or"
	GroupExpressionTypeNot                      GroupExpressionType = "not"
	GroupExpressionTypeUnaryComparisonOperator  GroupExpressionType = "unary_comparison_operator"
	GroupExpressionTypeBinaryComparisonOperator GroupExpressionType = "binary_comparison_operator"
)

func ParseGroupExpressionType 

func ParseGroupExpressionType(input string) (GroupExpressionType, error)

ParseGroupExpressionType parses an expression type argument type from string.

func (GroupExpressionType) IsValid 

func (j GroupExpressionType) IsValid() bool

IsValid checks if the value is invalid.

func (*GroupExpressionType) UnmarshalJSON 

func (j *GroupExpressionType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type GroupExpressionUnaryComparisonOperator 

type GroupExpressionUnaryComparisonOperator struct {
	Operator UnaryComparisonOperator `json:"operator" mapstructure:"operator" yaml:"operator"`
	Target   GroupComparisonTarget   `json:"target"   mapstructure:"target"   yaml:"target"`
}

GroupExpressionUnaryComparisonOperator is an object which represents a unary operator expression

func NewGroupExpressionUnaryComparisonOperator 

func NewGroupExpressionUnaryComparisonOperator[T GroupComparisonTargetInner](
	target T,
	operator UnaryComparisonOperator,
) *GroupExpressionUnaryComparisonOperator

NewGroupExpressionUnaryComparisonOperator creates a GroupExpressionUnaryComparisonOperator instance.

func (GroupExpressionUnaryComparisonOperator) ToMap 

func (exp GroupExpressionUnaryComparisonOperator) ToMap() map[string]any

ToMap converts the instance to raw map.

func (GroupExpressionUnaryComparisonOperator) Type 

func (exp GroupExpressionUnaryComparisonOperator) Type() GroupExpressionType

Type return the type name of the instance.

func (GroupExpressionUnaryComparisonOperator) Wrap 

func (exp GroupExpressionUnaryComparisonOperator) Wrap() GroupExpression

Encode converts the instance to a raw Expression.

type GroupOrderBy 

type GroupOrderBy struct {
	// The elements to order by, in priority order
	Elements []GroupOrderByElement `json:"elements" yaml:"elements" mapstructure:"elements"`
}

func (*GroupOrderBy) UnmarshalJSON 

func (j *GroupOrderBy) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type GroupOrderByElement 

type GroupOrderByElement struct {
	// OrderDirection corresponds to the JSON schema field "order_direction".
	OrderDirection OrderDirection `json:"order_direction" yaml:"order_direction" mapstructure:"order_direction"`

	// Target corresponds to the JSON schema field "target".
	Target GroupOrderByTarget `json:"target" yaml:"target" mapstructure:"target"`
}

func (*GroupOrderByElement) UnmarshalJSON 

func (j *GroupOrderByElement) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type GroupOrderByTarget 

type GroupOrderByTarget struct {
	// contains filtered or unexported fields
}

GroupOrderByTarget groups order by target.

func NewGroupOrderByTarget 

func NewGroupOrderByTarget[T GroupOrderByTargetInner](inner T) GroupOrderByTarget

NewGroupOrderByTarget creates a new GroupOrderByTarget instance.

func (GroupOrderByTarget) Interface 

func (j GroupOrderByTarget) Interface() GroupOrderByTargetInner

Interface returns the inner interface.

func (GroupOrderByTarget) IsEmpty 

func (j GroupOrderByTarget) IsEmpty() bool

IsEmpty checks if the inner type is empty.

func (GroupOrderByTarget) MarshalJSON 

func (j GroupOrderByTarget) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler interface.

func (GroupOrderByTarget) Type 

func (j GroupOrderByTarget) Type() GroupOrderByTargetType

Type gets the type enum of the current type.

func (*GroupOrderByTarget) UnmarshalJSON 

func (j *GroupOrderByTarget) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type GroupOrderByTargetAggregate 

type GroupOrderByTargetAggregate struct {
	// Aggregation method to apply.
	Aggregate Aggregate `json:"aggregate" mapstructure:"aggregate" yaml:"aggregate"`
}

GroupOrderByTargetAggregate represents an aggregate object of GroupOrderByTarget.

func NewGroupOrderByTargetAggregate 

func NewGroupOrderByTargetAggregate(aggregate AggregateEncoder) *GroupOrderByTargetAggregate

NewGroupOrderByTargetAggregate creates a GroupOrderByTargetAggregate instance.

func (GroupOrderByTargetAggregate) ToMap 

func (ob GroupOrderByTargetAggregate) ToMap() map[string]any

ToMap converts the instance to raw map.

func (GroupOrderByTargetAggregate) Type 

func (ob GroupOrderByTargetAggregate) Type() GroupOrderByTargetType

Type return the type name of the instance.

func (GroupOrderByTargetAggregate) Wrap 

func (ob GroupOrderByTargetAggregate) Wrap() GroupOrderByTarget

Encode converts the instance to raw GroupOrderByTarget.

type GroupOrderByTargetDimension 

type GroupOrderByTargetDimension struct {
	// The index of the dimension to order by, selected from the dimensions provided in the `Grouping` request.
	Index uint `json:"index" mapstructure:"index" yaml:"index"`
}

GroupOrderByTargetDimension represents a dimension object of GroupOrderByTarget.

func NewGroupOrderByTargetDimension 

func NewGroupOrderByTargetDimension(index uint) *GroupOrderByTargetDimension

NewGroupOrderByTargetDimension creates a GroupOrderByTargetDimension instance.

func (GroupOrderByTargetDimension) ToMap 

func (ob GroupOrderByTargetDimension) ToMap() map[string]any

ToMap converts the instance to raw map.

func (GroupOrderByTargetDimension) Type 

func (ob GroupOrderByTargetDimension) Type() GroupOrderByTargetType

Type return the type name of the instance.

func (GroupOrderByTargetDimension) Wrap 

func (ob GroupOrderByTargetDimension) Wrap() GroupOrderByTarget

Encode converts the instance to raw OrderByTarget.

type GroupOrderByTargetInner 

type GroupOrderByTargetInner interface {
	Type() GroupOrderByTargetType
	ToMap() map[string]any
	Wrap() GroupOrderByTarget
}

GroupOrderByTargetInner abstracts a generic interface of GroupOrderByTarget.

type GroupOrderByTargetType 

type GroupOrderByTargetType string

GroupOrderByTargetType represents a type of GroupOrderByTarget. 

const (
	GroupOrderByTargetTypeDimension GroupOrderByTargetType = "dimension"
	GroupOrderByTargetTypeAggregate GroupOrderByTargetType = "aggregate"
)

func ParseGroupOrderByTargetType 

func ParseGroupOrderByTargetType(input string) (GroupOrderByTargetType, error)

ParseGroupOrderByTargetType parses a field type from string.

func (GroupOrderByTargetType) IsValid 

func (j GroupOrderByTargetType) IsValid() bool

IsValid checks if the value is invalid.

func (*GroupOrderByTargetType) UnmarshalJSON 

func (j *GroupOrderByTargetType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type Grouping 

type Grouping struct {
	// Aggregates to compute in each group
	Aggregates GroupingAggregates `json:"aggregates" yaml:"aggregates" mapstructure:"aggregates"`

	// Dimensions along which to partition the data
	Dimensions []Dimension `json:"dimensions" yaml:"dimensions" mapstructure:"dimensions"`

	// Optionally limit to N groups Only used if the
	// 'query.aggregates.group_by.paginate' capability is supported.
	Limit *int `json:"limit,omitempty" yaml:"limit,omitempty" mapstructure:"limit,omitempty"`

	// Optionally offset from the Nth group Only used if the
	// 'query.aggregates.group_by.paginate' capability is supported.
	Offset *int `json:"offset,omitempty" yaml:"offset,omitempty" mapstructure:"offset,omitempty"`

	// Optionally specify how groups should be ordered Only used if the
	// 'query.aggregates.group_by.order' capability is supported.
	OrderBy *GroupOrderBy `json:"order_by" yaml:"order_by" mapstructure:"order_by"`

	// Optionally specify a predicate to apply after grouping rows. Only used if the
	// 'query.aggregates.group_by.filter' capability is supported.
	Predicate *GroupExpression `json:"predicate,omitempty" yaml:"predicate,omitempty" mapstructure:"predicate,omitempty"`
}

func (*Grouping) UnmarshalJSON 

func (j *Grouping) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type GroupingAggregates 

type GroupingAggregates map[string]Aggregate

Aggregates to compute in each group

type JoinOn 

type JoinOn struct {
	// Left corresponds to the JSON schema field "left".
	Left RelationalExpression `json:"left" yaml:"left" mapstructure:"left"`

	// Right corresponds to the JSON schema field "right".
	Right RelationalExpression `json:"right" yaml:"right" mapstructure:"right"`
}

func (*JoinOn) UnmarshalJSON 

func (j *JoinOn) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type JoinType 

type JoinType string

JoinType represents a join type. 

const (
	// Left join. Only used when the capability `relational_query.join.join_types.left` is supported.
	LeftJoin JoinType = "left"
	// Right join. Only used when the capability `relational_query.join.join_types.right` is supported.
	RightJoin JoinType = "right"
	// Inner join. Only used when the capability `relational_query.join.join_types.inner` is supported.
	InnerJoin JoinType = "inner"
	// Full join. Only used when the capability `relational_query.join.join_types.full` is supported.
	FullJoin JoinType = "full"
	// Left anti join. Only used when the capability `relational_query.join.join_types.left_anti` is supported.
	LeftAntiJoin JoinType = "left_anti"
	// Left semi join. Only used when the capability `relational_query.join.join_types.left_semi` is supported.
	LeftSemiJoin JoinType = "left_semi"
	// Right anti join. Only used when the capability `relational_query.join.join_types.right_anti` is supported.
	RightAntiJoin JoinType = "right_anti"
	// Right semi join. Only used when the capability `relational_query.join.join_types.right_semi` is supported.
	RightSemiJoin JoinType = "right_semi"
)

func ParseJoinType 

func ParseJoinType(input string) (JoinType, error)

ParseJoinType parses a join type from string.

func (JoinType) IsValid 

func (j JoinType) IsValid() bool

IsValid checks if the value is invalid.

func (*JoinType) UnmarshalJSON 

func (j *JoinType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type LeafCapability 

type LeafCapability struct {
}

A unit value to indicate a particular leaf capability is supported. This is an empty struct to allow for future sub-capabilities.

type MutationCapabilities 

type MutationCapabilities struct {
	// Does the connector support explaining mutations
	Explain *LeafCapability `json:"explain,omitempty" yaml:"explain,omitempty" mapstructure:"explain,omitempty"`

	// Does the connector support executing multiple mutations in a transaction.
	Transactional *LeafCapability `json:"transactional,omitempty" yaml:"transactional,omitempty" mapstructure:"transactional,omitempty"`
}

type MutationOperation 

type MutationOperation struct {
	Type MutationOperationType `json:"type"             mapstructure:"type"      yaml:"type"`
	// The name of the operation
	Name string `json:"name"             mapstructure:"name"      yaml:"name"`
	// Any named procedure arguments
	Arguments json.RawMessage `json:"arguments"        mapstructure:"arguments" yaml:"arguments"`
	// The fields to return from the result, or null to return everything
	Fields NestedField `json:"fields,omitempty" mapstructure:"fields"    yaml:"fields,omitempty"`
}

MutationOperation represents a mutation operation.

func (*MutationOperation) UnmarshalJSON 

func (j *MutationOperation) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type MutationOperationResults 

type MutationOperationResults map[string]any

MutationOperationResults represent the result of mutation operation.

func (MutationOperationResults) AsProcedure 

func (j MutationOperationResults) AsProcedure() (*ProcedureResult, error)

AsProcedure tries to convert the instance to ProcedureResult type.

func (MutationOperationResults) Interface 

func (j MutationOperationResults) Interface() MutationOperationResultsEncoder

Interface tries to convert the instance to MutationOperationResultsEncoder interface.

func (MutationOperationResults) InterfaceT 

func (j MutationOperationResults) InterfaceT() (MutationOperationResultsEncoder, error)

InterfaceT tries to convert the instance to MutationOperationResultsEncoder interface safely with explicit error.

func (MutationOperationResults) Type 

func (j MutationOperationResults) Type() (MutationOperationType, error)

Type gets the type enum of the current type.

func (*MutationOperationResults) UnmarshalJSON 

func (j *MutationOperationResults) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type MutationOperationResultsEncoder 

type MutationOperationResultsEncoder interface {
	Type() MutationOperationType
	Encode() MutationOperationResults
}

MutationOperationResultsEncoder abstracts the serialization interface for MutationOperationResults.

type MutationOperationType 

type MutationOperationType string

MutationOperationType represents the mutation operation type enum. 

const (
	MutationOperationProcedure MutationOperationType = "procedure"
)

func ParseMutationOperationType 

func ParseMutationOperationType(input string) (*MutationOperationType, error)

ParseMutationOperationType parses a mutation operation type argument type from string.

func (*MutationOperationType) UnmarshalJSON 

func (j *MutationOperationType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type MutationRequest 

type MutationRequest struct {
	// The relationships between collections involved in the entire mutation request.
	// Only used if the 'relationships' capability is supported.
	CollectionRelationships MutationRequestCollectionRelationships `json:"collection_relationships" yaml:"collection_relationships" mapstructure:"collection_relationships"`

	// The mutation operations to perform
	Operations []MutationOperation `json:"operations" yaml:"operations" mapstructure:"operations"`

	// Values to be provided to request-level arguments.
	RequestArguments MutationRequestRequestArguments `json:"request_arguments,omitempty" yaml:"request_arguments,omitempty" mapstructure:"request_arguments,omitempty"`
}

func (*MutationRequest) UnmarshalJSON 

func (j *MutationRequest) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type MutationRequestCollectionRelationships 

type MutationRequestCollectionRelationships map[string]Relationship

The relationships between collections involved in the entire mutation request. Only used if the 'relationships' capability is supported.

type MutationRequestRequestArguments 

type MutationRequestRequestArguments map[string]interface{}

Values to be provided to request-level arguments.

type MutationResponse 

type MutationResponse struct {
	// The results of each mutation operation, in the same order as they were received
	OperationResults []MutationOperationResults `json:"operation_results" yaml:"operation_results" mapstructure:"operation_results"`
}

func (*MutationResponse) UnmarshalJSON 

func (j *MutationResponse) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type NamedType 

type NamedType struct {
	// The name can refer to a primitive type or a scalar type
	Name string `json:"name" mapstructure:"name" yaml:"name"`
}

NamedType represents a named type.

func GetUnderlyingNamedType 

func GetUnderlyingNamedType(input Type) *NamedType

GetUnderlyingNamedType gets the underlying named type of the input type recursively if exists.

func NewNamedType 

func NewNamedType(name string) *NamedType

NewNamedType creates a new NamedType instance.

func (NamedType) Encode 

func (ty NamedType) Encode() Type

Encode returns the raw Type instance.

func (NamedType) String 

func (ty NamedType) String() string

String implements the fmt.Stringer interface.

func (NamedType) Type 

func (ty NamedType) Type() TypeEnum

Type return the type name of the instance.

type NestedArray 

type NestedArray struct {
	Fields NestedField `json:"fields" mapstructure:"fields" yaml:"fields"`
}

NestedArray presents a nested array field.

func NewNestedArray 

func NewNestedArray[T NestedFieldEncoder](fields T) *NestedArray

NewNestedArray create a new NestedArray instance.

func (NestedArray) Encode 

func (ob NestedArray) Encode() NestedField

Encode converts the instance to raw NestedField.

func (NestedArray) Type 

func (ob NestedArray) Type() NestedFieldType

Type return the type name of the instance.

type NestedArrayFilterByCapabilities 

type NestedArrayFilterByCapabilities struct {
	// Does the connector support filtering over nested arrays by checking if the
	// array contains a value. This must be supported for all types that can be
	// contained in an array that implement an 'eq' comparison operator.
	Contains *LeafCapability `json:"contains,omitempty" yaml:"contains,omitempty" mapstructure:"contains,omitempty"`

	// Does the connector support filtering over nested arrays by checking if the
	// array is empty. This must be supported no matter what type is contained in the
	// array.
	IsEmpty *LeafCapability `json:"is_empty,omitempty" yaml:"is_empty,omitempty" mapstructure:"is_empty,omitempty"`
}

type NestedCollection 

type NestedCollection struct {
	Query Query `json:"query" mapstructure:"query" yaml:"query"`
}

NestedCollection presents a nested collection field.

func NewNestedCollection 

func NewNestedCollection(query Query) *NestedCollection

NewNestedCollection create a new NestedCollection instance.

func (NestedCollection) Encode 

func (ob NestedCollection) Encode() NestedField

Encode converts the instance to raw NestedField.

func (NestedCollection) Type 

func (ob NestedCollection) Type() NestedFieldType

Type return the type name of the instance.

type NestedField 

type NestedField map[string]any

NestedField represents a nested field.

func (NestedField) AsArray 

func (j NestedField) AsArray() (*NestedArray, error)

AsArray tries to convert the instance to NestedArray type.

func (NestedField) AsCollection 

func (j NestedField) AsCollection() (*NestedCollection, error)

AsCollection tries to convert the instance to NestedCollection type.

func (NestedField) AsObject 

func (j NestedField) AsObject() (*NestedObject, error)

AsObject tries to convert the instance to NestedObject type.

func (NestedField) Interface 

func (j NestedField) Interface() NestedFieldEncoder

Interface tries to convert the instance to NestedFieldEncoder interface.

func (NestedField) InterfaceT 

func (j NestedField) InterfaceT() (NestedFieldEncoder, error)

Interface tries to convert the instance to NestedFieldEncoder interface safely with explicit error.

func (NestedField) IsNil 

func (j NestedField) IsNil() bool

IsNil checks if the field is null or empty.

func (NestedField) Type 

func (j NestedField) Type() (NestedFieldType, error)

Type gets the type enum of the current type.

func (*NestedField) UnmarshalJSON 

func (j *NestedField) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type NestedFieldCapabilities 

type NestedFieldCapabilities struct {
	// Does the connector support aggregating values within nested fields
	Aggregates *LeafCapability `json:"aggregates,omitempty" yaml:"aggregates,omitempty" mapstructure:"aggregates,omitempty"`

	// Does the connector support filtering by values of nested fields
	FilterBy *NestedFieldFilterByCapabilities `json:"filter_by,omitempty" yaml:"filter_by,omitempty" mapstructure:"filter_by,omitempty"`

	// Does the connector support nested collection queries using
	// `NestedField::NestedCollection`
	NestedCollections *LeafCapability `json:"nested_collections,omitempty" yaml:"nested_collections,omitempty" mapstructure:"nested_collections,omitempty"`

	// Does the connector support ordering by values of nested fields
	OrderBy *LeafCapability `json:"order_by" yaml:"order_by" mapstructure:"order_by"`
}

type NestedFieldEncoder 

type NestedFieldEncoder interface {
	Type() NestedFieldType
	Encode() NestedField
}

NestedFieldEncoder abstracts the serialization interface for NestedField.

type NestedFieldFilterByCapabilities 

type NestedFieldFilterByCapabilities struct {
	// Does the connector support filtering over nested arrays (ie.
	// Expression::ArrayComparison)
	NestedArrays *NestedArrayFilterByCapabilities `json:"nested_arrays,omitempty" yaml:"nested_arrays,omitempty" mapstructure:"nested_arrays,omitempty"`
}

type NestedFieldType 

type NestedFieldType string

NestedFieldType represents a nested field type enum. 

const (
	NestedFieldTypeObject     NestedFieldType = "object"
	NestedFieldTypeArray      NestedFieldType = "array"
	NestedFieldTypeCollection NestedFieldType = "collection"
)

func ParseNestedFieldType 

func ParseNestedFieldType(input string) (NestedFieldType, error)

ParseNestedFieldType parses the type of nested field.

func (NestedFieldType) IsValid 

func (j NestedFieldType) IsValid() bool

IsValid checks if the value is invalid.

func (*NestedFieldType) UnmarshalJSON 

func (j *NestedFieldType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type NestedObject 

type NestedObject struct {
	Fields map[string]Field `json:"fields" mapstructure:"fields" yaml:"fields"`
}

NestedObject presents a nested object field.

func NewNestedObject 

func NewNestedObject(fields map[string]FieldEncoder) *NestedObject

NewNestedObject create a new NestedObject instance.

func (NestedObject) Encode 

func (ob NestedObject) Encode() NestedField

Encode converts the instance to raw NestedField.

func (NestedObject) Type 

func (ob NestedObject) Type() NestedFieldType

Type return the type name of the instance.

type NestedRelationshipCapabilities 

type NestedRelationshipCapabilities struct {
	// Does the connector support navigating a relationship from inside a nested
	// object inside a nested array
	Array *LeafCapability `json:"array,omitempty" yaml:"array,omitempty" mapstructure:"array,omitempty"`

	// Does the connector support filtering over a relationship that starts from
	// inside a nested object
	Filtering *LeafCapability `json:"filtering,omitempty" yaml:"filtering,omitempty" mapstructure:"filtering,omitempty"`

	// Does the connector support ordering over a relationship that starts from inside
	// a nested object
	Ordering *LeafCapability `json:"ordering,omitempty" yaml:"ordering,omitempty" mapstructure:"ordering,omitempty"`
}

type NullableType 

type NullableType struct {
	// The type of the non-null inhabitants of this type
	UnderlyingType Type `json:"underlying_type" mapstructure:"underlying_type" yaml:"underlying_type"`
}

NullableType represents a nullable type.

func NewNullableNamedType 

func NewNullableNamedType(name string) *NullableType

NewNullableNamedType creates a new NullableType instance with underlying named type.

func NewNullableType 

func NewNullableType[T TypeEncoder](underlyingType T) *NullableType

NewNullableType creates a new NullableType instance with underlying type.

func (NullableType) Encode 

func (ty NullableType) Encode() Type

Encode returns the raw Type instance.

func (NullableType) String 

func (ty NullableType) String() string

String implements the fmt.Stringer interface.

func (NullableType) Type 

func (ty NullableType) Type() TypeEnum

Type return the type name of the instance.

type NullsSort 

type NullsSort string
const NullsSortNullsFirst NullsSort = "nulls_first"
const NullsSortNullsLast NullsSort = "nulls_last"

func (*NullsSort) UnmarshalJSON 

func (j *NullsSort) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ObjectField 

type ObjectField struct {
	// The arguments available to the field - Matches implementation from
	// CollectionInfo
	Arguments ObjectFieldArguments `json:"arguments,omitempty" yaml:"arguments,omitempty" mapstructure:"arguments,omitempty"`

	// Description of this field
	Description *string `json:"description,omitempty" yaml:"description,omitempty" mapstructure:"description,omitempty"`

	// The type of this field
	Type Type `json:"type" yaml:"type" mapstructure:"type"`
}

The definition of an object field

func (*ObjectField) UnmarshalJSON 

func (j *ObjectField) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ObjectFieldArguments 

type ObjectFieldArguments map[string]ArgumentInfo

The arguments available to the field - Matches implementation from CollectionInfo

type ObjectType 

type ObjectType struct {
	// Description of this type
	Description *string `json:"description,omitempty" yaml:"description,omitempty" mapstructure:"description,omitempty"`

	// Fields defined on this object type
	Fields ObjectTypeFields `json:"fields" yaml:"fields" mapstructure:"fields"`

	// Any foreign keys defined for this object type's columns
	ForeignKeys ObjectTypeForeignKeys `json:"foreign_keys" yaml:"foreign_keys" mapstructure:"foreign_keys"`
}

The definition of an object type

func NewObjectType 

func NewObjectType(
	fields ObjectTypeFields,
	foreignKeys ObjectTypeForeignKeys,
	description *string,
) ObjectType

NewObjectType creates a new object type.

func (ObjectType) MarshalJSON 

func (j ObjectType) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler.

func (*ObjectType) UnmarshalJSON 

func (j *ObjectType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ObjectTypeFields 

type ObjectTypeFields map[string]ObjectField

Fields defined on this object type

type ObjectTypeForeignKeys 

type ObjectTypeForeignKeys map[string]ForeignKeyConstraint

Any foreign keys defined for this object type's columns

type OrderBy 

type OrderBy struct {
	// The elements to order by, in priority order
	Elements []OrderByElement `json:"elements" yaml:"elements" mapstructure:"elements"`
}

func (*OrderBy) UnmarshalJSON 

func (j *OrderBy) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type OrderByAggregate 

type OrderByAggregate struct {
	// The aggregation method to use.
	Aggregate Aggregate `json:"aggregate" mapstructure:"aggregate" yaml:"aggregate"`
	// Non-empty collection of relationships to traverse. Only non-empty if the 'relationships' capability is supported.
	// 'PathElement.field_path' will only be non-empty if the 'relationships.nested.ordering' capability is supported.
	Path []PathElement `json:"path"      mapstructure:"path"      yaml:"path"`
}

OrderByAggregate The ordering is performed over the result of an aggregation. Only used if the 'relationships.order_by_aggregate' capability is supported.

func NewOrderByAggregate 

func NewOrderByAggregate[A AggregateEncoder](aggregate A, path []PathElement) *OrderByAggregate

NewOrderByAggregate creates an OrderByAggregate instance.

func (OrderByAggregate) ToMap 

func (ob OrderByAggregate) ToMap() map[string]any

ToMap converts the instance to raw map.

func (OrderByAggregate) Type 

func (ob OrderByAggregate) Type() OrderByTargetType

Type return the type name of the instance.

func (OrderByAggregate) Wrap 

func (ob OrderByAggregate) Wrap() OrderByTarget

Encode returns the relation wrapper.

type OrderByColumn 

type OrderByColumn struct {
	// The name of the column
	Name string `json:"name"                 mapstructure:"name"       yaml:"name"`
	// Any relationships to traverse to reach this column
	Path []PathElement `json:"path"                 mapstructure:"path"       yaml:"path"`
	// Any field path to a nested field within the column
	FieldPath []string `json:"field_path,omitempty" mapstructure:"field_path" yaml:"field_path,omitempty"`
	// Arguments to satisfy the column specified by 'name'
	Arguments map[string]Argument `json:"arguments,omitempty"  mapstructure:"arguments"  yaml:"arguments,omitempty"`
}

OrderByColumn represents an ordering object which compares the value in the selected column.

func NewOrderByColumn 

func NewOrderByColumn(name string, path []PathElement) *OrderByColumn

NewOrderByColumn creates an OrderByColumn instance.

func (OrderByColumn) ToMap 

func (ob OrderByColumn) ToMap() map[string]any

ToMap converts the instance to raw map.

func (OrderByColumn) Type 

func (ob OrderByColumn) Type() OrderByTargetType

Type return the type name of the instance.

func (OrderByColumn) WithArgument 

func (f OrderByColumn) WithArgument(
	key string,
	argument ArgumentEncoder,
) *OrderByColumn

WithArgument return a new instance with an arguments set.

func (OrderByColumn) WithArguments 

func (f OrderByColumn) WithArguments(
	arguments map[string]ArgumentEncoder,
) *OrderByColumn

WithArguments return a new instance with arguments set.

func (OrderByColumn) WithFieldPath 

func (f OrderByColumn) WithFieldPath(fieldPath []string) *OrderByColumn

WithFieldPath returns a new instance with field_path set.

func (OrderByColumn) Wrap 

func (ob OrderByColumn) Wrap() OrderByTarget

Encode returns the relation wrapper.

type OrderByElement 

type OrderByElement struct {
	// OrderDirection corresponds to the JSON schema field "order_direction".
	OrderDirection OrderDirection `json:"order_direction" yaml:"order_direction" mapstructure:"order_direction"`

	// Target corresponds to the JSON schema field "target".
	Target OrderByTarget `json:"target" yaml:"target" mapstructure:"target"`
}

func (*OrderByElement) UnmarshalJSON 

func (j *OrderByElement) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type OrderByTarget 

type OrderByTarget struct {
	// contains filtered or unexported fields
}

OrderByTarget represents an order_by field of the Query object

func NewOrderByTarget 

func NewOrderByTarget[T OrderByTargetInner](inner T) OrderByTarget

NewOrderByTarget creates a new OrderByTarget instance.

func (OrderByTarget) Equal 

func (j OrderByTarget) Equal(value OrderByTarget) bool

Equal checks whether instances are the same.

func (OrderByTarget) Interface 

func (j OrderByTarget) Interface() OrderByTargetInner

Interface tries to convert the instance to AggregateInner interface.

func (OrderByTarget) IsEmpty 

func (j OrderByTarget) IsEmpty() bool

IsEmpty checks if the inner type is empty.

func (OrderByTarget) MarshalJSON 

func (j OrderByTarget) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler interface.

func (OrderByTarget) Type 

func (j OrderByTarget) Type() OrderByTargetType

Type gets the type enum of the current type.

func (*OrderByTarget) UnmarshalJSON 

func (j *OrderByTarget) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type OrderByTargetInner 

type OrderByTargetInner interface {
	Type() OrderByTargetType
	ToMap() map[string]any
	Wrap() OrderByTarget
}

OrderByTargetInner abstracts the serialization interface for OrderByTarget.

type OrderByTargetType 

type OrderByTargetType string

OrderByTargetType represents a ordering target type. 

const (
	OrderByTargetTypeColumn    OrderByTargetType = "column"
	OrderByTargetTypeAggregate OrderByTargetType = "aggregate"
)

func ParseOrderByTargetType 

func ParseOrderByTargetType(input string) (OrderByTargetType, error)

ParseOrderByTargetType parses a ordering target type argument type from string.

func (OrderByTargetType) IsValid 

func (j OrderByTargetType) IsValid() bool

IsValid checks if the value is invalid.

func (*OrderByTargetType) UnmarshalJSON 

func (j *OrderByTargetType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type OrderDirection 

type OrderDirection string
const OrderDirectionAsc OrderDirection = "asc"
const OrderDirectionDesc OrderDirection = "desc"

func (*OrderDirection) UnmarshalJSON 

func (j *OrderDirection) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type PathElement 

type PathElement struct {
	// Values to be provided to any collection arguments
	Arguments PathElementArguments `json:"arguments" yaml:"arguments" mapstructure:"arguments"`

	// Path to a nested field within an object column that must be navigated before
	// the relationship is navigated. Only non-empty if the 'relationships.nested'
	// capability is supported (plus perhaps one of the sub-capabilities, depending on
	// the feature using the PathElement).
	FieldPath []string `json:"field_path,omitempty" yaml:"field_path,omitempty" mapstructure:"field_path,omitempty"`

	// A predicate expression to apply to the target collection
	Predicate Expression `json:"predicate,omitempty" yaml:"predicate,omitempty" mapstructure:"predicate,omitempty"`

	// The name of the relationship to follow
	Relationship string `json:"relationship" yaml:"relationship" mapstructure:"relationship"`
}

func (*PathElement) FromValue 

func (pe *PathElement) FromValue(raw map[string]any) error

FromValue decodes the raw object value to the instance.

func (*PathElement) UnmarshalJSON 

func (j *PathElement) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type PathElementArguments 

type PathElementArguments map[string]RelationshipArgument

Values to be provided to any collection arguments

type PredicateType 

type PredicateType struct {
	// The name can refer to a primitive type or a scalar type
	ObjectTypeName string `json:"object_type_name" mapstructure:"object_type_name" yaml:"object_type_name"`
}

PredicateType represents a predicate type for a given object type.

func NewPredicateType 

func NewPredicateType(objectTypeName string) *PredicateType

NewPredicateType creates a new PredicateType instance.

func (PredicateType) Encode 

func (ty PredicateType) Encode() Type

Encode returns the raw Type instance.

func (PredicateType) String 

func (ty PredicateType) String() string

String implements the fmt.Stringer interface.

func (PredicateType) Type 

func (ty PredicateType) Type() TypeEnum

Type return the type name of the instance.

type ProcedureInfo 

type ProcedureInfo struct {
	// Any arguments that this collection requires
	Arguments ProcedureInfoArguments `json:"arguments" yaml:"arguments" mapstructure:"arguments"`

	// Column description
	Description *string `json:"description,omitempty" yaml:"description,omitempty" mapstructure:"description,omitempty"`

	// The name of the procedure
	Name string `json:"name" yaml:"name" mapstructure:"name"`

	// The name of the result type
	ResultType Type `json:"result_type" yaml:"result_type" mapstructure:"result_type"`
}

func (*ProcedureInfo) UnmarshalJSON 

func (j *ProcedureInfo) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

func (*ProcedureInfo) UnmarshalJSONMap 

func (j *ProcedureInfo) UnmarshalJSONMap(raw map[string]json.RawMessage) error

UnmarshalJSONMap decodes ProcedureInfo from a JSON map.

type ProcedureInfoArguments 

type ProcedureInfoArguments map[string]ArgumentInfo

Any arguments that this collection requires

type ProcedureResult 

type ProcedureResult struct {
	Result any `json:"result" mapstructure:"result" yaml:"result"`
}

ProcedureResult represent the result of a procedure mutation operation.

func NewProcedureResult 

func NewProcedureResult(result any) *ProcedureResult

NewProcedureResult creates a MutationProcedureResult instance.

func (ProcedureResult) Encode 

func (pr ProcedureResult) Encode() MutationOperationResults

Encode encodes the struct to MutationOperationResults.

func (ProcedureResult) Type 

func (pr ProcedureResult) Type() MutationOperationType

Type return the type name of the instance.

type Query 

type Query struct {
	// Aggregate fields of the query. Only used if the 'query.aggregates' capability
	// is supported.
	Aggregates QueryAggregates `json:"aggregates,omitempty" yaml:"aggregates,omitempty" mapstructure:"aggregates,omitempty"`

	// Fields of the query
	Fields QueryFields `json:"fields,omitempty" yaml:"fields,omitempty" mapstructure:"fields,omitempty"`

	// Optionally group and aggregate the selected rows. Only used if the
	// 'query.aggregates.group_by' capability is supported.
	Groups *Grouping `json:"groups,omitempty" yaml:"groups,omitempty" mapstructure:"groups,omitempty"`

	// Optionally limit to N results
	Limit *int `json:"limit,omitempty" yaml:"limit,omitempty" mapstructure:"limit,omitempty"`

	// Optionally offset from the Nth result
	Offset *int `json:"offset,omitempty" yaml:"offset,omitempty" mapstructure:"offset,omitempty"`

	// Optionally specify how rows should be ordered
	OrderBy *OrderBy `json:"order_by" yaml:"order_by" mapstructure:"order_by"`

	// Optionally specify a predicate to apply to the rows
	Predicate Expression `json:"predicate,omitempty" yaml:"predicate,omitempty" mapstructure:"predicate,omitempty"`
}

func (*Query) UnmarshalJSON 

func (j *Query) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type QueryAggregates 

type QueryAggregates map[string]Aggregate

Aggregate fields of the query. Only used if the 'query.aggregates' capability is supported.

type QueryCapabilities 

type QueryCapabilities struct {
	// Does the connector support aggregate queries
	Aggregates *AggregateCapabilities `json:"aggregates,omitempty" yaml:"aggregates,omitempty" mapstructure:"aggregates,omitempty"`

	// Does the connector support EXISTS predicates
	Exists ExistsCapabilities `json:"exists,omitempty" yaml:"exists,omitempty" mapstructure:"exists,omitempty"`

	// Does the connector support explaining queries
	Explain *LeafCapability `json:"explain,omitempty" yaml:"explain,omitempty" mapstructure:"explain,omitempty"`

	// Does the connector support nested fields
	NestedFields NestedFieldCapabilities `json:"nested_fields,omitempty" yaml:"nested_fields,omitempty" mapstructure:"nested_fields,omitempty"`

	// Does the connector support queries which use variables
	Variables *LeafCapability `json:"variables" yaml:"variables" mapstructure:"variables"`
}

func (*QueryCapabilities) UnmarshalJSON 

func (j *QueryCapabilities) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type QueryCapabilitiesSchemaInfo 

type QueryCapabilitiesSchemaInfo struct {
	// Schema information relevant to aggregate query capabilities
	Aggregates *AggregateCapabilitiesSchemaInfo `json:"aggregates,omitempty" yaml:"aggregates,omitempty" mapstructure:"aggregates,omitempty"`
}

type QueryFields 

type QueryFields map[string]Field

Fields of the query

type QueryRequest 

type QueryRequest struct {
	// Values to be provided to any collection arguments
	Arguments QueryRequestArguments `json:"arguments" yaml:"arguments" mapstructure:"arguments"`

	// The name of a collection
	Collection string `json:"collection" yaml:"collection" mapstructure:"collection"`

	// Any relationships between collections involved in the query request. Only used
	// if the 'relationships' capability is supported.
	CollectionRelationships QueryRequestCollectionRelationships `json:"collection_relationships" yaml:"collection_relationships" mapstructure:"collection_relationships"`

	// The query syntax tree
	Query Query `json:"query" yaml:"query" mapstructure:"query"`

	// Values to be provided to request-level arguments.
	RequestArguments QueryRequestRequestArguments `json:"request_arguments,omitempty" yaml:"request_arguments,omitempty" mapstructure:"request_arguments,omitempty"`

	// One set of named variables for each rowset to fetch. Each variable set should
	// be subtituted in turn, and a fresh set of rows returned. Only used if the
	// 'query.variables' capability is supported.
	Variables []QueryRequestVariablesElem `json:"variables" yaml:"variables" mapstructure:"variables"`
}

This is the request body of the query POST endpoint

func (*QueryRequest) UnmarshalJSON 

func (j *QueryRequest) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type QueryRequestArguments 

type QueryRequestArguments map[string]Argument

Values to be provided to any collection arguments

type QueryRequestCollectionRelationships 

type QueryRequestCollectionRelationships map[string]Relationship

Any relationships between collections involved in the query request. Only used if the 'relationships' capability is supported.

type QueryRequestRequestArguments 

type QueryRequestRequestArguments map[string]interface{}

Values to be provided to request-level arguments.

type QueryRequestVariablesElem 

type QueryRequestVariablesElem map[string]interface{}

type QueryResponse 

type QueryResponse []RowSet

Query responses may return multiple RowSets when using queries with variables. Else, there should always be exactly one RowSet

type RawCapabilitiesResponse 

type RawCapabilitiesResponse struct {
	// contains filtered or unexported fields
}

RawCapabilitiesResponse represents a NDC capabilities response with pre-encoded raw bytes.

func NewRawCapabilitiesResponse 

func NewRawCapabilitiesResponse(data []byte) (*RawCapabilitiesResponse, error)

NewRawCapabilitiesResponse creates and validate a RawSchemaResponse instance.

func NewRawCapabilitiesResponseUnsafe 

func NewRawCapabilitiesResponseUnsafe(data []byte) *RawCapabilitiesResponse

NewRawCapabilitiesResponseUnsafe creates a RawSchemaResponse instance from raw bytes without validation.

func (RawCapabilitiesResponse) MarshalCapabilitiesJSON 

func (j RawCapabilitiesResponse) MarshalCapabilitiesJSON() ([]byte, error)

MarshalCapabilitiesJSON encodes the NDC schema response to JSON.

type RawSchemaResponse 

type RawSchemaResponse struct {
	// contains filtered or unexported fields
}

RawSchemaResponse represents a NDC schema response with pre-encoded raw bytes.

func NewRawSchemaResponse 

func NewRawSchemaResponse(data []byte) (*RawSchemaResponse, error)

NewRawSchemaResponse creates and validate a RawSchemaResponse instance.

func NewRawSchemaResponseUnsafe 

func NewRawSchemaResponseUnsafe(data []byte) *RawSchemaResponse

NewRawSchemaResponse creates a RawSchemaResponse instance from raw bytes without validation.

func (RawSchemaResponse) MarshalSchemaJSON 

func (j RawSchemaResponse) MarshalSchemaJSON() ([]byte, error)

MarshalSchemaJSON encodes the NDC schema response to JSON.

type Relation 

type Relation struct {
	// contains filtered or unexported fields
}

Relation is provided by reference to a relation.

func NewRelation 

func NewRelation[R RelationInner](inner R) Relation

NewRelation creates the relation instance.

func (Relation) Interface 

func (j Relation) Interface() RelationInner

Interface tries to convert the instance to RelationInner interface.

func (Relation) IsEmpty 

func (j Relation) IsEmpty() bool

IsEmpty checks if the inner type is empty.

func (Relation) MarshalJSON 

func (j Relation) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler interface.

func (Relation) Type 

func (j Relation) Type() RelationType

Type gets the type enum of the current type.

func (*Relation) UnmarshalJSON 

func (j *Relation) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationAggregate 

type RelationAggregate struct {
	Input Relation `json:"input"      mapstructure:"input"      yaml:"input"`
	// Only non-empty if the 'relational_query.aggregate.group_by' capability is supported.
	GroupBy    []RelationalExpression `json:"group_by"   mapstructure:"group_by"   yaml:"group_by"`
	Aggregates []RelationalExpression `json:"aggregates" mapstructure:"aggregates" yaml:"aggregates"`
}

RelationAggregate represents an aggregate relation.

func NewRelationAggregate 

func NewRelationAggregate[R RelationInner](
	input R,
	groupBy []RelationalExpressionInner,
	aggregates []RelationalExpressionInner,
) *RelationAggregate

NewRelationAggregate creates a RelationAggregate instance.

func (RelationAggregate) ToMap 

func (j RelationAggregate) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationAggregate) Type 

func (j RelationAggregate) Type() RelationType

Type return the type name of the instance.

func (RelationAggregate) Wrap 

func (j RelationAggregate) Wrap() Relation

Encode returns the relation wrapper.

type RelationFilter 

type RelationFilter struct {
	Input     Relation             `json:"input"     mapstructure:"input"     yaml:"input"`
	Predicate RelationalExpression `json:"predicate" mapstructure:"predicate" yaml:"predicate"`
}

RelationFilter represents a filter relation.

func NewRelationFilter 

func NewRelationFilter[R RelationInner, P RelationalExpressionInner](
	input R,
	predicate P,
) *RelationFilter

NewRelationFilter creates a RelationFilter instance.

func (RelationFilter) ToMap 

func (j RelationFilter) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationFilter) Type 

func (j RelationFilter) Type() RelationType

Type return the type name of the instance.

func (RelationFilter) Wrap 

func (j RelationFilter) Wrap() Relation

Encode returns the relation wrapper.

type RelationFrom 

type RelationFrom struct {
	Collection string                       `json:"collection"          mapstructure:"collection" yaml:"collection"`
	Columns    []string                     `json:"columns"             mapstructure:"columns"    yaml:"columns"`
	Arguments  map[string]RelationalLiteral `json:"arguments,omitempty" mapstructure:"arguments"  yaml:"arguments,omitempty"`
}

RelationFrom represents a from relation.

func NewRelationFrom 

func NewRelationFrom(collection string, columns []string) *RelationFrom

NewRelationFrom creates a RelationFrom instance.

func (RelationFrom) ToMap 

func (j RelationFrom) ToMap() map[string]any

ToMap converts the instance to raw Relation.

func (RelationFrom) Type 

func (j RelationFrom) Type() RelationType

Type return the type name of the instance.

func (RelationFrom) WithArgument 

func (f RelationFrom) WithArgument(key string, argument RelationalLiteralInner) *RelationFrom

WithArgument return a new column field with an arguments set.

func (RelationFrom) WithArguments 

func (f RelationFrom) WithArguments(arguments map[string]RelationalLiteralInner) *RelationFrom

WithArguments return a new column field with arguments set.

func (RelationFrom) Wrap 

func (j RelationFrom) Wrap() Relation

Encode returns the relation wrapper.

type RelationInner 

type RelationInner interface {
	Type() RelationType
	ToMap() map[string]any
	Wrap() Relation
}

RelationInner abstracts the interface for Relation.

type RelationJoin 

type RelationJoin struct {
	Left     Relation `json:"left"      mapstructure:"left"      yaml:"left"`
	Right    Relation `json:"right"     mapstructure:"right"     yaml:"right"`
	On       []JoinOn `json:"on"        mapstructure:"on"        yaml:"on"`
	JoinType JoinType `json:"join_type" mapstructure:"join_type" yaml:"join_type"`
}

RelationJoin represents a join relation.

func NewRelationJoin 

func NewRelationJoin[L RelationInner, R RelationInner](
	left L,
	right R,
	on []JoinOn,
	joinType JoinType,
) *RelationJoin

NewRelationJoin creates a RelationJoin instance.

func (RelationJoin) ToMap 

func (j RelationJoin) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationJoin) Type 

func (j RelationJoin) Type() RelationType

Type return the type name of the instance.

func (RelationJoin) Wrap 

func (j RelationJoin) Wrap() Relation

Encode returns the relation wrapper.

type RelationPaginate 

type RelationPaginate struct {
	Input Relation `json:"input" mapstructure:"input" yaml:"input"`
	Fetch *uint64  `json:"fetch" mapstructure:"fetch" yaml:"fetch"`
	Skip  uint64   `json:"skip"  mapstructure:"skip"  yaml:"skip"`
}

RelationPaginate represents a paginate relation.

func NewRelationPaginate 

func NewRelationPaginate[R RelationInner](input R, fetch *uint64, skip uint64) *RelationPaginate

NewRelationPaginate creates a RelationPaginate instance.

func (RelationPaginate) ToMap 

func (j RelationPaginate) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationPaginate) Type 

func (j RelationPaginate) Type() RelationType

Type return the type name of the instance.

func (RelationPaginate) Wrap 

func (j RelationPaginate) Wrap() Relation

Encode returns the relation wrapper.

type RelationProject 

type RelationProject struct {
	Input Relation               `json:"input" mapstructure:"input" yaml:"input"`
	Exprs []RelationalExpression `json:"exprs" mapstructure:"exprs" yaml:"exprs"`
}

RelationProject represents a project relation.

func NewRelationProject 

func NewRelationProject[R RelationInner](
	input R,
	expressions []RelationalExpressionInner,
) *RelationProject

NewRelationProject creates a RelationProject instance.

func (RelationProject) ToMap 

func (j RelationProject) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationProject) Type 

func (j RelationProject) Type() RelationType

Type return the type name of the instance.

func (RelationProject) Wrap 

func (j RelationProject) Wrap() Relation

Encode returns the relation wrapper.

type RelationSort 

type RelationSort struct {
	Input Relation `json:"input" mapstructure:"input" yaml:"input"`
	Exprs []Sort   `json:"exprs" mapstructure:"exprs" yaml:"exprs"`
}

RelationSort represents a sort relation.

func NewRelationSort 

func NewRelationSort[R RelationInner](input R, exprs []Sort) *RelationSort

NewRelationSort creates a RelationSort instance.

func (RelationSort) ToMap 

func (j RelationSort) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationSort) Type 

func (j RelationSort) Type() RelationType

Type return the type name of the instance.

func (RelationSort) Wrap 

func (j RelationSort) Wrap() Relation

Encode returns the relation wrapper.

type RelationType 

type RelationType string

RelationType represents a relation type enum. 

const (
	RelationTypeFrom      RelationType = "from"
	RelationTypePaginate  RelationType = "paginate"
	RelationTypeProject   RelationType = "project"
	RelationTypeFilter    RelationType = "filter"
	RelationTypeSort      RelationType = "sort"
	RelationTypeJoin      RelationType = "join"
	RelationTypeAggregate RelationType = "aggregate"
	RelationTypeWindow    RelationType = "window"
	RelationTypeUnion     RelationType = "union"
)

func ParseRelationType 

func ParseRelationType(input string) (RelationType, error)

ParseRelationType parses a relation type from string.

func (RelationType) IsValid 

func (j RelationType) IsValid() bool

IsValid checks if the value is invalid.

func (*RelationType) UnmarshalJSON 

func (j *RelationType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationUnion 

type RelationUnion struct {
	Relations []Relation `json:"relations" mapstructure:"relations" yaml:"relations"`
}

RelationUnion represents a union relation.

func NewRelationUnion 

func NewRelationUnion(relations []RelationInner) *RelationUnion

NewRelationUnion creates a RelationUnion instance.

func (RelationUnion) ToMap 

func (j RelationUnion) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationUnion) Type 

func (j RelationUnion) Type() RelationType

Type return the type name of the instance.

func (RelationUnion) Wrap 

func (j RelationUnion) Wrap() Relation

Encode returns the relation wrapper.

type RelationWindow 

type RelationWindow struct {
	Input Relation               `json:"input" mapstructure:"input" yaml:"input"`
	Exprs []RelationalExpression `json:"exprs" mapstructure:"exprs" yaml:"exprs"`
}

RelationWindow represents a window relation.

func NewRelationWindow 

func NewRelationWindow[R RelationInner](
	input R,
	expressions []RelationalExpressionInner,
) *RelationWindow

NewRelationWindow creates a RelationWindow instance.

func (RelationWindow) ToMap 

func (j RelationWindow) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationWindow) Type 

func (j RelationWindow) Type() RelationType

Type return the type name of the instance.

func (RelationWindow) Wrap 

func (j RelationWindow) Wrap() Relation

Encode returns the relation wrapper.

type RelationalAggregateCapabilities 

type RelationalAggregateCapabilities struct {
	// Expression corresponds to the JSON schema field "expression".
	Expression RelationalExpressionCapabilities `json:"expression" yaml:"expression" mapstructure:"expression"`

	// GroupBy corresponds to the JSON schema field "group_by".
	GroupBy *LeafCapability `json:"group_by,omitempty" yaml:"group_by,omitempty" mapstructure:"group_by,omitempty"`
}

func (*RelationalAggregateCapabilities) UnmarshalJSON 

func (j *RelationalAggregateCapabilities) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalAggregateExpressionCapabilities 

type RelationalAggregateExpressionCapabilities struct {
	// ApproxDistinct corresponds to the JSON schema field "approx_distinct".
	ApproxDistinct *LeafCapability `json:"approx_distinct,omitempty" yaml:"approx_distinct,omitempty" mapstructure:"approx_distinct,omitempty"`

	// ApproxPercentileCont corresponds to the JSON schema field
	// "approx_percentile_cont".
	ApproxPercentileCont *LeafCapability `` /* 127-byte string literal not displayed */

	// ArrayAgg corresponds to the JSON schema field "array_agg".
	ArrayAgg *RelationalOrderedAggregateFunctionCapabilities `json:"array_agg,omitempty" yaml:"array_agg,omitempty" mapstructure:"array_agg,omitempty"`

	// Avg corresponds to the JSON schema field "avg".
	Avg *LeafCapability `json:"avg,omitempty" yaml:"avg,omitempty" mapstructure:"avg,omitempty"`

	// BoolAnd corresponds to the JSON schema field "bool_and".
	BoolAnd *LeafCapability `json:"bool_and,omitempty" yaml:"bool_and,omitempty" mapstructure:"bool_and,omitempty"`

	// BoolOr corresponds to the JSON schema field "bool_or".
	BoolOr *LeafCapability `json:"bool_or,omitempty" yaml:"bool_or,omitempty" mapstructure:"bool_or,omitempty"`

	// Count corresponds to the JSON schema field "count".
	Count *LeafCapability `json:"count,omitempty" yaml:"count,omitempty" mapstructure:"count,omitempty"`

	// FirstValue corresponds to the JSON schema field "first_value".
	FirstValue *LeafCapability `json:"first_value,omitempty" yaml:"first_value,omitempty" mapstructure:"first_value,omitempty"`

	// LastValue corresponds to the JSON schema field "last_value".
	LastValue *LeafCapability `json:"last_value,omitempty" yaml:"last_value,omitempty" mapstructure:"last_value,omitempty"`

	// Max corresponds to the JSON schema field "max".
	Max *LeafCapability `json:"max,omitempty" yaml:"max,omitempty" mapstructure:"max,omitempty"`

	// Median corresponds to the JSON schema field "median".
	Median *LeafCapability `json:"median,omitempty" yaml:"median,omitempty" mapstructure:"median,omitempty"`

	// Min corresponds to the JSON schema field "min".
	Min *LeafCapability `json:"min,omitempty" yaml:"min,omitempty" mapstructure:"min,omitempty"`

	// Stddev corresponds to the JSON schema field "stddev".
	Stddev *LeafCapability `json:"stddev,omitempty" yaml:"stddev,omitempty" mapstructure:"stddev,omitempty"`

	// StddevPop corresponds to the JSON schema field "stddev_pop".
	StddevPop *LeafCapability `json:"stddev_pop,omitempty" yaml:"stddev_pop,omitempty" mapstructure:"stddev_pop,omitempty"`

	// StringAgg corresponds to the JSON schema field "string_agg".
	StringAgg *RelationalOrderedAggregateFunctionCapabilities `json:"string_agg,omitempty" yaml:"string_agg,omitempty" mapstructure:"string_agg,omitempty"`

	// StringAggWithSeparator corresponds to the JSON schema field
	// "string_agg_with_separator".
	StringAggWithSeparator *RelationalOrderedAggregateFunctionCapabilities `` /* 136-byte string literal not displayed */

	// Sum corresponds to the JSON schema field "sum".
	Sum *LeafCapability `json:"sum,omitempty" yaml:"sum,omitempty" mapstructure:"sum,omitempty"`

	// Var corresponds to the JSON schema field "var".
	Var *LeafCapability `json:"var,omitempty" yaml:"var,omitempty" mapstructure:"var,omitempty"`
}

type RelationalAggregateFunctionCapabilities 

type RelationalAggregateFunctionCapabilities struct {
	// Distinct corresponds to the JSON schema field "distinct".
	Distinct *LeafCapability `json:"distinct,omitempty" yaml:"distinct,omitempty" mapstructure:"distinct,omitempty"`
}

type RelationalCaseCapabilities 

type RelationalCaseCapabilities struct {
	// Scrutinee corresponds to the JSON schema field "scrutinee".
	Scrutinee *LeafCapability `json:"scrutinee,omitempty" yaml:"scrutinee,omitempty" mapstructure:"scrutinee,omitempty"`
}

type RelationalComparisonExpressionCapabilities 

type RelationalComparisonExpressionCapabilities struct {
	// Between corresponds to the JSON schema field "between".
	Between *LeafCapability `json:"between,omitempty" yaml:"between,omitempty" mapstructure:"between,omitempty"`

	// Contains corresponds to the JSON schema field "contains".
	Contains *LeafCapability `json:"contains,omitempty" yaml:"contains,omitempty" mapstructure:"contains,omitempty"`

	// GreaterThan corresponds to the JSON schema field "greater_than".
	GreaterThan *LeafCapability `json:"greater_than,omitempty" yaml:"greater_than,omitempty" mapstructure:"greater_than,omitempty"`

	// GreaterThanEq corresponds to the JSON schema field "greater_than_eq".
	GreaterThanEq *LeafCapability `json:"greater_than_eq,omitempty" yaml:"greater_than_eq,omitempty" mapstructure:"greater_than_eq,omitempty"`

	// Ilike corresponds to the JSON schema field "ilike".
	Ilike *LeafCapability `json:"ilike,omitempty" yaml:"ilike,omitempty" mapstructure:"ilike,omitempty"`

	// InList corresponds to the JSON schema field "in_list".
	InList *LeafCapability `json:"in_list,omitempty" yaml:"in_list,omitempty" mapstructure:"in_list,omitempty"`

	// IsDistinctFrom corresponds to the JSON schema field "is_distinct_from".
	IsDistinctFrom *LeafCapability `json:"is_distinct_from,omitempty" yaml:"is_distinct_from,omitempty" mapstructure:"is_distinct_from,omitempty"`

	// IsFalse corresponds to the JSON schema field "is_false".
	IsFalse *LeafCapability `json:"is_false,omitempty" yaml:"is_false,omitempty" mapstructure:"is_false,omitempty"`

	// IsNan corresponds to the JSON schema field "is_nan".
	IsNan *LeafCapability `json:"is_nan,omitempty" yaml:"is_nan,omitempty" mapstructure:"is_nan,omitempty"`

	// IsNull corresponds to the JSON schema field "is_null".
	IsNull *LeafCapability `json:"is_null,omitempty" yaml:"is_null,omitempty" mapstructure:"is_null,omitempty"`

	// IsTrue corresponds to the JSON schema field "is_true".
	IsTrue *LeafCapability `json:"is_true,omitempty" yaml:"is_true,omitempty" mapstructure:"is_true,omitempty"`

	// IsZero corresponds to the JSON schema field "is_zero".
	IsZero *LeafCapability `json:"is_zero,omitempty" yaml:"is_zero,omitempty" mapstructure:"is_zero,omitempty"`

	// LessThan corresponds to the JSON schema field "less_than".
	LessThan *LeafCapability `json:"less_than,omitempty" yaml:"less_than,omitempty" mapstructure:"less_than,omitempty"`

	// LessThanEq corresponds to the JSON schema field "less_than_eq".
	LessThanEq *LeafCapability `json:"less_than_eq,omitempty" yaml:"less_than_eq,omitempty" mapstructure:"less_than_eq,omitempty"`

	// Like corresponds to the JSON schema field "like".
	Like *LeafCapability `json:"like,omitempty" yaml:"like,omitempty" mapstructure:"like,omitempty"`
}

type RelationalConditionalExpressionCapabilities 

type RelationalConditionalExpressionCapabilities struct {
	// Case corresponds to the JSON schema field "case".
	Case *RelationalCaseCapabilities `json:"case,omitempty" yaml:"case,omitempty" mapstructure:"case,omitempty"`

	// Nullif corresponds to the JSON schema field "nullif".
	Nullif *LeafCapability `json:"nullif,omitempty" yaml:"nullif,omitempty" mapstructure:"nullif,omitempty"`
}

type RelationalDeleteRequest 

type RelationalDeleteRequest struct {
	// Values to be provided to any collection arguments
	Arguments RelationalDeleteRequestArguments `json:"arguments" yaml:"arguments" mapstructure:"arguments"`

	// The name of the collection to delete from
	Collection string `json:"collection" yaml:"collection" mapstructure:"collection"`

	// The relation that identifies which rows to delete
	Relation Relation `json:"relation" yaml:"relation" mapstructure:"relation"`
}

func (*RelationalDeleteRequest) UnmarshalJSON 

func (j *RelationalDeleteRequest) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalDeleteRequestArguments 

type RelationalDeleteRequestArguments map[string]Argument

Values to be provided to any collection arguments

type RelationalDeleteResponse 

type RelationalDeleteResponse struct {
	// The number of rows that were deleted
	AffectedRows int `json:"affected_rows" yaml:"affected_rows" mapstructure:"affected_rows"`
}

func (*RelationalDeleteResponse) UnmarshalJSON 

func (j *RelationalDeleteResponse) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalExpression 

type RelationalExpression struct {
	// contains filtered or unexported fields
}

RelationalExpression is provided by reference to a relational expression.

func NewRelationalExpression 

func NewRelationalExpression[T RelationalExpressionInner](inner T) RelationalExpression

NewRelationalExpression creates a RelationalExpression instance.

func (RelationalExpression) Interface 

func (j RelationalExpression) Interface() RelationalExpressionInner

Interface tries to convert the instance to AggregateInner interface.

func (RelationalExpression) IsEmpty 

func (j RelationalExpression) IsEmpty() bool

IsEmpty checks if the inner type is empty.

func (RelationalExpression) MarshalJSON 

func (j RelationalExpression) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler interface.

func (RelationalExpression) Type 

func (j RelationalExpression) Type() RelationalExpressionType

Type gets the type enum of the current type.

func (*RelationalExpression) UnmarshalJSON 

func (j *RelationalExpression) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalExpressionAbs 

type RelationalExpressionAbs struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionAbs represents a RelationalExpression with the abs type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.abs` * During filtering: `relational_query.filter.scalar.abs` * During sorting:`relational_query.sort.expression.scalar.abs` * During joining: `relational_query.join.expression.scalar.abs` * During aggregation: `relational_query.aggregate.expression.scalar.abs` * During windowing: `relational_query.window.expression.scalar.abs`.

func NewRelationalExpressionAbs 

func NewRelationalExpressionAbs[E RelationalExpressionInner](expr E) *RelationalExpressionAbs

NewRelationalExpressionAbs creates a RelationalExpressionAbs instance.

func (RelationalExpressionAbs) ToMap 

func (j RelationalExpressionAbs) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionAbs) Type 

func (j RelationalExpressionAbs) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionAbs) Wrap 

func (j RelationalExpressionAbs) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionAnd 

type RelationalExpressionAnd struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionAnd represents a RelationalExpression with the and type.

func NewRelationalExpressionAnd 

func NewRelationalExpressionAnd[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionAnd

NewRelationalExpressionAnd creates a RelationalExpressionAnd instance.

func (RelationalExpressionAnd) ToMap 

func (j RelationalExpressionAnd) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionAnd) Type 

func (j RelationalExpressionAnd) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionAnd) Wrap 

func (j RelationalExpressionAnd) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionApproxDistinct 

type RelationalExpressionApproxDistinct struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionApproxDistinct represents a RelationalExpression with the approx_distinct type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.aggregate.approx_distinct` * During filtering: `relational_query.filter.aggregate.approx_distinct` * During sorting:`relational_query.sort.expression.aggregate.approx_distinct` * During joining: `relational_query.join.expression.aggregate.approx_distinct` * During aggregation: `relational_query.aggregate.expression.aggregate.approx_distinct` * During windowing: `relational_query.window.expression.aggregate.approx_distinct`.

func NewRelationalExpressionApproxDistinct 

func NewRelationalExpressionApproxDistinct[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionApproxDistinct

NewRelationalExpressionApproxDistinct creates a RelationalExpressionApproxDistinct instance.

func (RelationalExpressionApproxDistinct) ToMap 

func (j RelationalExpressionApproxDistinct) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionApproxDistinct) Type 

func (j RelationalExpressionApproxDistinct) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionApproxDistinct) Wrap 

func (j RelationalExpressionApproxDistinct) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionApproxPercentileCont 

type RelationalExpressionApproxPercentileCont struct {
	Expr       RelationalExpression `json:"expr"       mapstructure:"expr"       yaml:"expr"`
	Percentile float64              `json:"percentile" mapstructure:"percentile" yaml:"percentile"`
}

RelationalExpressionApproxPercentileCont represents a RelationalExpression with the approx_percentile_cont type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.aggregate.approx_percentile_cont` * During filtering: `relational_query.filter.aggregate.approx_percentile_cont` * During sorting:`relational_query.sort.expression.aggregate.approx_percentile_cont` * During joining: `relational_query.join.expression.aggregate.approx_percentile_cont` * During aggregation: `relational_query.aggregate.expression.aggregate.approx_percentile_cont` * During windowing: `relational_query.window.expression.aggregate.approx_percentile_cont`.

func NewRelationalExpressionApproxPercentileCont 

func NewRelationalExpressionApproxPercentileCont[E RelationalExpressionInner](
	expr E,
	percentile float64,
) *RelationalExpressionApproxPercentileCont

NewRelationalExpressionApproxPercentileCont creates a RelationalExpressionApproxPercentileCont instance.

func (RelationalExpressionApproxPercentileCont) ToMap 

func (j RelationalExpressionApproxPercentileCont) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionApproxPercentileCont) Type 

func (j RelationalExpressionApproxPercentileCont) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionApproxPercentileCont) Wrap 

func (j RelationalExpressionApproxPercentileCont) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionArrayAgg 

type RelationalExpressionArrayAgg struct {
	Expr RelationalExpression `json:"expr"               mapstructure:"expr"               yaml:"expr"`
	// Only used when in specific contexts where the appropriate capability is supported:
	// * During projection: `relational_query.project.expression.aggregate.array_agg.distinct`
	// * During filtering: `relational_query.filter.aggregate.array_agg.distinct`
	// * During sorting:`relational_query.sort.expression.aggregate.array_agg.distinct`
	// * During joining: `relational_query.join.expression.aggregate.array_agg.distinct`
	// * During aggregation: `relational_query.aggregate.expression.aggregate.array_agg.distinct`
	// * During windowing: `relational_query.window.expression.aggregate.array_agg.distinct`
	Distinct bool `json:"distinct"           mapstructure:"distinct"           yaml:"distinct"`
	// Only used when in specific contexts where the appropriate capability is supported:
	// * During projection: `relational_query.project.expression.aggregate.array_agg.order_by`
	// * During filtering: `relational_query.filter.aggregate.array_agg.order_by`
	// * During sorting:`relational_query.sort.expression.aggregate.array_agg.order_by`
	// * During joining: `relational_query.join.expression.aggregate.array_agg.order_by`
	// * During aggregation: `relational_query.aggregate.expression.aggregate.array_agg.order_by`
	// * During windowing: `relational_query.window.expression.aggregate.array_agg.order_by`
	OrderBy []Sort `json:"order_by,omitempty" mapstructure:"order_by,omitempty" yaml:"order_by,omitempty"`
}

RelationalExpressionArrayAgg represents a RelationalExpression with the array_agg type.

func NewRelationalExpressionArrayAgg 

func NewRelationalExpressionArrayAgg[E RelationalExpressionInner](
	expr E,
	distinct bool,
) *RelationalExpressionArrayAgg

NewRelationalExpressionArrayAgg creates a RelationalExpressionArrayAgg instance.

func (RelationalExpressionArrayAgg) ToMap 

func (j RelationalExpressionArrayAgg) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionArrayAgg) Type 

func (j RelationalExpressionArrayAgg) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionArrayAgg) WithOrderBy 

func (j RelationalExpressionArrayAgg) WithOrderBy(orderBy []Sort) *RelationalExpressionArrayAgg

WithOrderBy returns the RelationalExpressionStringAgg with order by.

func (RelationalExpressionArrayAgg) Wrap 

func (j RelationalExpressionArrayAgg) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionArrayElement 

type RelationalExpressionArrayElement struct {
	Column RelationalExpression `json:"column" mapstructure:"column" yaml:"column"`
	Index  uint                 `json:"index"  mapstructure:"index"  yaml:"index"`
}

RelationalExpressionArrayElement represents a RelationalExpression with the array_element type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.array_element` * During filtering: `relational_query.filter.scalar.array_element` * During sorting:`relational_query.sort.expression.scalar.array_element` * During joining: `relational_query.join.expression.scalar.array_element` * During aggregation: `relational_query.aggregate.expression.scalar.array_element` * During windowing: `relational_query.window.expression.scalar.array_element`.

func NewRelationalExpressionArrayElement 

func NewRelationalExpressionArrayElement[E RelationalExpressionInner](
	column E,
	index uint,
) *RelationalExpressionArrayElement

NewRelationalExpressionArrayElement creates a RelationalExpressionArrayElement instance.

func (RelationalExpressionArrayElement) ToMap 

func (j RelationalExpressionArrayElement) ToMap() map[string]any

ToMap converts the instance to raw map.

func (RelationalExpressionArrayElement) Type 

func (j RelationalExpressionArrayElement) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionArrayElement) Wrap 

func (j RelationalExpressionArrayElement) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionAverage 

type RelationalExpressionAverage struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionAverage represents a RelationalExpression with the average type.

func NewRelationalExpressionAverage 

func NewRelationalExpressionAverage[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionAverage

NewRelationalExpressionAverage creates a RelationalExpressionAverage instance.

func (RelationalExpressionAverage) ToMap 

func (j RelationalExpressionAverage) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionAverage) Type 

func (j RelationalExpressionAverage) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionAverage) Wrap 

func (j RelationalExpressionAverage) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionBTrim 

type RelationalExpressionBTrim struct {
	Str     RelationalExpression  `json:"str"                mapstructure:"str"                yaml:"str"`
	TrimStr *RelationalExpression `json:"trim_str,omitempty" mapstructure:"trim_str,omitempty" yaml:"trim_str,omitempty"`
}

RelationalExpressionBTrim represents a RelationalExpression with the b_trim type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.btrim` * During filtering: `relational_query.filter.scalar.btrim` * During sorting:`relational_query.sort.expression.scalar.btrim` * During joining: `relational_query.join.expression.scalar.btrim` * During aggregation: `relational_query.aggregate.expression.scalar.btrim` * During windowing: `relational_query.window.expression.scalar.btrim`.

func NewRelationalExpressionBTrim 

func NewRelationalExpressionBTrim[E RelationalExpressionInner](str E) *RelationalExpressionBTrim

NewRelationalExpressionBTrim creates a RelationalExpressionBTrim instance.

func (RelationalExpressionBTrim) ToMap 

func (j RelationalExpressionBTrim) ToMap() map[string]any

ToMap converts the instance to raw map.

func (RelationalExpressionBTrim) Type 

func (j RelationalExpressionBTrim) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionBTrim) WithTrimStr 

func (j RelationalExpressionBTrim) WithTrimStr(
	trimStr RelationalExpressionInner,
) *RelationalExpressionBTrim

WithTrimStr return the instance with new trim_str.

func (RelationalExpressionBTrim) Wrap 

func (j RelationalExpressionBTrim) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionBetween 

type RelationalExpressionBetween struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
	Low  RelationalExpression `json:"low"  mapstructure:"low"  yaml:"low"`
	High RelationalExpression `json:"high" mapstructure:"high" yaml:"high"`
}

RelationalExpressionBetween represents a RelationalExpression with the between type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.comparison.between` * During filtering: `relational_query.filter.comparison.between` * During sorting:`relational_query.sort.expression.comparison.between` * During joining: `relational_query.join.expression.comparison.between` * During aggregation: `relational_query.aggregate.expression.comparison.between` * During windowing: `relational_query.window.expression.comparison.between`.

func NewRelationalExpressionBetween 

func NewRelationalExpressionBetween[E RelationalExpressionInner, L RelationalExpressionInner, H RelationalExpressionInner](
	expr E,
	low L,
	high H,
) *RelationalExpressionBetween

NewRelationalExpressionBetween creates a RelationalExpressionBetween instance.

func (RelationalExpressionBetween) ToMap 

func (j RelationalExpressionBetween) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionBetween) Type 

func (j RelationalExpressionBetween) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionBetween) Wrap 

func (j RelationalExpressionBetween) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionBinaryConcat 

type RelationalExpressionBinaryConcat struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionBinaryConcat represents a RelationalExpression with the binary_concat type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.binary_concat` * During filtering: `relational_query.filter.scalar.binary_concat` * During sorting:`relational_query.sort.expression.scalar.binary_concat` * During joining: `relational_query.join.expression.scalar.binary_concat` * During aggregation: `relational_query.aggregate.expression.scalar.binary_concat` * During windowing: `relational_query.window.expression.scalar.binary_concat`.

func NewRelationalExpressionBinaryConcat 

func NewRelationalExpressionBinaryConcat[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionBinaryConcat

NewRelationalExpressionBinaryConcat creates a RelationalExpressionBinaryConcat instance.

func (RelationalExpressionBinaryConcat) ToMap 

func (j RelationalExpressionBinaryConcat) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionBinaryConcat) Type 

func (j RelationalExpressionBinaryConcat) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionBinaryConcat) Wrap 

func (j RelationalExpressionBinaryConcat) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionBoolAnd 

type RelationalExpressionBoolAnd struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionBoolAnd represents a RelationalExpression with the bool_and type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.aggregate.bool_and` * During filtering: `relational_query.filter.aggregate.bool_and` * During sorting:`relational_query.sort.expression.aggregate.bool_and` * During joining: `relational_query.join.expression.aggregate.bool_and` * During aggregation: `relational_query.aggregate.expression.aggregate.bool_and` * During windowing: `relational_query.window.expression.aggregate.bool_and`.

func NewRelationalExpressionBoolAnd 

func NewRelationalExpressionBoolAnd[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionBoolAnd

NewRelationalExpressionBoolAnd creates a RelationalExpressionBoolAnd instance.

func (RelationalExpressionBoolAnd) ToMap 

func (j RelationalExpressionBoolAnd) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionBoolAnd) Type 

func (j RelationalExpressionBoolAnd) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionBoolAnd) Wrap 

func (j RelationalExpressionBoolAnd) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionBoolOr 

type RelationalExpressionBoolOr struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionBoolOr represents a RelationalExpression with the bool_or type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.aggregate.bool_or` * During filtering: `relational_query.filter.aggregate.bool_or` * During sorting:`relational_query.sort.expression.aggregate.bool_or` * During joining: `relational_query.join.expression.aggregate.bool_or` * During aggregation: `relational_query.aggregate.expression.aggregate.bool_or` * During windowing: `relational_query.window.expression.aggregate.bool_or`.

func NewRelationalExpressionBoolOr 

func NewRelationalExpressionBoolOr[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionBoolOr

NewRelationalExpressionBoolOr creates a RelationalExpressionBoolOr instance.

func (RelationalExpressionBoolOr) ToMap 

func (j RelationalExpressionBoolOr) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionBoolOr) Type 

func (j RelationalExpressionBoolOr) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionBoolOr) Wrap 

func (j RelationalExpressionBoolOr) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionCapabilities 

type RelationalExpressionCapabilities struct {
	// Aggregate corresponds to the JSON schema field "aggregate".
	Aggregate RelationalAggregateExpressionCapabilities `json:"aggregate" yaml:"aggregate" mapstructure:"aggregate"`

	// Comparison corresponds to the JSON schema field "comparison".
	Comparison RelationalComparisonExpressionCapabilities `json:"comparison" yaml:"comparison" mapstructure:"comparison"`

	// Conditional corresponds to the JSON schema field "conditional".
	Conditional RelationalConditionalExpressionCapabilities `json:"conditional" yaml:"conditional" mapstructure:"conditional"`

	// Scalar corresponds to the JSON schema field "scalar".
	Scalar RelationalScalarExpressionCapabilities `json:"scalar" yaml:"scalar" mapstructure:"scalar"`

	// ScalarTypes corresponds to the JSON schema field "scalar_types".
	ScalarTypes *RelationalScalarTypeCapabilities `json:"scalar_types,omitempty" yaml:"scalar_types,omitempty" mapstructure:"scalar_types,omitempty"`

	// Window corresponds to the JSON schema field "window".
	Window RelationalWindowExpressionCapabilities `json:"window" yaml:"window" mapstructure:"window"`
}

func (*RelationalExpressionCapabilities) UnmarshalJSON 

func (j *RelationalExpressionCapabilities) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalExpressionCase 

type RelationalExpressionCase struct {
	When      []CaseWhen            `json:"when"                mapstructure:"when"                yaml:"when"`
	Scrutinee *RelationalExpression `json:"scrutinee,omitempty" mapstructure:"scrutinee,omitempty" yaml:"scrutinee,omitempty"`
	Default   *RelationalExpression `json:"default,omitempty"   mapstructure:"default,omitempty"   yaml:"default,omitempty"`
}

RelationalExpressionCase represents a RelationalExpression with CASE type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.conditional.case` * During filtering: `relational_query.filter.conditional.case` * During sorting:`relational_query.sort.expression.conditional.case` * During joining: `relational_query.join.expression.conditional.case` * During aggregation: `relational_query.aggregate.expression.conditional.case` * During windowing: `relational_query.window.expression.conditional.case`.

func NewRelationalExpressionCase 

func NewRelationalExpressionCase(when []CaseWhen) *RelationalExpressionCase

NewRelationalExpressionCase creates a RelationalExpressionCase instance.

func (RelationalExpressionCase) ToMap 

func (j RelationalExpressionCase) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionCase) Type 

func (j RelationalExpressionCase) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionCase) WithDefault 

func (j RelationalExpressionCase) WithDefault(
	defaultExpr *RelationalExpression,
) *RelationalExpressionCase

WithDefault returns the RelationalExpressionCase with default expression.

func (RelationalExpressionCase) WithScrutinee 

func (j RelationalExpressionCase) WithScrutinee(
	scrutinee *RelationalExpression,
) *RelationalExpressionCase

WithScrutinee returns the RelationalExpressionCase with scrutinee.

func (RelationalExpressionCase) Wrap 

func (j RelationalExpressionCase) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionCast 

type RelationalExpressionCast struct {
	Expr   RelationalExpression `json:"expr"                mapstructure:"expr"                yaml:"expr"`
	AsType CastType             `json:"as_type"             mapstructure:"as_type"             yaml:"as_type"`
	// Optional for now, but will be required in the future
	FromType *CastType `json:"from_type,omitempty" mapstructure:"from_type,omitempty" yaml:"from_type,omitempty"`
}

RelationalExpressionCast represents a RelationalExpression with the cast type.

func NewRelationalExpressionCast 

func NewRelationalExpressionCast[E RelationalExpressionInner, C CastTypeInner](
	expr E,
	asType C,
) *RelationalExpressionCast

NewRelationalExpressionCast creates a RelationalExpressionCast instance.

func (RelationalExpressionCast) ToMap 

func (j RelationalExpressionCast) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionCast) Type 

func (j RelationalExpressionCast) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionCast) WithFromType 

func (j RelationalExpressionCast) WithFromType(fromType CastTypeInner) *RelationalExpressionCast

WithFromType return the instance with from_type set.

func (RelationalExpressionCast) Wrap 

func (j RelationalExpressionCast) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionCeil 

type RelationalExpressionCeil struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionCeil represents a RelationalExpression with the ceil type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.ceil` * During filtering: `relational_query.filter.scalar.ceil` * During sorting:`relational_query.sort.expression.scalar.ceil` * During joining: `relational_query.join.expression.scalar.ceil` * During aggregation: `relational_query.aggregate.expression.scalar.ceil` * During windowing: `relational_query.window.expression.scalar.ceil`.

func NewRelationalExpressionCeil 

func NewRelationalExpressionCeil[E RelationalExpressionInner](expr E) *RelationalExpressionCeil

NewRelationalExpressionCeil creates a RelationalExpressionCeil instance.

func (RelationalExpressionCeil) ToMap 

func (j RelationalExpressionCeil) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionCeil) Type 

func (j RelationalExpressionCeil) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionCeil) Wrap 

func (j RelationalExpressionCeil) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionCharacterLength 

type RelationalExpressionCharacterLength struct {
	Str RelationalExpression `json:"str" mapstructure:"str" yaml:"str"`
}

RelationalExpressionCharacterLength represents a RelationalExpression with the character_length type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.character_length` * During filtering: `relational_query.filter.scalar.character_length` * During sorting:`relational_query.sort.expression.scalar.character_length` * During joining: `relational_query.join.expression.scalar.character_length` * During aggregation: `relational_query.aggregate.expression.scalar.character_length` * During windowing: `relational_query.window.expression.scalar.character_length`.

func NewRelationalExpressionCharacterLength 

func NewRelationalExpressionCharacterLength[E RelationalExpressionInner](
	str E,
) *RelationalExpressionCharacterLength

NewRelationalExpressionCharacterLength creates a RelationalExpressionCharacterLength instance.

func (RelationalExpressionCharacterLength) ToMap 

func (j RelationalExpressionCharacterLength) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionCharacterLength) Type 

func (j RelationalExpressionCharacterLength) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionCharacterLength) Wrap 

func (j RelationalExpressionCharacterLength) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionCoalesce 

type RelationalExpressionCoalesce struct {
	Exprs []RelationalExpression `json:"exprs" mapstructure:"exprs" yaml:"exprs"`
}

RelationalExpressionCoalesce represents a RelationalExpression with the coalesce type.

func NewRelationalExpressionCoalesce 

func NewRelationalExpressionCoalesce(
	expressions []RelationalExpressionInner,
) *RelationalExpressionCoalesce

NewRelationalExpressionCoalesce creates a RelationalExpressionCoalesce instance.

func (RelationalExpressionCoalesce) ToMap 

func (j RelationalExpressionCoalesce) ToMap() map[string]any

ToMap converts the instance to raw map.

func (RelationalExpressionCoalesce) Type 

func (j RelationalExpressionCoalesce) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionCoalesce) Wrap 

func (j RelationalExpressionCoalesce) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionColumn 

type RelationalExpressionColumn struct {
	Index uint64 `json:"index" mapstructure:"index" yaml:"index"`
}

RelationalExpressionColumn represents a RelationalExpression with column type.

func NewRelationalExpressionColumn 

func NewRelationalExpressionColumn(index uint64) *RelationalExpressionColumn

NewRelationalExpressionColumn creates a RelationalExpressionColumn instance.

func (RelationalExpressionColumn) ToMap 

func (j RelationalExpressionColumn) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionColumn) Type 

func (j RelationalExpressionColumn) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionColumn) Wrap 

func (j RelationalExpressionColumn) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionConcat 

type RelationalExpressionConcat struct {
	Exprs []RelationalExpression `json:"exprs" mapstructure:"exprs" yaml:"exprs"`
}

RelationalExpressionConcat represents a RelationalExpression with the concat type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.concat` * During filtering: `relational_query.filter.scalar.concat` * During sorting:`relational_query.sort.expression.scalar.concat` * During joining: `relational_query.join.expression.scalar.concat` * During aggregation: `relational_query.aggregate.expression.scalar.concat` * During windowing: `relational_query.window.expression.scalar.concat`.

func NewRelationalExpressionConcat 

func NewRelationalExpressionConcat(
	expressions []RelationalExpressionInner,
) *RelationalExpressionConcat

NewRelationalExpressionConcat creates a RelationalExpressionConcat instance.

func (RelationalExpressionConcat) ToMap 

func (j RelationalExpressionConcat) ToMap() map[string]any

ToMap converts the instance to raw map.

func (RelationalExpressionConcat) Type 

func (j RelationalExpressionConcat) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionConcat) Wrap 

func (j RelationalExpressionConcat) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionContains 

type RelationalExpressionContains struct {
	Str       RelationalExpression `json:"str"        mapstructure:"str"        yaml:"str"`
	SearchStr RelationalExpression `json:"search_str" mapstructure:"search_str" yaml:"search_str"`
}

RelationalExpressionContains represents a RelationalExpression with the contains type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.comparison.contains` * During filtering: `relational_query.filter.comparison.contains` * During sorting:`relational_query.sort.expression.comparison.contains` * During joining: `relational_query.join.expression.comparison.contains` * During aggregation: `relational_query.aggregate.expression.comparison.contains` * During windowing: `relational_query.window.expression.comparison.contains`.

func NewRelationalExpressionContains 

func NewRelationalExpressionContains[S RelationalExpressionInner, SS RelationalExpressionInner](
	str S,
	searchStr SS,
) *RelationalExpressionContains

NewRelationalExpressionContains creates a RelationalExpressionContains instance.

func (RelationalExpressionContains) ToMap 

func (j RelationalExpressionContains) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionContains) Type 

func (j RelationalExpressionContains) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionContains) Wrap 

func (j RelationalExpressionContains) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionCos 

type RelationalExpressionCos struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionCos represents a RelationalExpression with the cos type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.cos` * During filtering: `relational_query.filter.scalar.cos` * During sorting:`relational_query.sort.expression.scalar.cos` * During joining: `relational_query.join.expression.scalar.cos` * During aggregation: `relational_query.aggregate.expression.scalar.cos` * During windowing: `relational_query.window.expression.scalar.cos`.

func NewRelationalExpressionCos 

func NewRelationalExpressionCos[E RelationalExpressionInner](expr E) *RelationalExpressionCos

NewRelationalExpressionCos creates a RelationalExpressionCos instance.

func (RelationalExpressionCos) ToMap 

func (j RelationalExpressionCos) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionCos) Type 

func (j RelationalExpressionCos) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionCos) Wrap 

func (j RelationalExpressionCos) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionCount 

type RelationalExpressionCount struct {
	Expr RelationalExpression `json:"expr"     mapstructure:"expr"     yaml:"expr"`
	// Only used when in specific contexts where the appropriate capability is supported:
	// * During projection: `relational_query.project.expression.aggregate.count.distinct`
	// * During filtering: `relational_query.filter.aggregate.count.distinct`
	// * During sorting:`relational_query.sort.expression.aggregate.count.distinct`
	// * During joining: `relational_query.join.expression.aggregate.count.distinct`
	// * During aggregation: `relational_query.aggregate.expression.aggregate.count.distinct`
	// * During windowing: `relational_query.window.expression.aggregate.count.distinct`
	Distinct bool `json:"distinct" mapstructure:"distinct" yaml:"distinct"`
}

RelationalExpressionCount represents a RelationalExpression with the count type.

func NewRelationalExpressionCount 

func NewRelationalExpressionCount[E RelationalExpressionInner](
	expr E,
	distinct bool,
) *RelationalExpressionCount

NewRelationalExpressionCount creates a RelationalExpressionCount instance.

func (RelationalExpressionCount) ToMap 

func (j RelationalExpressionCount) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionCount) Type 

func (j RelationalExpressionCount) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionCount) Wrap 

func (j RelationalExpressionCount) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionCumeDist 

type RelationalExpressionCumeDist struct {
	OrderBy     []Sort                 `json:"order_by"     mapstructure:"order_by"     yaml:"order_by"`
	PartitionBy []RelationalExpression `json:"partition_by" mapstructure:"partition_by" yaml:"partition_by"`
}

RelationalExpressionCumeDist represents a RelationalExpression with the cume_dist type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.window.cume_dist` * During filtering: `relational_query.filter.window.cume_dist` * During sorting:`relational_query.sort.expression.window.cume_dist` * During joining: `relational_query.join.expression.window.cume_dist` * During aggregation: `relational_query.window.cume_dist` * During windowing: `relational_query.window.expression.window.cume_dist`.

func NewRelationalExpressionCumeDist 

func NewRelationalExpressionCumeDist(
	orderBy []Sort,
	partitionBy []RelationalExpressionInner,
) *RelationalExpressionCumeDist

NewRelationalExpressionCumeDist creates a RelationalExpressionCumeDist instance.

func (RelationalExpressionCumeDist) ToMap 

func (j RelationalExpressionCumeDist) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionCumeDist) Type 

func (j RelationalExpressionCumeDist) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionCumeDist) Wrap 

func (j RelationalExpressionCumeDist) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionCurrentDate 

type RelationalExpressionCurrentDate struct{}

RelationalExpressionCurrentDate represents a RelationalExpression with the current_date type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.current_date` * During filtering: `relational_query.filter.scalar.current_date` * During sorting:`relational_query.sort.expression.scalar.current_date` * During joining: `relational_query.join.expression.scalar.current_date` * During aggregation: `relational_query.aggregate.expression.scalar.current_date` * During windowing: `relational_query.window.expression.scalar.current_date`.

func NewRelationalExpressionCurrentDate 

func NewRelationalExpressionCurrentDate() *RelationalExpressionCurrentDate

NewRelationalExpressionCurrentDate creates a RelationalExpressionCurrentDate instance.

func (RelationalExpressionCurrentDate) ToMap 

func (j RelationalExpressionCurrentDate) ToMap() map[string]any

ToMap converts the instance to raw map.

func (RelationalExpressionCurrentDate) Type 

func (j RelationalExpressionCurrentDate) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionCurrentDate) Wrap 

func (j RelationalExpressionCurrentDate) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionCurrentTime 

type RelationalExpressionCurrentTime struct{}

RelationalExpressionCurrentTime represents a RelationalExpression with the current_time type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.current_time` * During filtering: `relational_query.filter.scalar.current_time` * During sorting:`relational_query.sort.expression.scalar.current_time` * During joining: `relational_query.join.expression.scalar.current_time` * During aggregation: `relational_query.aggregate.expression.scalar.current_time` * During windowing: `relational_query.window.expression.scalar.current_time`.

func NewRelationalExpressionCurrentTime 

func NewRelationalExpressionCurrentTime() *RelationalExpressionCurrentTime

NewRelationalExpressionCurrentTime creates a RelationalExpressionCurrentTime instance.

func (RelationalExpressionCurrentTime) ToMap 

func (j RelationalExpressionCurrentTime) ToMap() map[string]any

ToMap converts the instance to raw map.

func (RelationalExpressionCurrentTime) Type 

func (j RelationalExpressionCurrentTime) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionCurrentTime) Wrap 

func (j RelationalExpressionCurrentTime) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionCurrentTimestamp 

type RelationalExpressionCurrentTimestamp struct{}

RelationalExpressionCurrentTimestamp represents a RelationalExpression with the current_timestamp type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.current_timestamp` * During filtering: `relational_query.filter.scalar.current_timestamp` * During sorting:`relational_query.sort.expression.scalar.current_timestamp` * During joining: `relational_query.join.expression.scalar.current_timestamp` * During aggregation: `relational_query.aggregate.expression.scalar.current_timestamp` * During windowing: `relational_query.window.expression.scalar.current_timestamp`.

func NewRelationalExpressionCurrentTimestamp 

func NewRelationalExpressionCurrentTimestamp() *RelationalExpressionCurrentTimestamp

NewRelationalExpressionCurrentTimestamp creates a RelationalExpressionCurrentTime instance.

func (RelationalExpressionCurrentTimestamp) ToMap 

func (j RelationalExpressionCurrentTimestamp) ToMap() map[string]any

ToMap converts the instance to raw map.

func (RelationalExpressionCurrentTimestamp) Type 

func (j RelationalExpressionCurrentTimestamp) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionCurrentTimestamp) Wrap 

func (j RelationalExpressionCurrentTimestamp) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionDatePart 

type RelationalExpressionDatePart struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
	Part DatePartUnit         `json:"part" mapstructure:"part" yaml:"part"`
}

RelationalExpressionDatePart represents a RelationalExpression with the date_part type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.date_part` * During filtering: `relational_query.filter.scalar.date_part` * During sorting:`relational_query.sort.expression.scalar.date_part` * During joining: `relational_query.join.expression.scalar.date_part` * During aggregation: `relational_query.aggregate.expression.scalar.date_part` * During windowing: `relational_query.window.expression.scalar.date_part`.

func NewRelationalExpressionDatePart 

func NewRelationalExpressionDatePart[E RelationalExpressionInner](
	expr E,
	part DatePartUnit,
) *RelationalExpressionDatePart

NewRelationalExpressionDatePart creates a RelationalExpressionDatePart instance.

func (RelationalExpressionDatePart) ToMap 

func (j RelationalExpressionDatePart) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionDatePart) Type 

func (j RelationalExpressionDatePart) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionDatePart) Wrap 

func (j RelationalExpressionDatePart) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionDateTrunc 

type RelationalExpressionDateTrunc struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
	Part RelationalExpression `json:"part" mapstructure:"part" yaml:"part"`
}

RelationalExpressionDateTrunc represents a RelationalExpression with the date_trunc type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.date_trunc` * During filtering: `relational_query.filter.scalar.date_trunc` * During sorting:`relational_query.sort.expression.scalar.date_trunc` * During joining: `relational_query.join.expression.scalar.date_trunc` * During aggregation: `relational_query.aggregate.expression.scalar.date_trunc` * During windowing: `relational_query.window.expression.scalar.date_trunc`.

func NewRelationalExpressionDateTrunc 

func NewRelationalExpressionDateTrunc[E RelationalExpressionInner, R RelationalExpressionInner](
	expr E,
	part R,
) *RelationalExpressionDateTrunc

NewRelationalExpressionDateTrunc creates a RelationalExpressionDateTrunc instance.

func (RelationalExpressionDateTrunc) ToMap 

func (j RelationalExpressionDateTrunc) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionDateTrunc) Type 

func (j RelationalExpressionDateTrunc) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionDateTrunc) Wrap 

func (j RelationalExpressionDateTrunc) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionDenseRank 

type RelationalExpressionDenseRank struct {
	OrderBy     []Sort                 `json:"order_by"     mapstructure:"order_by"     yaml:"order_by"`
	PartitionBy []RelationalExpression `json:"partition_by" mapstructure:"partition_by" yaml:"partition_by"`
}

RelationalExpressionDenseRank represents a RelationalExpression with the dense_rank type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.window.dense_rank` * During filtering: `relational_query.filter.window.dense_rank` * During sorting:`relational_query.sort.expression.window.dense_rank` * During joining: `relational_query.join.expression.window.dense_rank` * During aggregation: `relational_query.window.dense_rank` * During windowing: `relational_query.window.expression.window.dense_rank`.

func NewRelationalExpressionDenseRank 

func NewRelationalExpressionDenseRank(
	orderBy []Sort,
	partitionBy []RelationalExpressionInner,
) *RelationalExpressionDenseRank

NewRelationalExpressionDenseRank creates a RelationalExpressionDenseRank instance.

func (RelationalExpressionDenseRank) ToMap 

func (j RelationalExpressionDenseRank) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionDenseRank) Type 

func (j RelationalExpressionDenseRank) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionDenseRank) Wrap 

func (j RelationalExpressionDenseRank) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionDivide 

type RelationalExpressionDivide struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionDivide represents a RelationalExpression with the divide type.

func NewRelationalExpressionDivide 

func NewRelationalExpressionDivide[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionDivide

NewRelationalExpressionDivide creates a RelationalExpressionDivide instance.

func (RelationalExpressionDivide) ToMap 

func (j RelationalExpressionDivide) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionDivide) Type 

func (j RelationalExpressionDivide) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionDivide) Wrap 

func (j RelationalExpressionDivide) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionEq 

type RelationalExpressionEq struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionEq represents a RelationalExpression with the eq type.

func NewRelationalExpressionEq 

func NewRelationalExpressionEq[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionEq

NewRelationalExpressionEq creates a RelationalExpressionEq instance.

func (RelationalExpressionEq) ToMap 

func (j RelationalExpressionEq) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionEq) Type 

func (j RelationalExpressionEq) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionEq) Wrap 

func (j RelationalExpressionEq) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionExp 

type RelationalExpressionExp struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionExp represents a RelationalExpression with the exp type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.exp` * During filtering: `relational_query.filter.scalar.exp` * During sorting:`relational_query.sort.expression.scalar.exp` * During joining: `relational_query.join.expression.scalar.exp` * During aggregation: `relational_query.aggregate.expression.scalar.exp` * During windowing: `relational_query.window.expression.scalar.exp`.

func NewRelationalExpressionExp 

func NewRelationalExpressionExp[E RelationalExpressionInner](expr E) *RelationalExpressionExp

NewRelationalExpressionExp creates a RelationalExpressionExp instance.

func (RelationalExpressionExp) ToMap 

func (j RelationalExpressionExp) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionExp) Type 

func (j RelationalExpressionExp) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionExp) Wrap 

func (j RelationalExpressionExp) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionFirstValue 

type RelationalExpressionFirstValue struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionFirstValue represents a RelationalExpression with the first_value type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.aggregate.first_value` * During filtering: `relational_query.filter.aggregate.first_value` * During sorting:`relational_query.sort.expression.aggregate.first_value` * During joining: `relational_query.join.expression.aggregate.first_value` * During aggregation: `relational_query.aggregate.expression.aggregate.first_value` * During windowing: `relational_query.window.expression.aggregate.first_value`.

func NewRelationalExpressionFirstValue 

func NewRelationalExpressionFirstValue[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionFirstValue

NewRelationalExpressionFirstValue creates a RelationalExpressionFirstValue instance.

func (RelationalExpressionFirstValue) ToMap 

func (j RelationalExpressionFirstValue) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionFirstValue) Type 

func (j RelationalExpressionFirstValue) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionFirstValue) Wrap 

func (j RelationalExpressionFirstValue) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionFloor 

type RelationalExpressionFloor struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionFloor represents a RelationalExpression with the floor type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.floor` * During filtering: `relational_query.filter.scalar.floor` * During sorting:`relational_query.sort.expression.scalar.floor` * During joining: `relational_query.join.expression.scalar.floor` * During aggregation: `relational_query.aggregate.expression.scalar.floor` * During windowing: `relational_query.window.expression.scalar.floor`.

func NewRelationalExpressionFloor 

func NewRelationalExpressionFloor[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionFloor

NewRelationalExpressionFloor creates a RelationalExpressionFloor instance.

func (RelationalExpressionFloor) ToMap 

func (j RelationalExpressionFloor) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionFloor) Type 

func (j RelationalExpressionFloor) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionFloor) Wrap 

func (j RelationalExpressionFloor) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionGetField 

type RelationalExpressionGetField struct {
	Column RelationalExpression `json:"column" mapstructure:"column" yaml:"column"`
	Field  string               `json:"field"  mapstructure:"field"  yaml:"field"`
}

RelationalExpressionGetField represents a RelationalExpression with the get_field type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.get_field` * During filtering: `relational_query.filter.scalar.get_field` * During sorting:`relational_query.sort.expression.scalar.get_field` * During joining: `relational_query.join.expression.scalar.get_field` * During aggregation: `relational_query.aggregate.expression.scalar.get_field` * During windowing: `relational_query.window.expression.scalar.get_field`.

func NewRelationalExpressionGetField 

func NewRelationalExpressionGetField[E RelationalExpressionInner](
	column E,
	field string,
) *RelationalExpressionGetField

NewRelationalExpressionGetField creates a RelationalExpressionGetField instance.

func (RelationalExpressionGetField) ToMap 

func (j RelationalExpressionGetField) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionGetField) Type 

func (j RelationalExpressionGetField) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionGetField) Wrap 

func (j RelationalExpressionGetField) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionGreatest 

type RelationalExpressionGreatest struct {
	Exprs []RelationalExpression `json:"exprs" mapstructure:"exprs" yaml:"exprs"`
}

RelationalExpressionGreatest represents a RelationalExpression with the greatest type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.greatest` * During filtering: `relational_query.filter.scalar.greatest` * During sorting:`relational_query.sort.expression.scalar.greatest` * During joining: `relational_query.join.expression.scalar.greatest` * During aggregation: `relational_query.aggregate.expression.scalar.greatest` * During windowing: `relational_query.window.expression.scalar.greatest`.

func NewRelationalExpressionGreatest 

func NewRelationalExpressionGreatest(
	expressions []RelationalExpressionInner,
) *RelationalExpressionGreatest

NewRelationalExpressionGreatest creates a RelationalExpressionGreatest instance.

func (RelationalExpressionGreatest) ToMap 

func (j RelationalExpressionGreatest) ToMap() map[string]any

ToMap converts the instance to raw map.

func (RelationalExpressionGreatest) Type 

func (j RelationalExpressionGreatest) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionGreatest) Wrap 

func (j RelationalExpressionGreatest) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionGt 

type RelationalExpressionGt struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionGt represents a RelationalExpression with the gt type.

func NewRelationalExpressionGt 

func NewRelationalExpressionGt[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionGt

NewRelationalExpressionGt creates a RelationalExpressionGt instance.

func (RelationalExpressionGt) ToMap 

func (j RelationalExpressionGt) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionGt) Type 

func (j RelationalExpressionGt) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionGt) Wrap 

func (j RelationalExpressionGt) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionGtEq 

type RelationalExpressionGtEq struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionGtEq represents a RelationalExpression with the gt_eq type.

func NewRelationalExpressionGtEq 

func NewRelationalExpressionGtEq[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionGtEq

NewRelationalExpressionGtEq creates a RelationalExpressionGtEq instance.

func (RelationalExpressionGtEq) ToMap 

func (j RelationalExpressionGtEq) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionGtEq) Type 

func (j RelationalExpressionGtEq) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionGtEq) Wrap 

func (j RelationalExpressionGtEq) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionILike 

type RelationalExpressionILike struct {
	Expr    RelationalExpression `json:"expr"    mapstructure:"expr"    yaml:"expr"`
	Pattern RelationalExpression `json:"pattern" mapstructure:"pattern" yaml:"pattern"`
}

RelationalExpressionILike represents a RelationalExpression with the i_like type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.comparison.ilike` * During filtering: `relational_query.filter.comparison.ilike` * During sorting:`relational_query.sort.expression.comparison.ilike` * During joining: `relational_query.join.expression.comparison.ilike` * During aggregation: `relational_query.aggregate.expression.comparison.ilike` * During windowing: `relational_query.window.expression.comparison.ilike`.

func NewRelationalExpressionILike 

func NewRelationalExpressionILike[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionILike

NewRelationalExpressionILike creates a RelationalExpressionILike instance.

func (RelationalExpressionILike) ToMap 

func (j RelationalExpressionILike) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionILike) Type 

func (j RelationalExpressionILike) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionILike) Wrap 

func (j RelationalExpressionILike) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionIn 

type RelationalExpressionIn struct {
	Expr RelationalExpression   `json:"expr" mapstructure:"expr" yaml:"expr"`
	List []RelationalExpression `json:"list" mapstructure:"list" yaml:"list"`
}

RelationalExpressionIn represents a RelationalExpression with the in type.

func NewRelationalExpressionIn 

func NewRelationalExpressionIn[E RelationalExpressionInner](
	expr E,
	list []RelationalExpressionInner,
) *RelationalExpressionIn

NewRelationalExpressionIn creates a RelationalExpressionIn instance.

func (RelationalExpressionIn) ToMap 

func (j RelationalExpressionIn) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionIn) Type 

func (j RelationalExpressionIn) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionIn) Wrap 

func (j RelationalExpressionIn) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionInner 

type RelationalExpressionInner interface {
	Type() RelationalExpressionType
	ToMap() map[string]any
	Wrap() RelationalExpression
}

RelationalExpressionInner abstracts the interface for RelationalExpression.

type RelationalExpressionIsDistinctFrom 

type RelationalExpressionIsDistinctFrom struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionIsDistinctFrom represents a RelationalExpression with the is_distinct_from type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.comparison.is_distinct_from` * During filtering: `relational_query.filter.comparison.is_distinct_from` * During sorting:`relational_query.sort.expression.comparison.is_distinct_from` * During joining: `relational_query.join.expression.comparison.is_distinct_from` * During aggregation: `relational_query.aggregate.expression.comparison.is_distinct_from` * During windowing: `relational_query.window.expression.comparison.is_distinct_from`.

func NewRelationalExpressionIsDistinctFrom 

func NewRelationalExpressionIsDistinctFrom[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionIsDistinctFrom

NewRelationalExpressionIsDistinctFrom creates a RelationalExpressionIsDistinctFrom instance.

func (RelationalExpressionIsDistinctFrom) ToMap 

func (j RelationalExpressionIsDistinctFrom) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionIsDistinctFrom) Type 

func (j RelationalExpressionIsDistinctFrom) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionIsDistinctFrom) Wrap 

func (j RelationalExpressionIsDistinctFrom) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionIsFalse 

type RelationalExpressionIsFalse struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionIsFalse represents a RelationalExpression with the is_false type.

func NewRelationalExpressionIsFalse 

func NewRelationalExpressionIsFalse[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionIsFalse

NewRelationalExpressionIsFalse creates a RelationalExpressionIsFalse instance.

func (RelationalExpressionIsFalse) ToMap 

func (j RelationalExpressionIsFalse) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionIsFalse) Type 

func (j RelationalExpressionIsFalse) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionIsFalse) Wrap 

func (j RelationalExpressionIsFalse) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionIsNaN 

type RelationalExpressionIsNaN struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionIsNaN represents a RelationalExpression with the is_na_n type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.comparison.is_nan` * During filtering: `relational_query.filter.comparison.is_nan` * During sorting:`relational_query.sort.expression.comparison.is_nan` * During joining: `relational_query.join.expression.comparison.is_nan` * During aggregation: `relational_query.aggregate.expression.comparison.is_nan` * During windowing: `relational_query.window.expression.comparison.is_nan`.

func NewRelationalExpressionIsNaN 

func NewRelationalExpressionIsNaN[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionIsNaN

NewRelationalExpressionIsNaN creates a RelationalExpressionIsNaN instance.

func (RelationalExpressionIsNaN) ToMap 

func (j RelationalExpressionIsNaN) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionIsNaN) Type 

func (j RelationalExpressionIsNaN) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionIsNaN) Wrap 

func (j RelationalExpressionIsNaN) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionIsNotDistinctFrom 

type RelationalExpressionIsNotDistinctFrom struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionIsNotDistinctFrom represents a RelationalExpression with the is_not_distinct_from type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.comparison.is_not_distinct_from` * During filtering: `relational_query.filter.comparison.is_not_distinct_from` * During sorting:`relational_query.sort.expression.comparison.is_not_distinct_from` * During joining: `relational_query.join.expression.comparison.is_not_distinct_from` * During aggregation: `relational_query.aggregate.expression.comparison.is_not_distinct_from` * During windowing: `relational_query.window.expression.comparison.is_not_distinct_from`.

func NewRelationalExpressionIsNotDistinctFrom 

func NewRelationalExpressionIsNotDistinctFrom[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionIsNotDistinctFrom

NewRelationalExpressionIsDistinctFrom creates a RelationalExpressionIsDistinctFrom instance.

func (RelationalExpressionIsNotDistinctFrom) ToMap 

func (j RelationalExpressionIsNotDistinctFrom) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionIsNotDistinctFrom) Type 

func (j RelationalExpressionIsNotDistinctFrom) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionIsNotDistinctFrom) Wrap 

func (j RelationalExpressionIsNotDistinctFrom) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionIsNotFalse 

type RelationalExpressionIsNotFalse struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionIsNotFalse represents a RelationalExpression with the is_not_false type.

func NewRelationalExpressionIsNotFalse 

func NewRelationalExpressionIsNotFalse[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionIsNotFalse

NewRelationalExpressionIsNotFalse creates a RelationalExpressionIsNotFalse instance.

func (RelationalExpressionIsNotFalse) ToMap 

func (j RelationalExpressionIsNotFalse) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionIsNotFalse) Type 

func (j RelationalExpressionIsNotFalse) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionIsNotFalse) Wrap 

func (j RelationalExpressionIsNotFalse) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionIsNotNull 

type RelationalExpressionIsNotNull struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionIsNotNull represents a RelationalExpression with the is_not_null type.

func NewRelationalExpressionIsNotNull 

func NewRelationalExpressionIsNotNull[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionIsNotNull

NewRelationalExpressionIsNotNull creates a RelationalExpressionIsNotNull instance.

func (RelationalExpressionIsNotNull) ToMap 

func (j RelationalExpressionIsNotNull) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionIsNotNull) Type 

func (j RelationalExpressionIsNotNull) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionIsNotNull) Wrap 

func (j RelationalExpressionIsNotNull) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionIsNotTrue 

type RelationalExpressionIsNotTrue struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionIsNotTrue represents a RelationalExpression with the is_not_true type.

func NewRelationalExpressionIsNotTrue 

func NewRelationalExpressionIsNotTrue[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionIsNotTrue

NewRelationalExpressionIsNotTrue creates a RelationalExpressionIsNotTrue instance.

func (RelationalExpressionIsNotTrue) ToMap 

func (j RelationalExpressionIsNotTrue) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionIsNotTrue) Type 

func (j RelationalExpressionIsNotTrue) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionIsNotTrue) Wrap 

func (j RelationalExpressionIsNotTrue) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionIsNull 

type RelationalExpressionIsNull struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionIsNull represents a RelationalExpression with the is_null type.

func NewRelationalExpressionIsNull 

func NewRelationalExpressionIsNull[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionIsNull

NewRelationalExpressionIsNull creates a RelationalExpressionIsNull instance.

func (RelationalExpressionIsNull) ToMap 

func (j RelationalExpressionIsNull) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionIsNull) Type 

func (j RelationalExpressionIsNull) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionIsNull) Wrap 

func (j RelationalExpressionIsNull) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionIsTrue 

type RelationalExpressionIsTrue struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionIsTrue represents a RelationalExpression with the is_true type.

func NewRelationalExpressionIsTrue 

func NewRelationalExpressionIsTrue[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionIsTrue

NewRelationalExpressionIsTrue creates a RelationalExpressionIsTrue instance.

func (RelationalExpressionIsTrue) ToMap 

func (j RelationalExpressionIsTrue) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionIsTrue) Type 

func (j RelationalExpressionIsTrue) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionIsTrue) Wrap 

func (j RelationalExpressionIsTrue) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionIsZero 

type RelationalExpressionIsZero struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionIsZero represents a RelationalExpression with the is_zero type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.comparison.is_zero` * During filtering: `relational_query.filter.comparison.is_zero` * During sorting:`relational_query.sort.expression.comparison.is_zero` * During joining: `relational_query.join.expression.comparison.is_zero` * During aggregation: `relational_query.aggregate.expression.comparison.is_zero` * During windowing: `relational_query.window.expression.comparison.is_zero.

func NewRelationalExpressionIsZero 

func NewRelationalExpressionIsZero[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionIsZero

NewRelationalExpressionIsZero creates a RelationalExpressionIsZero instance.

func (RelationalExpressionIsZero) ToMap 

func (j RelationalExpressionIsZero) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionIsZero) Type 

func (j RelationalExpressionIsZero) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionIsZero) Wrap 

func (j RelationalExpressionIsZero) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionLPad 

type RelationalExpressionLPad struct {
	Str        RelationalExpression  `json:"str"                   mapstructure:"str"                   yaml:"str"`
	N          RelationalExpression  `json:"n"                     mapstructure:"n"                     yaml:"n"`
	PaddingStr *RelationalExpression `json:"padding_str,omitempty" mapstructure:"padding_str,omitempty" yaml:"padding_str,omitempty"`
}

RelationalExpressionLPad represents a RelationalExpression with the l_pad type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.lpad` * During filtering: `relational_query.filter.scalar.lpad` * During sorting:`relational_query.sort.expression.scalar.lpad` * During joining: `relational_query.join.expression.scalar.lpad` * During aggregation: `relational_query.aggregate.expression.scalar.lpad` * During windowing: `relational_query.window.expression.scalar.lpad`.

func NewRelationalExpressionLPad 

func NewRelationalExpressionLPad[E RelationalExpressionInner, N RelationalExpressionInner](
	str E,
	n N,
) *RelationalExpressionLPad

NewRelationalExpressionLPad creates a RelationalExpressionLPad instance.

func (RelationalExpressionLPad) ToMap 

func (j RelationalExpressionLPad) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionLPad) Type 

func (j RelationalExpressionLPad) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionLPad) WithPaddingStr 

func (j RelationalExpressionLPad) WithPaddingStr(
	paddingStr RelationalExpressionInner,
) *RelationalExpressionLPad

WithPaddingStr returns the new instance with padding str set.

func (RelationalExpressionLPad) Wrap 

func (j RelationalExpressionLPad) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionLTrim 

type RelationalExpressionLTrim struct {
	Str     RelationalExpression  `json:"str"                mapstructure:"str"                yaml:"str"`
	TrimStr *RelationalExpression `json:"trim_str,omitempty" mapstructure:"trim_str,omitempty" yaml:"trim_str,omitempty"`
}

RelationalExpressionLTrim represents a RelationalExpression with the l_trim type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.ltrim` * During filtering: `relational_query.filter.scalar.ltrim` * During sorting:`relational_query.sort.expression.scalar.ltrim` * During joining: `relational_query.join.expression.scalar.ltrim` * During aggregation: `relational_query.aggregate.expression.scalar.ltrim` * During windowing: `relational_query.window.expression.scalar.ltrim`.

func NewRelationalExpressionLTrim 

func NewRelationalExpressionLTrim[E RelationalExpressionInner](str E) *RelationalExpressionLTrim

NewRelationalExpressionLTrim creates a RelationalExpressionLTrim instance.

func (RelationalExpressionLTrim) ToMap 

func (j RelationalExpressionLTrim) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionLTrim) Type 

func (j RelationalExpressionLTrim) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionLTrim) WithTrimStr 

func (j RelationalExpressionLTrim) WithTrimStr(
	trimStr RelationalExpressionInner,
) *RelationalExpressionLTrim

WithTrimStr returns the new instance with trim str set.

func (RelationalExpressionLTrim) Wrap 

func (j RelationalExpressionLTrim) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionLastValue 

type RelationalExpressionLastValue struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionLastValue represents a RelationalExpression with the last_value type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.aggregate.last_value` * During filtering: `relational_query.filter.aggregate.last_value` * During sorting:`relational_query.sort.expression.aggregate.last_value` * During joining: `relational_query.join.expression.aggregate.last_value` * During aggregation: `relational_query.aggregate.expression.aggregate.last_value` * During windowing: `relational_query.window.expression.aggregate.last_value`.

func NewRelationalExpressionLastValue 

func NewRelationalExpressionLastValue[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionLastValue

NewRelationalExpressionLastValue creates a RelationalExpressionLastValue instance.

func (RelationalExpressionLastValue) ToMap 

func (j RelationalExpressionLastValue) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionLastValue) Type 

func (j RelationalExpressionLastValue) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionLastValue) Wrap 

func (j RelationalExpressionLastValue) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionLeast 

type RelationalExpressionLeast struct {
	Exprs []RelationalExpression `json:"least" mapstructure:"least" yaml:"least"`
}

RelationalExpressionLeast represents a RelationalExpression with the least type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.least` * During filtering: `relational_query.filter.scalar.least` * During sorting:`relational_query.sort.expression.scalar.least` * During joining: `relational_query.join.expression.scalar.least` * During aggregation: `relational_query.aggregate.expression.scalar.least` * During windowing: `relational_query.window.expression.scalar.least`.

func NewRelationalExpressionLeast 

func NewRelationalExpressionLeast(
	expressions []RelationalExpressionInner,
) *RelationalExpressionLeast

NewRelationalExpressionLeast creates a RelationalExpressionLeast instance.

func (RelationalExpressionLeast) ToMap 

func (j RelationalExpressionLeast) ToMap() map[string]any

ToMap converts the instance to raw map.

func (RelationalExpressionLeast) Type 

func (j RelationalExpressionLeast) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionLeast) Wrap 

func (j RelationalExpressionLeast) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionLeft 

type RelationalExpressionLeft struct {
	Str RelationalExpression `json:"str" mapstructure:"str" yaml:"str"`
	N   RelationalExpression `json:"n"   mapstructure:"n"   yaml:"n"`
}

RelationalExpressionLeft represents a RelationalExpression with the left type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.left` * During filtering: `relational_query.filter.scalar.left` * During sorting:`relational_query.sort.expression.scalar.left` * During joining: `relational_query.join.expression.scalar.left` * During aggregation: `relational_query.aggregate.expression.scalar.left` * During windowing: `relational_query.window.expression.scalar.left`.

func NewRelationalExpressionLeft 

func NewRelationalExpressionLeft[E RelationalExpressionInner, N RelationalExpressionInner](
	str E,
	n N,
) *RelationalExpressionLeft

NewRelationalExpressionLeft creates a RelationalExpressionLeft instance.

func (RelationalExpressionLeft) ToMap 

func (j RelationalExpressionLeft) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionLeft) Type 

func (j RelationalExpressionLeft) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionLeft) Wrap 

func (j RelationalExpressionLeft) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionLike 

type RelationalExpressionLike struct {
	Expr    RelationalExpression `json:"expr"    mapstructure:"expr"    yaml:"expr"`
	Pattern RelationalExpression `json:"pattern" mapstructure:"pattern" yaml:"pattern"`
}

RelationalExpressionLike represents a RelationalExpression with the like type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.comparison.like` * During filtering: `relational_query.filter.comparison.like` * During sorting:`relational_query.sort.expression.comparison.like` * During joining: `relational_query.join.expression.comparison.like` * During aggregation: `relational_query.aggregate.expression.comparison.like` * During windowing: `relational_query.window.expression.comparison.like`.

func NewRelationalExpressionLike 

func NewRelationalExpressionLike[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionLike

NewRelationalExpressionLike creates a RelationalExpressionLike instance.

func (RelationalExpressionLike) ToMap 

func (j RelationalExpressionLike) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionLike) Type 

func (j RelationalExpressionLike) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionLike) Wrap 

func (j RelationalExpressionLike) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionLiteral 

type RelationalExpressionLiteral struct {
	Literal RelationalLiteral `json:"literal" mapstructure:"literal" yaml:"literal"`
}

RelationalExpressionLiteral represents a RelationalExpression with literal value.

func NewRelationalExpressionLiteral 

func NewRelationalExpressionLiteral[R RelationalLiteralInner](
	literal R,
) *RelationalExpressionLiteral

NewRelationalExpressionLiteral creates a RelationalExpressionLiteral instance.

func (RelationalExpressionLiteral) ToMap 

func (j RelationalExpressionLiteral) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionLiteral) Type 

func (j RelationalExpressionLiteral) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionLiteral) Wrap 

func (j RelationalExpressionLiteral) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionLn 

type RelationalExpressionLn struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionLn represents a RelationalExpression with the ln type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.ln` * During filtering: `relational_query.filter.scalar.ln` * During sorting:`relational_query.sort.expression.scalar.ln` * During joining: `relational_query.join.expression.scalar.ln` * During aggregation: `relational_query.aggregate.expression.scalar.ln` * During windowing: `relational_query.window.expression.scalar.ln`.

func NewRelationalExpressionLn 

func NewRelationalExpressionLn[E RelationalExpressionInner](expr E) *RelationalExpressionLn

NewRelationalExpressionLn creates a RelationalExpressionLn instance.

func (RelationalExpressionLn) ToMap 

func (j RelationalExpressionLn) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionLn) Type 

func (j RelationalExpressionLn) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionLn) Wrap 

func (j RelationalExpressionLn) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionLog 

type RelationalExpressionLog struct {
	Expr RelationalExpression  `json:"expr"           mapstructure:"expr"           yaml:"expr"`
	Base *RelationalExpression `json:"base,omitempty" mapstructure:"base,omitempty" yaml:"base,omitempty"`
}

RelationalExpressionLog represents a RelationalExpression with the log type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.log` * During filtering: `relational_query.filter.scalar.log` * During sorting:`relational_query.sort.expression.scalar.log` * During joining: `relational_query.join.expression.scalar.log` * During aggregation: `relational_query.aggregate.expression.scalar.log` * During windowing: `relational_query.window.expression.scalar.log`.

func NewRelationalExpressionLog 

func NewRelationalExpressionLog[E RelationalExpressionInner](expr E) *RelationalExpressionLog

NewRelationalExpressionLog creates a RelationalExpressionLog instance.

func (RelationalExpressionLog) ToMap 

func (j RelationalExpressionLog) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionLog) Type 

func (j RelationalExpressionLog) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionLog) WithBase 

func (j RelationalExpressionLog) WithBase(
	base RelationalExpressionInner,
) *RelationalExpressionLog

WithBase return the instance with a new base set.

func (RelationalExpressionLog) Wrap 

func (j RelationalExpressionLog) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionLog2 

type RelationalExpressionLog2 struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionLog2 represents a RelationalExpression with the log2 type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.log2` * During filtering: `relational_query.filter.scalar.log2` * During sorting:`relational_query.sort.expression.scalar.log2` * During joining: `relational_query.join.expression.scalar.log2` * During aggregation: `relational_query.aggregate.expression.scalar.log2` * During windowing: `relational_query.window.expression.scalar.log2`.

func NewRelationalExpressionLog2 

func NewRelationalExpressionLog2[E RelationalExpressionInner](expr E) *RelationalExpressionLog2

NewRelationalExpressionLog2 creates a RelationalExpressionLog2 instance.

func (RelationalExpressionLog2) ToMap 

func (j RelationalExpressionLog2) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionLog2) Type 

func (j RelationalExpressionLog2) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionLog2) Wrap 

func (j RelationalExpressionLog2) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionLog10 

type RelationalExpressionLog10 struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionLog10 represents a RelationalExpression with the log10 type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.log10` * During filtering: `relational_query.filter.scalar.log10` * During sorting:`relational_query.sort.expression.scalar.log10` * During joining: `relational_query.join.expression.scalar.log10` * During aggregation: `relational_query.aggregate.expression.scalar.log10` * During windowing: `relational_query.window.expression.scalar.log10`.

func NewRelationalExpressionLog10 

func NewRelationalExpressionLog10[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionLog10

NewRelationalExpressionLog10 creates a RelationalExpressionLog10 instance.

func (RelationalExpressionLog10) ToMap 

func (j RelationalExpressionLog10) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionLog10) Type 

func (j RelationalExpressionLog10) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionLog10) Wrap 

func (j RelationalExpressionLog10) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionLt 

type RelationalExpressionLt struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionLt represents a RelationalExpression with the lt type.

func NewRelationalExpressionLt 

func NewRelationalExpressionLt[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionLt

NewRelationalExpressionLt creates a RelationalExpressionLt instance.

func (RelationalExpressionLt) ToMap 

func (j RelationalExpressionLt) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionLt) Type 

func (j RelationalExpressionLt) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionLt) Wrap 

func (j RelationalExpressionLt) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionLtEq 

type RelationalExpressionLtEq struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionLtEq represents a RelationalExpression with the lt_eq type.

func NewRelationalExpressionLtEq 

func NewRelationalExpressionLtEq[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionLtEq

NewRelationalExpressionLtEq creates a RelationalExpressionLtEq instance.

func (RelationalExpressionLtEq) ToMap 

func (j RelationalExpressionLtEq) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionLtEq) Type 

func (j RelationalExpressionLtEq) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionLtEq) Wrap 

func (j RelationalExpressionLtEq) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionMax 

type RelationalExpressionMax struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionMax represents a RelationalExpression with the max type.

func NewRelationalExpressionMax 

func NewRelationalExpressionMax[E RelationalExpressionInner](expr E) *RelationalExpressionMax

NewRelationalExpressionMax creates a RelationalExpressionMax instance.

func (RelationalExpressionMax) ToMap 

func (j RelationalExpressionMax) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionMax) Type 

func (j RelationalExpressionMax) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionMax) Wrap 

func (j RelationalExpressionMax) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionMedian 

type RelationalExpressionMedian struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionMedian represents a RelationalExpression with the median type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.aggregate.median` * During filtering: `relational_query.filter.aggregate.median` * During sorting:`relational_query.sort.expression.aggregate.median` * During joining: `relational_query.join.expression.aggregate.median` * During aggregation: `relational_query.aggregate.expression.aggregate.median` * During windowing: `relational_query.window.expression.aggregate.median`.

func NewRelationalExpressionMedian 

func NewRelationalExpressionMedian[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionMedian

NewRelationalExpressionMedian creates a RelationalExpressionMedian instance.

func (RelationalExpressionMedian) ToMap 

func (j RelationalExpressionMedian) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionMedian) Type 

func (j RelationalExpressionMedian) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionMedian) Wrap 

func (j RelationalExpressionMedian) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionMin 

type RelationalExpressionMin struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionMin represents a RelationalExpression with the min type.

func NewRelationalExpressionMin 

func NewRelationalExpressionMin[E RelationalExpressionInner](expr E) *RelationalExpressionMin

NewRelationalExpressionMin creates a RelationalExpressionMin instance.

func (RelationalExpressionMin) ToMap 

func (j RelationalExpressionMin) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionMin) Type 

func (j RelationalExpressionMin) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionMin) Wrap 

func (j RelationalExpressionMin) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionMinus 

type RelationalExpressionMinus struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionMinus represents a RelationalExpression with the minus type.

func NewRelationalExpressionMinus 

func NewRelationalExpressionMinus[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionMinus

NewRelationalExpressionMinus creates a RelationalExpressionMinus instance.

func (RelationalExpressionMinus) ToMap 

func (j RelationalExpressionMinus) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionMinus) Type 

func (j RelationalExpressionMinus) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionMinus) Wrap 

func (j RelationalExpressionMinus) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionModulo 

type RelationalExpressionModulo struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionModulo represents a RelationalExpression with the modulo type.

func NewRelationalExpressionModulo 

func NewRelationalExpressionModulo[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionModulo

NewRelationalExpressionModulo creates a RelationalExpressionModulo instance.

func (RelationalExpressionModulo) ToMap 

func (j RelationalExpressionModulo) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionModulo) Type 

func (j RelationalExpressionModulo) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionModulo) Wrap 

func (j RelationalExpressionModulo) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionMultiply 

type RelationalExpressionMultiply struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionMultiply represents a RelationalExpression with the multiply type.

func NewRelationalExpressionMultiply 

func NewRelationalExpressionMultiply[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionMultiply

NewRelationalExpressionMultiply creates a RelationalExpressionMultiply instance.

func (RelationalExpressionMultiply) ToMap 

func (j RelationalExpressionMultiply) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionMultiply) Type 

func (j RelationalExpressionMultiply) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionMultiply) Wrap 

func (j RelationalExpressionMultiply) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionNTile 

type RelationalExpressionNTile struct {
	OrderBy     []Sort                 `json:"order_by"     mapstructure:"order_by"     yaml:"order_by"`
	PartitionBy []RelationalExpression `json:"partition_by" mapstructure:"partition_by" yaml:"partition_by"`
	N           int64                  `json:"n"            mapstructure:"n"            yaml:"n"`
}

RelationalExpressionNTile represents a RelationalExpression with the ntile type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.window.ntile` * During filtering: `relational_query.filter.window.ntile` * During sorting:`relational_query.sort.expression.window.ntile` * During joining: `relational_query.join.expression.window.ntile` * During aggregation: `relational_query.window.ntile` * During windowing: `relational_query.window.expression.window.ntile`.

func NewRelationalExpressionNTile 

func NewRelationalExpressionNTile(
	orderBy []Sort,
	partitionBy []RelationalExpressionInner,
	n int64,
) *RelationalExpressionNTile

NewRelationalExpressionNTile creates a RelationalExpressionNTile instance.

func (RelationalExpressionNTile) ToMap 

func (j RelationalExpressionNTile) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionNTile) Type 

func (j RelationalExpressionNTile) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionNTile) Wrap 

func (j RelationalExpressionNTile) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionNegate 

type RelationalExpressionNegate struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionNegate represents a RelationalExpression with the negate type.

func NewRelationalExpressionNegate 

func NewRelationalExpressionNegate[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionNegate

NewRelationalExpressionNegate creates a RelationalExpressionNegate instance.

func (RelationalExpressionNegate) ToMap 

func (j RelationalExpressionNegate) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionNegate) Type 

func (j RelationalExpressionNegate) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionNegate) Wrap 

func (j RelationalExpressionNegate) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionNot 

type RelationalExpressionNot struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionNot represents a RelationalExpression with the not type.

func NewRelationalExpressionNot 

func NewRelationalExpressionNot[E RelationalExpressionInner](expr E) *RelationalExpressionNot

NewRelationalExpressionNot creates a RelationalExpressionNot instance.

func (RelationalExpressionNot) ToMap 

func (j RelationalExpressionNot) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionNot) Type 

func (j RelationalExpressionNot) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionNot) Wrap 

func (j RelationalExpressionNot) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionNotBetween 

type RelationalExpressionNotBetween struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
	Low  RelationalExpression `json:"low"  mapstructure:"low"  yaml:"low"`
	High RelationalExpression `json:"high" mapstructure:"high" yaml:"high"`
}

RelationalExpressionNotBetween represents a RelationalExpression with the not_between type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.comparison.between` * During filtering: `relational_query.filter.comparison.between` * During sorting:`relational_query.sort.expression.comparison.between` * During joining: `relational_query.join.expression.comparison.between` * During aggregation: `relational_query.aggregate.expression.comparison.between` * During windowing: `relational_query.window.expression.comparison.between`.

func NewRelationalExpressionNotBetween 

func NewRelationalExpressionNotBetween[E RelationalExpressionInner, L RelationalExpressionInner, H RelationalExpressionInner](
	expr E,
	low L,
	high H,
) *RelationalExpressionNotBetween

NewRelationalExpressionNotBetween creates a RelationalExpressionNotBetween instance.

func (RelationalExpressionNotBetween) ToMap 

func (j RelationalExpressionNotBetween) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionNotBetween) Type 

func (j RelationalExpressionNotBetween) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionNotBetween) Wrap 

func (j RelationalExpressionNotBetween) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionNotEq 

type RelationalExpressionNotEq struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionNotEq represents a RelationalExpression with the not_eq type.

func NewRelationalExpressionNotEq 

func NewRelationalExpressionNotEq[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionNotEq

NewRelationalExpressionNotEq creates a RelationalExpressionNotEq instance.

func (RelationalExpressionNotEq) ToMap 

func (j RelationalExpressionNotEq) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionNotEq) Type 

func (j RelationalExpressionNotEq) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionNotEq) Wrap 

func (j RelationalExpressionNotEq) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionNotILike 

type RelationalExpressionNotILike struct {
	Expr    RelationalExpression `json:"expr"    mapstructure:"expr"    yaml:"expr"`
	Pattern RelationalExpression `json:"pattern" mapstructure:"pattern" yaml:"pattern"`
}

RelationalExpressionNotILike represents a RelationalExpression with the not_i_like type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.comparison.ilike` * During filtering: `relational_query.filter.comparison.ilike` * During sorting:`relational_query.sort.expression.comparison.ilike` * During joining: `relational_query.join.expression.comparison.ilike` * During aggregation: `relational_query.aggregate.expression.comparison.ilike` * During windowing: `relational_query.window.expression.comparison.ilike`.

func NewRelationalExpressionNotILike 

func NewRelationalExpressionNotILike[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionNotILike

NewRelationalExpressionNotILike creates a RelationalExpressionNotILike instance.

func (RelationalExpressionNotILike) ToMap 

func (j RelationalExpressionNotILike) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionNotILike) Type 

func (j RelationalExpressionNotILike) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionNotILike) Wrap 

func (j RelationalExpressionNotILike) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionNotIn 

type RelationalExpressionNotIn struct {
	Expr RelationalExpression   `json:"expr" mapstructure:"expr" yaml:"expr"`
	List []RelationalExpression `json:"list" mapstructure:"list" yaml:"list"`
}

RelationalExpressionNotIn represents a RelationalExpression with the not_in type.

func NewRelationalExpressionNotIn 

func NewRelationalExpressionNotIn[E RelationalExpressionInner](
	expr E,
	list []RelationalExpressionInner,
) *RelationalExpressionNotIn

NewRelationalExpressionNotIn creates a RelationalExpressionNotIn instance.

func (RelationalExpressionNotIn) ToMap 

func (j RelationalExpressionNotIn) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionNotIn) Type 

func (j RelationalExpressionNotIn) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionNotIn) Wrap 

func (j RelationalExpressionNotIn) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionNotLike 

type RelationalExpressionNotLike struct {
	Expr    RelationalExpression `json:"expr"    mapstructure:"expr"    yaml:"expr"`
	Pattern RelationalExpression `json:"pattern" mapstructure:"pattern" yaml:"pattern"`
}

RelationalExpressionNotLike represents a RelationalExpression with the not_like type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.comparison.like` * During filtering: `relational_query.filter.comparison.like` * During sorting:`relational_query.sort.expression.comparison.like` * During joining: `relational_query.join.expression.comparison.like` * During aggregation: `relational_query.aggregate.expression.comparison.like` * During windowing: `relational_query.window.expression.comparison.like`.

func NewRelationalExpressionNotLike 

func NewRelationalExpressionNotLike[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionNotLike

NewRelationalExpressionNotLike creates a RelationalExpressionNotLike instance.

func (RelationalExpressionNotLike) ToMap 

func (j RelationalExpressionNotLike) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionNotLike) Type 

func (j RelationalExpressionNotLike) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionNotLike) Wrap 

func (j RelationalExpressionNotLike) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionNullIf 

type RelationalExpressionNullIf struct {
	Expr1 RelationalExpression `json:"expr1" mapstructure:"expr1" yaml:"expr1"`
	Expr2 RelationalExpression `json:"expr2" mapstructure:"expr2" yaml:"expr2"`
}

RelationalExpressionNullIf represents a relational null_if expression type.

func NewRelationalExpressionNullIf 

func NewRelationalExpressionNullIf[L RelationalExpressionInner, R RelationalExpressionInner](
	expr1 L,
	expr2 R,
) *RelationalExpressionNullIf

NewRelationalExpressionNullIf creates a RelationalExpressionNullIf instance.

func (RelationalExpressionNullIf) ToMap 

func (j RelationalExpressionNullIf) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionNullIf) Type 

func (j RelationalExpressionNullIf) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionNullIf) Wrap 

func (j RelationalExpressionNullIf) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionNvl 

type RelationalExpressionNvl struct {
	Expr1 RelationalExpression `json:"expr1" mapstructure:"expr1" yaml:"expr1"`
	Expr2 RelationalExpression `json:"expr2" mapstructure:"expr2" yaml:"expr2"`
}

RelationalExpressionNvl represents a relational nvl expression type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.nvl` * During filtering: `relational_query.filter.scalar.nvl` * During sorting:`relational_query.sort.expression.scalar.nvl` * During joining: `relational_query.join.expression.scalar.nvl` * During aggregation: `relational_query.aggregate.expression.scalar.nvl` * During windowing: `relational_query.window.expression.scalar.nvl`.

func NewRelationalExpressionNvl 

func NewRelationalExpressionNvl[L RelationalExpressionInner, R RelationalExpressionInner](
	expr1 L,
	expr2 R,
) *RelationalExpressionNvl

NewRelationalExpressionNvl creates a RelationalExpressionNvl instance.

func (RelationalExpressionNvl) ToMap 

func (j RelationalExpressionNvl) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionNvl) Type 

func (j RelationalExpressionNvl) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionNvl) Wrap 

func (j RelationalExpressionNvl) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionOr 

type RelationalExpressionOr struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionOr represents a RelationalExpression with the or type.

func NewRelationalExpressionOr 

func NewRelationalExpressionOr[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionOr

NewRelationalExpressionOr creates a RelationalExpressionOr instance.

func (RelationalExpressionOr) ToMap 

func (j RelationalExpressionOr) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionOr) Type 

func (j RelationalExpressionOr) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionOr) Wrap 

func (j RelationalExpressionOr) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionPercentRank 

type RelationalExpressionPercentRank struct {
	OrderBy     []Sort                 `json:"order_by"     mapstructure:"order_by"     yaml:"order_by"`
	PartitionBy []RelationalExpression `json:"partition_by" mapstructure:"partition_by" yaml:"partition_by"`
}

RelationalExpressionPercentRank represents a RelationalExpression with the percent_rank type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.window.percent_rank` * During filtering: `relational_query.filter.window.percent_rank` * During sorting:`relational_query.sort.expression.window.percent_rank` * During joining: `relational_query.join.expression.window.percent_rank` * During aggregation: `relational_query.window.percent_rank` * During windowing: `relational_query.window.expression.window.percent_rank`.

func NewRelationalExpressionPercentRank 

func NewRelationalExpressionPercentRank(
	orderBy []Sort,
	partitionBy []RelationalExpressionInner,
) *RelationalExpressionPercentRank

NewRelationalExpressionPercentRank creates a RelationalExpressionPercentRank instance.

func (RelationalExpressionPercentRank) ToMap 

func (j RelationalExpressionPercentRank) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionPercentRank) Type 

func (j RelationalExpressionPercentRank) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionPercentRank) Wrap 

func (j RelationalExpressionPercentRank) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionPlus 

type RelationalExpressionPlus struct {
	Left  RelationalExpression `json:"left"  mapstructure:"left"  yaml:"left"`
	Right RelationalExpression `json:"right" mapstructure:"right" yaml:"right"`
}

RelationalExpressionPlus represents a RelationalExpression with the plus type.

func NewRelationalExpressionPlus 

func NewRelationalExpressionPlus[L RelationalExpressionInner, R RelationalExpressionInner](
	left L,
	right R,
) *RelationalExpressionPlus

NewRelationalExpressionPlus creates a RelationalExpressionPlus instance.

func (RelationalExpressionPlus) ToMap 

func (j RelationalExpressionPlus) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionPlus) Type 

func (j RelationalExpressionPlus) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionPlus) Wrap 

func (j RelationalExpressionPlus) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionPower 

type RelationalExpressionPower struct {
	Base RelationalExpression `json:"base" mapstructure:"base" yaml:"base"`
	Exp  RelationalExpression `json:"exp"  mapstructure:"exp"  yaml:"exp"`
}

RelationalExpressionPower represents a relational power expression type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.power` * During filtering: `relational_query.filter.scalar.power` * During sorting:`relational_query.sort.expression.scalar.power` * During joining: `relational_query.join.expression.scalar.power` * During aggregation: `relational_query.aggregate.expression.scalar.power` * During windowing: `relational_query.window.expression.scalar.power`.

func NewRelationalExpressionPower 

func NewRelationalExpressionPower[L RelationalExpressionInner, R RelationalExpressionInner](
	base L,
	exp R,
) *RelationalExpressionPower

NewRelationalExpressionPower creates a RelationalExpressionPower instance.

func (RelationalExpressionPower) ToMap 

func (j RelationalExpressionPower) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionPower) Type 

func (j RelationalExpressionPower) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionPower) Wrap 

func (j RelationalExpressionPower) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionRPad 

type RelationalExpressionRPad struct {
	Str        RelationalExpression  `json:"str"                   mapstructure:"str"                   yaml:"str"`
	N          RelationalExpression  `json:"n"                     mapstructure:"n"                     yaml:"n"`
	PaddingStr *RelationalExpression `json:"padding_str,omitempty" mapstructure:"padding_str,omitempty" yaml:"padding_str,omitempty"`
}

RelationalExpressionRPad represents a RelationalExpression with the r_pad type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.rpad` * During filtering: `relational_query.filter.scalar.rpad` * During sorting:`relational_query.sort.expression.scalar.rpad` * During joining: `relational_query.join.expression.scalar.rpad` * During aggregation: `relational_query.aggregate.expression.scalar.rpad` * During windowing: `relational_query.window.expression.scalar.rpad`.

func NewRelationalExpressionRPad 

func NewRelationalExpressionRPad[E RelationalExpressionInner, N RelationalExpressionInner](
	str E,
	n N,
) *RelationalExpressionRPad

NewRelationalExpressionRPad creates a RelationalExpressionRPad instance.

func (RelationalExpressionRPad) ToMap 

func (j RelationalExpressionRPad) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionRPad) Type 

func (j RelationalExpressionRPad) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionRPad) WithPaddingStr 

func (j RelationalExpressionRPad) WithPaddingStr(
	paddingStr RelationalExpressionInner,
) *RelationalExpressionRPad

WithPaddingStr returns the new instance with padding str set.

func (RelationalExpressionRPad) Wrap 

func (j RelationalExpressionRPad) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionRTrim 

type RelationalExpressionRTrim struct {
	Str     RelationalExpression  `json:"str"                mapstructure:"str"                yaml:"str"`
	TrimStr *RelationalExpression `json:"trim_str,omitempty" mapstructure:"trim_str,omitempty" yaml:"trim_str,omitempty"`
}

RelationalExpressionRTrim represents a RelationalExpression with the r_trim type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.rtrim` * During filtering: `relational_query.filter.scalar.rtrim` * During sorting:`relational_query.sort.expression.scalar.rtrim` * During joining: `relational_query.join.expression.scalar.rtrim` * During aggregation: `relational_query.aggregate.expression.scalar.rtrim` * During windowing: `relational_query.window.expression.scalar.rtrim`.

func NewRelationalExpressionRTrim 

func NewRelationalExpressionRTrim[E RelationalExpressionInner](str E) *RelationalExpressionRTrim

NewRelationalExpressionRTrim creates a RelationalExpressionRTrim instance.

func (RelationalExpressionRTrim) ToMap 

func (j RelationalExpressionRTrim) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionRTrim) Type 

func (j RelationalExpressionRTrim) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionRTrim) WithTrimStr 

func (j RelationalExpressionRTrim) WithTrimStr(
	trimStr RelationalExpressionInner,
) *RelationalExpressionRTrim

WithTrimStr returns the new instance with trim str set.

func (RelationalExpressionRTrim) Wrap 

func (j RelationalExpressionRTrim) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionRandom 

type RelationalExpressionRandom struct{}

RelationalExpressionRandom represents a relational current_date expression type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.random` * During filtering: `relational_query.filter.scalar.random` * During sorting:`relational_query.sort.expression.scalar.random` * During joining: `relational_query.join.expression.scalar.random` * During aggregation: `relational_query.aggregate.expression.scalar.random` * During windowing: `relational_query.window.expression.scalar.random`.

func NewRelationalExpressionRandom 

func NewRelationalExpressionRandom() *RelationalExpressionRandom

NewRelationalExpressionRandom creates a RelationalExpressionRandom instance.

func (RelationalExpressionRandom) ToMap 

func (j RelationalExpressionRandom) ToMap() map[string]any

ToMap converts the instance to raw map.

func (RelationalExpressionRandom) Type 

func (j RelationalExpressionRandom) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionRandom) Wrap 

func (j RelationalExpressionRandom) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionRank 

type RelationalExpressionRank struct {
	OrderBy     []Sort                 `json:"order_by"     mapstructure:"order_by"     yaml:"order_by"`
	PartitionBy []RelationalExpression `json:"partition_by" mapstructure:"partition_by" yaml:"partition_by"`
}

RelationalExpressionRank represents a RelationalExpression with the rank type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.window.rank` * During filtering: `relational_query.filter.window.rank` * During sorting:`relational_query.sort.expression.window.rank` * During joining: `relational_query.join.expression.window.rank` * During aggregation: `relational_query.window.rank` * During windowing: `relational_query.window.expression.window.rank`.

func NewRelationalExpressionRank 

func NewRelationalExpressionRank(
	orderBy []Sort,
	partitionBy []RelationalExpressionInner,
) *RelationalExpressionRank

NewRelationalExpressionRank creates a RelationalExpressionRank instance.

func (RelationalExpressionRank) ToMap 

func (j RelationalExpressionRank) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionRank) Type 

func (j RelationalExpressionRank) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionRank) Wrap 

func (j RelationalExpressionRank) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionReplace 

type RelationalExpressionReplace struct {
	Str         RelationalExpression `json:"str"         mapstructure:"str"         yaml:"str"`
	Substr      RelationalExpression `json:"substr"      mapstructure:"substr"      yaml:"substr"`
	Replacement RelationalExpression `json:"replacement" mapstructure:"replacement" yaml:"replacement"`
}

RelationalExpressionReplace represents a relational replace expression type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.replace` * During filtering: `relational_query.filter.scalar.replace` * During sorting:`relational_query.sort.expression.scalar.replace` * During joining: `relational_query.join.expression.scalar.replace` * During aggregation: `relational_query.aggregate.expression.scalar.replace` * During windowing: `relational_query.window.expression.scalar.replace`.

func NewRelationalExpressionReplace 

func NewRelationalExpressionReplace[S RelationalExpressionInner, SS RelationalExpressionInner, R RelationalExpressionInner](
	str S,
	substr SS,
	replacement R,
) *RelationalExpressionReplace

NewRelationalExpressionReplace creates a RelationalExpressionReplace instance.

func (RelationalExpressionReplace) ToMap 

func (j RelationalExpressionReplace) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionReplace) Type 

func (j RelationalExpressionReplace) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionReplace) Wrap 

func (j RelationalExpressionReplace) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionReverse 

type RelationalExpressionReverse struct {
	Str RelationalExpression `json:"str" mapstructure:"str" yaml:"str"`
}

RelationalExpressionReverse represents a relational reverse expression type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.reverse` * During filtering: `relational_query.filter.scalar.reverse` * During sorting:`relational_query.sort.expression.scalar.reverse` * During joining: `relational_query.join.expression.scalar.reverse` * During aggregation: `relational_query.aggregate.expression.scalar.reverse` * During windowing: `relational_query.window.expression.scalar.reverse`.

func NewRelationalExpressionReverse 

func NewRelationalExpressionReverse[S RelationalExpressionInner](
	str S,
) *RelationalExpressionReverse

NewRelationalExpressionReverse creates a RelationalExpressionReverse instance.

func (RelationalExpressionReverse) ToMap 

func (j RelationalExpressionReverse) ToMap() map[string]any

ToMap converts the instance to raw map.

func (RelationalExpressionReverse) Type 

func (j RelationalExpressionReverse) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionReverse) Wrap 

func (j RelationalExpressionReverse) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionRight 

type RelationalExpressionRight struct {
	Str RelationalExpression `json:"str" mapstructure:"str" yaml:"str"`
	N   RelationalExpression `json:"n"   mapstructure:"n"   yaml:"n"`
}

RelationalExpressionRight represents a RelationalExpression with the right type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.right` * During filtering: `relational_query.filter.scalar.right` * During sorting:`relational_query.sort.expression.scalar.right` * During joining: `relational_query.join.expression.scalar.right` * During aggregation: `relational_query.aggregate.expression.scalar.right` * During windowing: `relational_query.window.expression.scalar.right`.

func NewRelationalExpressionRight 

func NewRelationalExpressionRight[E RelationalExpressionInner, N RelationalExpressionInner](
	str E,
	n N,
) *RelationalExpressionRight

NewRelationalExpressionRight creates a RelationalExpressionRight instance.

func (RelationalExpressionRight) ToMap 

func (j RelationalExpressionRight) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionRight) Type 

func (j RelationalExpressionRight) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionRight) Wrap 

func (j RelationalExpressionRight) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionRound 

type RelationalExpressionRound struct {
	Expr RelationalExpression  `json:"expr"           mapstructure:"expr"           yaml:"expr"`
	Prec *RelationalExpression `json:"prec,omitempty" mapstructure:"prec,omitempty" yaml:"prec,omitempty"`
}

RelationalExpressionRound represents a RelationalExpression with the round type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.round` * During filtering: `relational_query.filter.scalar.round` * During sorting:`relational_query.sort.expression.scalar.round` * During joining: `relational_query.join.expression.scalar.round` * During aggregation: `relational_query.aggregate.expression.scalar.round` * During windowing: `relational_query.window.expression.scalar.round`.

func NewRelationalExpressionRound 

func NewRelationalExpressionRound[E RelationalExpressionInner](str E) *RelationalExpressionRound

NewRelationalExpressionRound creates a RelationalExpressionRound instance.

func (RelationalExpressionRound) ToMap 

func (j RelationalExpressionRound) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionRound) Type 

func (j RelationalExpressionRound) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionRound) WithPrec 

func (j RelationalExpressionRound) WithPrec(
	prec RelationalExpressionInner,
) *RelationalExpressionRound

WithPrec returns the new instance with prec set.

func (RelationalExpressionRound) Wrap 

func (j RelationalExpressionRound) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionRowNumber 

type RelationalExpressionRowNumber struct {
	OrderBy     []Sort                 `json:"order_by"     mapstructure:"order_by"     yaml:"order_by"`
	PartitionBy []RelationalExpression `json:"partition_by" mapstructure:"partition_by" yaml:"partition_by"`
}

RelationalExpressionRowNumber represents a RelationalExpression with the row_number type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.window.row_number` * During filtering: `relational_query.filter.window.row_number` * During sorting:`relational_query.sort.expression.window.row_number` * During joining: `relational_query.join.expression.window.row_number` * During aggregation: `relational_query.window.row_number` * During windowing: `relational_query.window.expression.window.row_number`.

func NewRelationalExpressionRowNumber 

func NewRelationalExpressionRowNumber(
	orderBy []Sort,
	partitionBy []RelationalExpressionInner,
) *RelationalExpressionRowNumber

NewRelationalExpressionRowNumber creates a RelationalExpressionRowNumber instance.

func (RelationalExpressionRowNumber) ToMap 

func (j RelationalExpressionRowNumber) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionRowNumber) Type 

func (j RelationalExpressionRowNumber) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionRowNumber) Wrap 

func (j RelationalExpressionRowNumber) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionSqrt 

type RelationalExpressionSqrt struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionSqrt represents a RelationalExpression with the sqrt type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.sqrt` * During filtering: `relational_query.filter.scalar.sqrt` * During sorting:`relational_query.sort.expression.scalar.sqrt` * During joining: `relational_query.join.expression.scalar.sqrt` * During aggregation: `relational_query.aggregate.expression.scalar.sqrt` * During windowing: `relational_query.window.expression.scalar.sqrt`.

func NewRelationalExpressionSqrt 

func NewRelationalExpressionSqrt[E RelationalExpressionInner](expr E) *RelationalExpressionSqrt

NewRelationalExpressionSqrt creates a RelationalExpressionSqrt instance.

func (RelationalExpressionSqrt) ToMap 

func (j RelationalExpressionSqrt) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionSqrt) Type 

func (j RelationalExpressionSqrt) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionSqrt) Wrap 

func (j RelationalExpressionSqrt) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionStddev 

type RelationalExpressionStddev struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionStddev represents a RelationalExpression with the stddev type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.aggregate.stddev` * During filtering: `relational_query.filter.aggregate.stddev` * During sorting:`relational_query.sort.expression.aggregate.stddev` * During joining: `relational_query.join.expression.aggregate.stddev` * During aggregation: `relational_query.aggregate.expression.aggregate.stddev` * During windowing: `relational_query.window.expression.aggregate.stddev`.

func NewRelationalExpressionStddev 

func NewRelationalExpressionStddev[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionStddev

NewRelationalExpressionStddev creates a RelationalExpressionStddev instance.

func (RelationalExpressionStddev) ToMap 

func (j RelationalExpressionStddev) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionStddev) Type 

func (j RelationalExpressionStddev) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionStddev) Wrap 

func (j RelationalExpressionStddev) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionStddevPop 

type RelationalExpressionStddevPop struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionStddevPop represents a RelationalExpression with the stddev_pop type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.aggregate.stddev_pop` * During filtering: `relational_query.filter.aggregate.stddev_pop` * During sorting:`relational_query.sort.expression.aggregate.stddev_pop` * During joining: `relational_query.join.expression.aggregate.stddev_pop` * During aggregation: `relational_query.aggregate.expression.aggregate.stddev_pop` * During windowing: `relational_query.window.expression.aggregate.stddev_pop`.

func NewRelationalExpressionStddevPop 

func NewRelationalExpressionStddevPop[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionStddevPop

NewRelationalExpressionStddevPop creates a RelationalExpressionStddevPop instance.

func (RelationalExpressionStddevPop) ToMap 

func (j RelationalExpressionStddevPop) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionStddevPop) Type 

func (j RelationalExpressionStddevPop) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionStddevPop) Wrap 

func (j RelationalExpressionStddevPop) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionStrPos 

type RelationalExpressionStrPos struct {
	Str    RelationalExpression `json:"str"    mapstructure:"str"    yaml:"str"`
	Substr RelationalExpression `json:"substr" mapstructure:"substr" yaml:"substr"`
}

RelationalExpressionStrPos represents a relational str_pos expression type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.strpos` * During filtering: `relational_query.filter.scalar.strpos` * During sorting:`relational_query.sort.expression.scalar.strpos` * During joining: `relational_query.join.expression.scalar.strpos` * During aggregation: `relational_query.aggregate.expression.scalar.strpos` * During windowing: `relational_query.window.expression.scalar.strpos`.

func NewRelationalExpressionStrPos 

func NewRelationalExpressionStrPos[S RelationalExpressionInner, SS RelationalExpressionInner](
	str S,
	substr SS,
) *RelationalExpressionStrPos

NewRelationalExpressionStrPos creates a RelationalExpressionStrPos instance.

func (RelationalExpressionStrPos) ToMap 

func (j RelationalExpressionStrPos) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionStrPos) Type 

func (j RelationalExpressionStrPos) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionStrPos) Wrap 

func (j RelationalExpressionStrPos) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionStringAgg 

type RelationalExpressionStringAgg struct {
	Expr      RelationalExpression `json:"expr"               mapstructure:"expr"               yaml:"expr"`
	Separator string               `json:"separator"          mapstructure:"separator"          yaml:"separator"`
	// Only used when in specific contexts where the appropriate capability is supported:
	// * During projection: `relational_query.project.expression.aggregate.string_agg.distinct`
	// * During filtering: `relational_query.filter.aggregate.string_agg.distinct`
	// * During sorting:`relational_query.sort.expression.aggregate.string_agg.distinct`
	// * During joining: `relational_query.join.expression.aggregate.string_agg.distinct`
	// * During aggregation: `relational_query.aggregate.expression.aggregate.string_agg.distinct` * During windowing: `relational_query.window.expression.aggregate.string_agg.distinct`
	Distinct bool `json:"distinct"           mapstructure:"distinct"           yaml:"distinct"`
	// Only used when in specific contexts where the appropriate capability is supported:
	// * During projection: `relational_query.project.expression.aggregate.string_agg.order_by`
	// * During filtering: `relational_query.filter.aggregate.string_agg.order_by`
	// * During sorting:`relational_query.sort.expression.aggregate.string_agg.order_by`
	// * During joining: `relational_query.join.expression.aggregate.string_agg.order_by`
	// * During aggregation: `relational_query.aggregate.expression.aggregate.string_agg.order_by`
	// * During windowing: `relational_query.window.expression.aggregate.string_agg.order_by`
	OrderBy []Sort `json:"order_by,omitempty" mapstructure:"order_by,omitempty" yaml:"order_by,omitempty"`
}

RelationalExpressionStringAgg represents a RelationalExpression with the string_agg type.

func NewRelationalExpressionStringAgg 

func NewRelationalExpressionStringAgg[E RelationalExpressionInner](
	expr E,
	separator string,
	distinct bool,
) *RelationalExpressionStringAgg

NewRelationalExpressionStringAgg creates a RelationalExpressionStringAgg instance.

func (RelationalExpressionStringAgg) ToMap 

func (j RelationalExpressionStringAgg) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionStringAgg) Type 

func (j RelationalExpressionStringAgg) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionStringAgg) WithOrderBy 

func (j RelationalExpressionStringAgg) WithOrderBy(orderBy []Sort) *RelationalExpressionStringAgg

WithOrderBy returns the RelationalExpressionStringAgg with order by.

func (RelationalExpressionStringAgg) Wrap 

func (j RelationalExpressionStringAgg) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionSubstr 

type RelationalExpressionSubstr struct {
	Str      RelationalExpression  `json:"str"           mapstructure:"str"           yaml:"str"`
	StartPos RelationalExpression  `json:"start_pos"     mapstructure:"start_pos"     yaml:"start_pos"`
	Len      *RelationalExpression `json:"len,omitempty" mapstructure:"len,omitempty" yaml:"len,omitempty"`
}

RelationalExpressionSubstr represents a relational substr expression type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.substr` * During filtering: `relational_query.filter.scalar.substr` * During sorting:`relational_query.sort.expression.scalar.substr` * During joining: `relational_query.join.expression.scalar.substr` * During aggregation: `relational_query.aggregate.expression.scalar.substr` * During windowing: `relational_query.window.expression.scalar.substr`.

func NewRelationalExpressionSubstr 

func NewRelationalExpressionSubstr[S RelationalExpressionInner, SP RelationalExpressionInner](
	str S,
	startPos SP,
) *RelationalExpressionSubstr

NewRelationalExpressionSubstr creates a RelationalExpressionSubstr instance.

func (RelationalExpressionSubstr) ToMap 

func (j RelationalExpressionSubstr) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionSubstr) Type 

func (j RelationalExpressionSubstr) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionSubstr) WithLen 

func (j RelationalExpressionSubstr) WithLen(
	length RelationalExpressionInner,
) *RelationalExpressionSubstr

WithLen returns the new instance with len set.

func (RelationalExpressionSubstr) Wrap 

func (j RelationalExpressionSubstr) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionSubstrIndex 

type RelationalExpressionSubstrIndex struct {
	Str   RelationalExpression `json:"str"   mapstructure:"str"   yaml:"str"`
	Delim RelationalExpression `json:"delim" mapstructure:"delim" yaml:"delim"`
	Count RelationalExpression `json:"count" mapstructure:"count" yaml:"count"`
}

RelationalExpressionSubstrIndex represents a relational substr_index expression type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.substr_index` * During filtering: `relational_query.filter.scalar.substr_index` * During sorting:`relational_query.sort.expression.scalar.substr_index` * During joining: `relational_query.join.expression.scalar.substr_index` * During aggregation: `relational_query.aggregate.expression.scalar.substr_index` * During windowing: `relational_query.window.expression.scalar.substr_index`.

func NewRelationalExpressionSubstrIndex 

func NewRelationalExpressionSubstrIndex[S RelationalExpressionInner, D RelationalExpressionInner, C RelationalExpressionInner](
	str S,
	delim D,
	count C,
) *RelationalExpressionSubstrIndex

NewRelationalExpressionSubstrIndex creates a RelationalExpressionSubstrIndex instance.

func (RelationalExpressionSubstrIndex) ToMap 

func (j RelationalExpressionSubstrIndex) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionSubstrIndex) Type 

func (j RelationalExpressionSubstrIndex) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionSubstrIndex) Wrap 

func (j RelationalExpressionSubstrIndex) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionSum 

type RelationalExpressionSum struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionSum represents a RelationalExpression with the sum type.

func NewRelationalExpressionSum 

func NewRelationalExpressionSum[E RelationalExpressionInner](expr E) *RelationalExpressionSum

NewRelationalExpressionSum creates a RelationalExpressionSum instance.

func (RelationalExpressionSum) ToMap 

func (j RelationalExpressionSum) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionSum) Type 

func (j RelationalExpressionSum) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionSum) Wrap 

func (j RelationalExpressionSum) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionTan 

type RelationalExpressionTan struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionTan represents a RelationalExpression with the tan type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.tan` * During filtering: `relational_query.filter.scalar.tan` * During sorting:`relational_query.sort.expression.scalar.tan` * During joining: `relational_query.join.expression.scalar.tan` * During aggregation: `relational_query.aggregate.expression.scalar.tan` * During windowing: `relational_query.window.expression.scalar.tan`.

func NewRelationalExpressionTan 

func NewRelationalExpressionTan[E RelationalExpressionInner](expr E) *RelationalExpressionTan

NewRelationalExpressionTan creates a RelationalExpressionTan instance.

func (RelationalExpressionTan) ToMap 

func (j RelationalExpressionTan) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionTan) Type 

func (j RelationalExpressionTan) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionTan) Wrap 

func (j RelationalExpressionTan) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionToDate 

type RelationalExpressionToDate struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionToDate represents a RelationalExpression with the to_date type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.to_date` * During filtering: `relational_query.filter.scalar.to_date` * During sorting:`relational_query.sort.expression.scalar.to_date` * During joining: `relational_query.join.expression.scalar.to_date` * During aggregation: `relational_query.aggregate.expression.scalar.to_date` * During windowing: `relational_query.window.expression.scalar.to_date`.

func NewRelationalExpressionToDate 

func NewRelationalExpressionToDate[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionToDate

NewRelationalExpressionToDate creates a RelationalExpressionToDate instance.

func (RelationalExpressionToDate) ToMap 

func (j RelationalExpressionToDate) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionToDate) Type 

func (j RelationalExpressionToDate) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionToDate) Wrap 

func (j RelationalExpressionToDate) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionToLower 

type RelationalExpressionToLower struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionToLower represents a RelationalExpression with the to_lower type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.to_lower` * During filtering: `relational_query.filter.scalar.to_lower` * During sorting:`relational_query.sort.expression.scalar.to_lower` * During joining: `relational_query.join.expression.scalar.to_lower` * During aggregation: `relational_query.aggregate.expression.scalar.to_lower` * During windowing: `relational_query.window.expression.scalar.to_lower`.

func NewRelationalExpressionToLower 

func NewRelationalExpressionToLower[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionToLower

NewRelationalExpressionToLower creates a RelationalExpressionToLower instance.

func (RelationalExpressionToLower) ToMap 

func (j RelationalExpressionToLower) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionToLower) Type 

func (j RelationalExpressionToLower) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionToLower) Wrap 

func (j RelationalExpressionToLower) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionToTimestamp 

type RelationalExpressionToTimestamp struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionToTimestamp represents a RelationalExpression with the to_timestamp type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.to_timestamp` * During filtering: `relational_query.filter.scalar.to_timestamp` * During sorting:`relational_query.sort.expression.scalar.to_timestamp` * During joining: `relational_query.join.expression.scalar.to_timestamp` * During aggregation: `relational_query.aggregate.expression.scalar.to_timestamp` * During windowing: `relational_query.window.expression.scalar.to_timestamp`.

func NewRelationalExpressionToTimestamp 

func NewRelationalExpressionToTimestamp[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionToTimestamp

NewRelationalExpressionToTimestamp creates a RelationalExpressionToTimestamp instance.

func (RelationalExpressionToTimestamp) ToMap 

func (j RelationalExpressionToTimestamp) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionToTimestamp) Type 

func (j RelationalExpressionToTimestamp) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionToTimestamp) Wrap 

func (j RelationalExpressionToTimestamp) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionToUpper 

type RelationalExpressionToUpper struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionToUpper represents a RelationalExpression with the to_upper type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.to_upper` * During filtering: `relational_query.filter.scalar.to_upper` * During sorting:`relational_query.sort.expression.scalar.to_upper` * During joining: `relational_query.join.expression.scalar.to_upper` * During aggregation: `relational_query.aggregate.expression.scalar.to_upper` * During windowing: `relational_query.window.expression.scalar.to_upper`.

func NewRelationalExpressionToUpper 

func NewRelationalExpressionToUpper[E RelationalExpressionInner](
	expr E,
) *RelationalExpressionToUpper

NewRelationalExpressionToUpper creates a RelationalExpressionToUpper instance.

func (RelationalExpressionToUpper) ToMap 

func (j RelationalExpressionToUpper) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionToUpper) Type 

func (j RelationalExpressionToUpper) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionToUpper) Wrap 

func (j RelationalExpressionToUpper) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionTrunc 

type RelationalExpressionTrunc struct {
	Expr RelationalExpression  `json:"expr"           mapstructure:"expr"           yaml:"expr"`
	Prec *RelationalExpression `json:"prec,omitempty" mapstructure:"prec,omitempty" yaml:"prec,omitempty"`
}

RelationalExpressionTrunc represents a RelationalExpression with the trunc type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.scalar.trunc` * During filtering: `relational_query.filter.scalar.trunc` * During sorting:`relational_query.sort.expression.scalar.trunc` * During joining: `relational_query.join.expression.scalar.trunc` * During aggregation: `relational_query.aggregate.expression.scalar.trunc` * During windowing: `relational_query.window.expression.scalar.trunc`.

func NewRelationalExpressionTrunc 

func NewRelationalExpressionTrunc[E RelationalExpressionInner](str E) *RelationalExpressionTrunc

NewRelationalExpressionTrunc creates a RelationalExpressionTrunc instance.

func (RelationalExpressionTrunc) ToMap 

func (j RelationalExpressionTrunc) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionTrunc) Type 

func (j RelationalExpressionTrunc) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionTrunc) WithPrec 

func (j RelationalExpressionTrunc) WithPrec(
	prec RelationalExpressionInner,
) *RelationalExpressionTrunc

WithPrec returns the new instance with prec set.

func (RelationalExpressionTrunc) Wrap 

func (j RelationalExpressionTrunc) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionTryCast 

type RelationalExpressionTryCast struct {
	Expr   RelationalExpression `json:"expr"                mapstructure:"expr"                yaml:"expr"`
	AsType CastType             `json:"as_type"             mapstructure:"as_type"             yaml:"as_type"`
	// Optional for now, but will be required in the future
	FromType *CastType `json:"from_type,omitempty" mapstructure:"from_type,omitempty" yaml:"from_type,omitempty"`
}

RelationalExpressionTryCast represents a RelationalExpression with the try_cast type.

func NewRelationalExpressionTryCast 

func NewRelationalExpressionTryCast[E RelationalExpressionInner, C CastTypeInner](
	expr E,
	asType C,
) *RelationalExpressionTryCast

NewRelationalExpressionTryCast creates a RelationalExpressionTryCast instance.

func (RelationalExpressionTryCast) ToMap 

func (j RelationalExpressionTryCast) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionTryCast) Type 

func (j RelationalExpressionTryCast) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionTryCast) WithFromType 

func (j RelationalExpressionTryCast) WithFromType(
	fromType CastTypeInner,
) *RelationalExpressionTryCast

WithFromType return the instance with from_type set.

func (RelationalExpressionTryCast) Wrap 

func (j RelationalExpressionTryCast) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalExpressionType 

type RelationalExpressionType string

RelationalExpressionType represents a relational expression type enum. 

const (
	RelationalExpressionTypeLiteral              RelationalExpressionType = "literal"
	RelationalExpressionTypeColumn               RelationalExpressionType = "column"
	RelationalExpressionTypeCase                 RelationalExpressionType = "case"
	RelationalExpressionTypeAnd                  RelationalExpressionType = "and"
	RelationalExpressionTypeOr                   RelationalExpressionType = "or"
	RelationalExpressionTypeNot                  RelationalExpressionType = "not"
	RelationalExpressionTypeEq                   RelationalExpressionType = "eq"
	RelationalExpressionTypeNotEq                RelationalExpressionType = "not_eq"
	RelationalExpressionTypeIsDistinctFrom       RelationalExpressionType = "is_distinct_from"
	RelationalExpressionTypeIsNotDistinctFrom    RelationalExpressionType = "is_not_distinct_from"
	RelationalExpressionTypeLt                   RelationalExpressionType = "lt"
	RelationalExpressionTypeLtEq                 RelationalExpressionType = "lt_eq"
	RelationalExpressionTypeGt                   RelationalExpressionType = "gt"
	RelationalExpressionTypeGtEq                 RelationalExpressionType = "gt_eq"
	RelationalExpressionTypeIsNotNull            RelationalExpressionType = "is_not_null"
	RelationalExpressionTypeIsNull               RelationalExpressionType = "is_null"
	RelationalExpressionTypeIsTrue               RelationalExpressionType = "is_true"
	RelationalExpressionTypeIsFalse              RelationalExpressionType = "is_false"
	RelationalExpressionTypeIsNotTrue            RelationalExpressionType = "is_not_true"
	RelationalExpressionTypeIsNotFalse           RelationalExpressionType = "is_not_false"
	RelationalExpressionTypeIn                   RelationalExpressionType = "in"
	RelationalExpressionTypeNotIn                RelationalExpressionType = "not_in"
	RelationalExpressionTypeLike                 RelationalExpressionType = "like"
	RelationalExpressionTypeNotLike              RelationalExpressionType = "not_like"
	RelationalExpressionTypeILike                RelationalExpressionType = "i_like"
	RelationalExpressionTypeNotILike             RelationalExpressionType = "not_i_like"
	RelationalExpressionTypeBetween              RelationalExpressionType = "between"
	RelationalExpressionTypeNotBetween           RelationalExpressionType = "not_between"
	RelationalExpressionTypeContains             RelationalExpressionType = "contains"
	RelationalExpressionTypeIsNaN                RelationalExpressionType = "is_na_n"
	RelationalExpressionTypeIsZero               RelationalExpressionType = "is_zero"
	RelationalExpressionTypePlus                 RelationalExpressionType = "plus"
	RelationalExpressionTypeMinus                RelationalExpressionType = "minus"
	RelationalExpressionTypeMultiply             RelationalExpressionType = "multiply"
	RelationalExpressionTypeDivide               RelationalExpressionType = "divide"
	RelationalExpressionTypeModulo               RelationalExpressionType = "modulo"
	RelationalExpressionTypeNegate               RelationalExpressionType = "negate"
	RelationalExpressionTypeCast                 RelationalExpressionType = "cast"
	RelationalExpressionTypeTryCast              RelationalExpressionType = "try_cast"
	RelationalExpressionTypeAbs                  RelationalExpressionType = "abs"
	RelationalExpressionTypeArrayElement         RelationalExpressionType = "array_element"
	RelationalExpressionTypeBTrim                RelationalExpressionType = "b_trim"
	RelationalExpressionTypeCeil                 RelationalExpressionType = "ceil"
	RelationalExpressionTypeCharacterLength      RelationalExpressionType = "character_length"
	RelationalExpressionTypeCoalesce             RelationalExpressionType = "coalesce"
	RelationalExpressionTypeConcat               RelationalExpressionType = "concat"
	RelationalExpressionTypeCos                  RelationalExpressionType = "cos"
	RelationalExpressionTypeCurrentDate          RelationalExpressionType = "current_date"
	RelationalExpressionTypeCurrentTime          RelationalExpressionType = "current_time"
	RelationalExpressionTypeCurrentTimestamp     RelationalExpressionType = "current_timestamp"
	RelationalExpressionTypeDatePart             RelationalExpressionType = "date_part"
	RelationalExpressionTypeDateTrunc            RelationalExpressionType = "date_trunc"
	RelationalExpressionTypeExp                  RelationalExpressionType = "exp"
	RelationalExpressionTypeFloor                RelationalExpressionType = "floor"
	RelationalExpressionTypeGetField             RelationalExpressionType = "get_field"
	RelationalExpressionTypeGreatest             RelationalExpressionType = "greatest"
	RelationalExpressionTypeLeast                RelationalExpressionType = "least"
	RelationalExpressionTypeLeft                 RelationalExpressionType = "left"
	RelationalExpressionTypeLn                   RelationalExpressionType = "ln"
	RelationalExpressionTypeLog                  RelationalExpressionType = "log"
	RelationalExpressionTypeLog10                RelationalExpressionType = "log10"
	RelationalExpressionTypeLog2                 RelationalExpressionType = "log2"
	RelationalExpressionTypeLPad                 RelationalExpressionType = "l_pad"
	RelationalExpressionTypeLTrim                RelationalExpressionType = "l_trim"
	RelationalExpressionTypeNullIf               RelationalExpressionType = "null_if"
	RelationalExpressionTypeNvl                  RelationalExpressionType = "nvl"
	RelationalExpressionTypePower                RelationalExpressionType = "power"
	RelationalExpressionTypeRandom               RelationalExpressionType = "random"
	RelationalExpressionTypeReplace              RelationalExpressionType = "replace"
	RelationalExpressionTypeReverse              RelationalExpressionType = "reverse"
	RelationalExpressionTypeRight                RelationalExpressionType = "right"
	RelationalExpressionTypeRound                RelationalExpressionType = "round"
	RelationalExpressionTypeRPad                 RelationalExpressionType = "r_pad"
	RelationalExpressionTypeRTrim                RelationalExpressionType = "r_trim"
	RelationalExpressionTypeSqrt                 RelationalExpressionType = "sqrt"
	RelationalExpressionTypeStrPos               RelationalExpressionType = "str_pos"
	RelationalExpressionTypeSubstr               RelationalExpressionType = "substr"
	RelationalExpressionTypeSubstrIndex          RelationalExpressionType = "substr_index"
	RelationalExpressionTypeTan                  RelationalExpressionType = "tan"
	RelationalExpressionTypeToDate               RelationalExpressionType = "to_date"
	RelationalExpressionTypeToTimestamp          RelationalExpressionType = "to_timestamp"
	RelationalExpressionTypeTrunc                RelationalExpressionType = "trunc"
	RelationalExpressionTypeToLower              RelationalExpressionType = "to_lower"
	RelationalExpressionTypeToUpper              RelationalExpressionType = "to_upper"
	RelationalExpressionTypeBinaryConcat         RelationalExpressionType = "binary_concat"
	RelationalExpressionTypeAverage              RelationalExpressionType = "average"
	RelationalExpressionTypeBoolAnd              RelationalExpressionType = "bool_and"
	RelationalExpressionTypeBoolOr               RelationalExpressionType = "bool_or"
	RelationalExpressionTypeCount                RelationalExpressionType = "count"
	RelationalExpressionTypeFirstValue           RelationalExpressionType = "first_value"
	RelationalExpressionTypeLastValue            RelationalExpressionType = "last_value"
	RelationalExpressionTypeMax                  RelationalExpressionType = "max"
	RelationalExpressionTypeMedian               RelationalExpressionType = "median"
	RelationalExpressionTypeMin                  RelationalExpressionType = "min"
	RelationalExpressionTypeStringAgg            RelationalExpressionType = "string_agg"
	RelationalExpressionTypeSum                  RelationalExpressionType = "sum"
	RelationalExpressionTypeVar                  RelationalExpressionType = "var"
	RelationalExpressionTypeStddev               RelationalExpressionType = "stddev"
	RelationalExpressionTypeStddevPop            RelationalExpressionType = "stddev_pop"
	RelationalExpressionTypeApproxPercentileCont RelationalExpressionType = "approx_percentile_cont"
	RelationalExpressionTypeArrayAgg             RelationalExpressionType = "array_agg"
	RelationalExpressionTypeApproxDistinct       RelationalExpressionType = "approx_distinct"
	RelationalExpressionTypeRowNumber            RelationalExpressionType = "row_number"
	RelationalExpressionTypeDenseRank            RelationalExpressionType = "dense_rank"
	RelationalExpressionTypeNTile                RelationalExpressionType = "n_tile"
	RelationalExpressionTypeRank                 RelationalExpressionType = "rank"
	RelationalExpressionTypeCumeDist             RelationalExpressionType = "cume_dist"
	RelationalExpressionTypePercentRank          RelationalExpressionType = "percent_rank"
)

func ParseRelationalExpressionType 

func ParseRelationalExpressionType(input string) (RelationalExpressionType, error)

ParseRelationalExpressionType parses a relational expression type from string.

func (RelationalExpressionType) IsValid 

func (j RelationalExpressionType) IsValid() bool

IsValid checks if the value is invalid.

func (*RelationalExpressionType) UnmarshalJSON 

func (j *RelationalExpressionType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalExpressionVar 

type RelationalExpressionVar struct {
	Expr RelationalExpression `json:"expr" mapstructure:"expr" yaml:"expr"`
}

RelationalExpressionVar represents a RelationalExpression with the var type. Only used when in specific contexts where the appropriate capability is supported: * During projection: `relational_query.project.expression.aggregate.var` * During filtering: `relational_query.filter.aggregate.var` * During sorting:`relational_query.sort.expression.aggregate.var` * During joining: `relational_query.join.expression.aggregate.var` * During aggregation: `relational_query.aggregate.expression.aggregate.var` * During windowing: `relational_query.window.expression.aggregate.var`.

func NewRelationalExpressionVar 

func NewRelationalExpressionVar[E RelationalExpressionInner](expr E) *RelationalExpressionVar

NewRelationalExpressionVar creates a RelationalExpressionVar instance.

func (RelationalExpressionVar) ToMap 

func (j RelationalExpressionVar) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalExpressionVar) Type 

func (j RelationalExpressionVar) Type() RelationalExpressionType

Type return the type name of the instance.

func (RelationalExpressionVar) Wrap 

func (j RelationalExpressionVar) Wrap() RelationalExpression

Encode returns the relation wrapper.

type RelationalInsertRequest 

type RelationalInsertRequest struct {
	// Values to be provided to any collection arguments
	Arguments RelationalInsertRequestArguments `json:"arguments" yaml:"arguments" mapstructure:"arguments"`

	// The name of the collection to insert into
	Collection string `json:"collection" yaml:"collection" mapstructure:"collection"`

	// The columns to insert values for
	Columns []string `json:"columns" yaml:"columns" mapstructure:"columns"`

	// The rows to insert, each row containing values for the specified columns
	Rows [][]interface{} `json:"rows" yaml:"rows" mapstructure:"rows"`
}

func (*RelationalInsertRequest) UnmarshalJSON 

func (j *RelationalInsertRequest) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalInsertRequestArguments 

type RelationalInsertRequestArguments map[string]Argument

Values to be provided to any collection arguments

type RelationalInsertResponse 

type RelationalInsertResponse struct {
	// The number of rows that were inserted
	AffectedRows int `json:"affected_rows" yaml:"affected_rows" mapstructure:"affected_rows"`
}

func (*RelationalInsertResponse) UnmarshalJSON 

func (j *RelationalInsertResponse) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalJoinCapabilities 

type RelationalJoinCapabilities struct {
	// Expression corresponds to the JSON schema field "expression".
	Expression RelationalExpressionCapabilities `json:"expression" yaml:"expression" mapstructure:"expression"`

	// JoinTypes corresponds to the JSON schema field "join_types".
	JoinTypes RelationalJoinTypeCapabilities `json:"join_types" yaml:"join_types" mapstructure:"join_types"`
}

func (*RelationalJoinCapabilities) UnmarshalJSON 

func (j *RelationalJoinCapabilities) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalJoinTypeCapabilities 

type RelationalJoinTypeCapabilities struct {
	// Full corresponds to the JSON schema field "full".
	Full *LeafCapability `json:"full,omitempty" yaml:"full,omitempty" mapstructure:"full,omitempty"`

	// Inner corresponds to the JSON schema field "inner".
	Inner *LeafCapability `json:"inner,omitempty" yaml:"inner,omitempty" mapstructure:"inner,omitempty"`

	// Left corresponds to the JSON schema field "left".
	Left *LeafCapability `json:"left,omitempty" yaml:"left,omitempty" mapstructure:"left,omitempty"`

	// LeftAnti corresponds to the JSON schema field "left_anti".
	LeftAnti *LeafCapability `json:"left_anti,omitempty" yaml:"left_anti,omitempty" mapstructure:"left_anti,omitempty"`

	// LeftSemi corresponds to the JSON schema field "left_semi".
	LeftSemi *LeafCapability `json:"left_semi,omitempty" yaml:"left_semi,omitempty" mapstructure:"left_semi,omitempty"`

	// Right corresponds to the JSON schema field "right".
	Right *LeafCapability `json:"right,omitempty" yaml:"right,omitempty" mapstructure:"right,omitempty"`

	// RightAnti corresponds to the JSON schema field "right_anti".
	RightAnti *LeafCapability `json:"right_anti,omitempty" yaml:"right_anti,omitempty" mapstructure:"right_anti,omitempty"`

	// RightSemi corresponds to the JSON schema field "right_semi".
	RightSemi *LeafCapability `json:"right_semi,omitempty" yaml:"right_semi,omitempty" mapstructure:"right_semi,omitempty"`
}

type RelationalLiteral 

type RelationalLiteral struct {
	// contains filtered or unexported fields
}

RelationalLiteral is provided by reference to a relation literal.

func NewRelationalLiteral 

func NewRelationalLiteral[T RelationalLiteralInner](inner T) RelationalLiteral

NewRelationalLiteral creates a RelationalLiteral instance.

func (RelationalLiteral) Interface 

func (j RelationalLiteral) Interface() RelationalLiteralInner

Interface tries to convert the instance to AggregateInner interface.

func (RelationalLiteral) IsEmpty 

func (j RelationalLiteral) IsEmpty() bool

IsEmpty checks if the inner type is empty.

func (RelationalLiteral) MarshalJSON 

func (j RelationalLiteral) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler interface.

func (RelationalLiteral) Type 

func (j RelationalLiteral) Type() RelationalLiteralType

Type gets the type enum of the current type.

func (*RelationalLiteral) UnmarshalJSON 

func (j *RelationalLiteral) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalLiteralBoolean 

type RelationalLiteralBoolean struct {
	Value bool `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralBoolean represents a RelationalLiteral boolean.

func NewRelationalLiteralBoolean 

func NewRelationalLiteralBoolean(value bool) *RelationalLiteralBoolean

NewRelationalLiteralBoolean creates a RelationalLiteralBoolean instance.

func (RelationalLiteralBoolean) ToMap 

func (j RelationalLiteralBoolean) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralBoolean) Type 

func (j RelationalLiteralBoolean) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralBoolean) Wrap 

func (j RelationalLiteralBoolean) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralDate32 

type RelationalLiteralDate32 struct {
	Value int32 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralDate32 represents a RelationalLiteral with Date stored as a signed 32bit int days since UNIX epoch 1970-01-01.

func NewRelationalLiteralDate32 

func NewRelationalLiteralDate32(value int32) *RelationalLiteralDate32

NewRelationalLiteralDate32 creates a RelationalLiteralDate32 instance.

func (RelationalLiteralDate32) ToMap 

func (j RelationalLiteralDate32) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralDate32) Type 

func (j RelationalLiteralDate32) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralDate32) Wrap 

func (j RelationalLiteralDate32) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralDate64 

type RelationalLiteralDate64 struct {
	Value int64 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralDate64 represents a RelationalLiteral with Date stored as a signed 64-bit int days since UNIX epoch 1970-01-01.

func NewRelationalLiteralDate64 

func NewRelationalLiteralDate64(value int64) *RelationalLiteralDate64

NewRelationalLiteralDate64 creates a RelationalLiteralDate64 instance.

func (RelationalLiteralDate64) ToMap 

func (j RelationalLiteralDate64) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralDate64) Type 

func (j RelationalLiteralDate64) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralDate64) Wrap 

func (j RelationalLiteralDate64) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralDecimal128 

type RelationalLiteralDecimal128 struct {
	Value int64 `json:"value" mapstructure:"value" yaml:"value"`
	Scale int8  `json:"scale" mapstructure:"scale" yaml:"scale"`
	Spec  uint8 `json:"prec"  mapstructure:"prec"  yaml:"prec"`
}

RelationalLiteralDecimal128 represents a RelationalLiteral with unsigned 128-bit decimal.

func NewRelationalLiteralDecimal128 

func NewRelationalLiteralDecimal128(
	value int64,
	scale int8,
	spec uint8,
) *RelationalLiteralDecimal128

NewRelationalLiteralDecimal128 creates a RelationalLiteralDecimal128 instance.

func (RelationalLiteralDecimal128) ToMap 

func (j RelationalLiteralDecimal128) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralDecimal128) Type 

func (j RelationalLiteralDecimal128) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralDecimal128) Wrap 

func (j RelationalLiteralDecimal128) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralDecimal256 

type RelationalLiteralDecimal256 struct {
	Value string `json:"value" mapstructure:"value" yaml:"value"`
	Scale int8   `json:"scale" mapstructure:"scale" yaml:"scale"`
	Spec  uint8  `json:"prec"  mapstructure:"prec"  yaml:"prec"`
}

RelationalLiteralDecimal256 represents a RelationalLiteral with unsigned 256-bit decimal.

func NewRelationalLiteralDecimal256 

func NewRelationalLiteralDecimal256(
	value string,
	scale int8,
	spec uint8,
) *RelationalLiteralDecimal256

NewRelationalLiteralDecimal256 creates a RelationalLiteralDecimal256 instance.

func (RelationalLiteralDecimal256) ToMap 

func (j RelationalLiteralDecimal256) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralDecimal256) Type 

func (j RelationalLiteralDecimal256) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralDecimal256) Wrap 

func (j RelationalLiteralDecimal256) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralDurationMicrosecond 

type RelationalLiteralDurationMicrosecond struct {
	Value int64 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralDurationMicrosecond represents a RelationalLiteral with Duration in microseconds.

func NewRelationalLiteralDurationMicrosecond 

func NewRelationalLiteralDurationMicrosecond(value int64) *RelationalLiteralDurationMicrosecond

NewRelationalLiteralDurationMicrosecond creates a RelationalLiteralDurationMicrosecond instance.

func (RelationalLiteralDurationMicrosecond) ToMap 

func (j RelationalLiteralDurationMicrosecond) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralDurationMicrosecond) Type 

func (j RelationalLiteralDurationMicrosecond) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralDurationMicrosecond) Wrap 

func (j RelationalLiteralDurationMicrosecond) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralDurationMillisecond 

type RelationalLiteralDurationMillisecond struct {
	Value int64 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralDurationMillisecond represents a RelationalLiteral with Duration in milliseconds.

func NewRelationalLiteralDurationMillisecond 

func NewRelationalLiteralDurationMillisecond(value int64) *RelationalLiteralDurationMillisecond

NewRelationalLiteralDurationMillisecond creates a RelationalLiteralDurationMillisecond instance.

func (RelationalLiteralDurationMillisecond) ToMap 

func (j RelationalLiteralDurationMillisecond) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralDurationMillisecond) Type 

func (j RelationalLiteralDurationMillisecond) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralDurationMillisecond) Wrap 

func (j RelationalLiteralDurationMillisecond) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralDurationNanosecond 

type RelationalLiteralDurationNanosecond struct {
	Value int64 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralDurationNanosecond represents a RelationalLiteral with Duration in nanoseconds.

func NewRelationalLiteralDurationNanosecond 

func NewRelationalLiteralDurationNanosecond(value int64) *RelationalLiteralDurationNanosecond

NewRelationalLiteralDurationNanosecond creates a RelationalLiteralDurationNanosecond instance.

func (RelationalLiteralDurationNanosecond) ToMap 

func (j RelationalLiteralDurationNanosecond) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralDurationNanosecond) Type 

func (j RelationalLiteralDurationNanosecond) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralDurationNanosecond) Wrap 

func (j RelationalLiteralDurationNanosecond) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralDurationSecond 

type RelationalLiteralDurationSecond struct {
	Value int64 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralDurationSecond represents a RelationalLiteral with Duration in seconds.

func NewRelationalLiteralDurationSecond 

func NewRelationalLiteralDurationSecond(value int64) *RelationalLiteralDurationSecond

NewRelationalLiteralDurationSecond creates a RelationalLiteralDurationSecond instance.

func (RelationalLiteralDurationSecond) ToMap 

func (j RelationalLiteralDurationSecond) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralDurationSecond) Type 

func (j RelationalLiteralDurationSecond) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralDurationSecond) Wrap 

func (j RelationalLiteralDurationSecond) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralFloat32 

type RelationalLiteralFloat32 struct {
	Value float32 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralFloat32 represents a RelationalLiteral with unsigned 32-bit float.

func NewRelationalLiteralFloat32 

func NewRelationalLiteralFloat32(value float32) *RelationalLiteralFloat32

NewRelationalLiteralFloat32 creates a RelationalLiteralFloat32 instance.

func (RelationalLiteralFloat32) ToMap 

func (j RelationalLiteralFloat32) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralFloat32) Type 

func (j RelationalLiteralFloat32) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralFloat32) Wrap 

func (j RelationalLiteralFloat32) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralFloat64 

type RelationalLiteralFloat64 struct {
	Value float64 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralFloat64 represents a RelationalLiteral with unsigned 64-bit float.

func NewRelationalLiteralFloat64 

func NewRelationalLiteralFloat64(value float64) *RelationalLiteralFloat64

NewRelationalLiteralFloat64 creates a RelationalLiteralFloat64 instance.

func (RelationalLiteralFloat64) ToMap 

func (j RelationalLiteralFloat64) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralFloat64) Type 

func (j RelationalLiteralFloat64) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralFloat64) Wrap 

func (j RelationalLiteralFloat64) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralInner 

type RelationalLiteralInner interface {
	Type() RelationalLiteralType
	ToMap() map[string]any
	Wrap() RelationalLiteral
}

RelationalLiteralInner abstracts the interface for Relation.

type RelationalLiteralInt8 

type RelationalLiteralInt8 struct {
	Value int8 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralInt8 represents a RelationalLiteral with signed 8-bit int.

func NewRelationalLiteralInt8 

func NewRelationalLiteralInt8(value int8) *RelationalLiteralInt8

NewRelationalLiteralInt8 creates a RelationalLiteralInt8 instance.

func (RelationalLiteralInt8) ToMap 

func (j RelationalLiteralInt8) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralInt8) Type 

func (j RelationalLiteralInt8) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralInt8) Wrap 

func (j RelationalLiteralInt8) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralInt16 

type RelationalLiteralInt16 struct {
	Value int16 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralInt16 represents a RelationalLiteral with signed 16-bit int.

func NewRelationalLiteralInt16 

func NewRelationalLiteralInt16(value int16) *RelationalLiteralInt16

NewRelationalLiteralInt16 creates a RelationalLiteralInt16 instance.

func (RelationalLiteralInt16) ToMap 

func (j RelationalLiteralInt16) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralInt16) Type 

func (j RelationalLiteralInt16) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralInt16) Wrap 

func (j RelationalLiteralInt16) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralInt32 

type RelationalLiteralInt32 struct {
	Value int32 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralInt32 represents a RelationalLiteral with signed 32-bit int.

func NewRelationalLiteralInt32 

func NewRelationalLiteralInt32(value int32) *RelationalLiteralInt32

NewRelationalLiteralInt32 creates a RelationalLiteralInt32 instance.

func (RelationalLiteralInt32) ToMap 

func (j RelationalLiteralInt32) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralInt32) Type 

func (j RelationalLiteralInt32) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralInt32) Wrap 

func (j RelationalLiteralInt32) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralInt64 

type RelationalLiteralInt64 struct {
	Value int64 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralInt64 represents a RelationalLiteral with signed 64-bit int.

func NewRelationalLiteralInt64 

func NewRelationalLiteralInt64(value int64) *RelationalLiteralInt64

NewRelationalLiteralInt64 creates a RelationalLiteralInt64 instance.

func (RelationalLiteralInt64) ToMap 

func (j RelationalLiteralInt64) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralInt64) Type 

func (j RelationalLiteralInt64) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralInt64) Wrap 

func (j RelationalLiteralInt64) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralInterval 

type RelationalLiteralInterval struct {
	Months      int32 `json:"months"      mapstructure:"months"      yaml:"months"`
	Days        int32 `json:"days"        mapstructure:"days"        yaml:"days"`
	Nanoseconds int64 `json:"nanoseconds" mapstructure:"nanoseconds" yaml:"nanoseconds"`
}

RelationalLiteralInterval represents a RelationalLiteral with Interval represented as months, days, and nanoseconds.

func NewRelationalLiteralInterval 

func NewRelationalLiteralInterval(
	months int32,
	days int32,
	nanoseconds int64,
) *RelationalLiteralInterval

NewRelationalLiteralInterval creates a RelationalLiteralInterval instance.

func (RelationalLiteralInterval) ToMap 

func (j RelationalLiteralInterval) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralInterval) Type 

func (j RelationalLiteralInterval) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralInterval) Wrap 

func (j RelationalLiteralInterval) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralNull 

type RelationalLiteralNull struct{}

RelationalLiteralNull represents a RelationalLiteral null.

func NewRelationalLiteralNull 

func NewRelationalLiteralNull() *RelationalLiteralNull

NewRelationalLiteralNull creates a RelationalLiteralNull instance.

func (RelationalLiteralNull) ToMap 

func (j RelationalLiteralNull) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralNull) Type 

func (j RelationalLiteralNull) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralNull) Wrap 

func (j RelationalLiteralNull) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralString 

type RelationalLiteralString struct {
	Value string `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralString represents a RelationalLiteral with utf-8 encoded string.

func NewRelationalLiteralString 

func NewRelationalLiteralString(value string) *RelationalLiteralString

NewRelationalLiteralString creates a RelationalLiteralString instance.

func (RelationalLiteralString) ToMap 

func (j RelationalLiteralString) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralString) Type 

func (j RelationalLiteralString) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralString) Wrap 

func (j RelationalLiteralString) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralTime32Millisecond 

type RelationalLiteralTime32Millisecond struct {
	Value int32 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralTime32Millisecond represents a RelationalLiteral with Time stored as a signed 32-bit int as seconds since midnight.

func NewRelationalLiteralTime32Millisecond 

func NewRelationalLiteralTime32Millisecond(value int32) *RelationalLiteralTime32Millisecond

NewRelationalLiteralTime32Millisecond creates a RelationalLiteralTime32Millisecond instance.

func (RelationalLiteralTime32Millisecond) ToMap 

func (j RelationalLiteralTime32Millisecond) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralTime32Millisecond) Type 

func (j RelationalLiteralTime32Millisecond) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralTime32Millisecond) Wrap 

func (j RelationalLiteralTime32Millisecond) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralTime32Second 

type RelationalLiteralTime32Second struct {
	Value int32 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralTime32Second represents a RelationalLiteral with Time stored as a signed 32-bit int as seconds since midnight.

func NewRelationalLiteralTime32Second 

func NewRelationalLiteralTime32Second(value int32) *RelationalLiteralTime32Second

NewRelationalLiteralTime32Second creates a RelationalLiteralTime32Second instance.

func (RelationalLiteralTime32Second) ToMap 

func (j RelationalLiteralTime32Second) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralTime32Second) Type 

func (j RelationalLiteralTime32Second) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralTime32Second) Wrap 

func (j RelationalLiteralTime32Second) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralTime64Microsecond 

type RelationalLiteralTime64Microsecond struct {
	Value int64 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralTime64Microsecond represents a RelationalLiteral with Time stored as a signed 64-bit int as microseconds since midnight.

func NewRelationalLiteralTime64Microsecond 

func NewRelationalLiteralTime64Microsecond(value int64) *RelationalLiteralTime64Microsecond

NewRelationalLiteralTime64Microsecond creates a RelationalLiteralTime64Microsecond instance.

func (RelationalLiteralTime64Microsecond) ToMap 

func (j RelationalLiteralTime64Microsecond) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralTime64Microsecond) Type 

func (j RelationalLiteralTime64Microsecond) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralTime64Microsecond) Wrap 

func (j RelationalLiteralTime64Microsecond) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralTime64Nanosecond 

type RelationalLiteralTime64Nanosecond struct {
	Value int64 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralTime64Nanosecond represents a RelationalLiteral with Time stored as a signed 64bit int as nanoseconds since midnight.

func NewRelationalLiteralTime64Nanosecond 

func NewRelationalLiteralTime64Nanosecond(value int64) *RelationalLiteralTime64Nanosecond

NewRelationalLiteralTime64Nanosecond creates a RelationalLiteralTime64Nanosecond instance.

func (RelationalLiteralTime64Nanosecond) ToMap 

func (j RelationalLiteralTime64Nanosecond) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralTime64Nanosecond) Type 

func (j RelationalLiteralTime64Nanosecond) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralTime64Nanosecond) Wrap 

func (j RelationalLiteralTime64Nanosecond) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralTimestampMicrosecond 

type RelationalLiteralTimestampMicrosecond struct {
	Value int64 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralTimestampMicrosecond represents a RelationalLiteral with Timestamp Microseconds.

func NewRelationalLiteralTimestampMicrosecond 

func NewRelationalLiteralTimestampMicrosecond(value int64) *RelationalLiteralTimestampMicrosecond

NewRelationalLiteralTimestampMicrosecond creates a RelationalLiteralTimestampMicrosecond instance.

func (RelationalLiteralTimestampMicrosecond) ToMap 

func (j RelationalLiteralTimestampMicrosecond) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralTimestampMicrosecond) Type 

func (j RelationalLiteralTimestampMicrosecond) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralTimestampMicrosecond) Wrap 

func (j RelationalLiteralTimestampMicrosecond) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralTimestampMillisecond 

type RelationalLiteralTimestampMillisecond struct {
	Value int64 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralTimestampMillisecond represents a RelationalLiteral with Timestamp Milliseconds.

func NewRelationalLiteralTimestampMillisecond 

func NewRelationalLiteralTimestampMillisecond(value int64) *RelationalLiteralTimestampMillisecond

NewRelationalLiteralTimestampMillisecond creates a RelationalLiteralTimestampMillisecond instance.

func (RelationalLiteralTimestampMillisecond) ToMap 

func (j RelationalLiteralTimestampMillisecond) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralTimestampMillisecond) Type 

func (j RelationalLiteralTimestampMillisecond) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralTimestampMillisecond) Wrap 

func (j RelationalLiteralTimestampMillisecond) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralTimestampNanosecond 

type RelationalLiteralTimestampNanosecond struct {
	Value int64 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralTimestampNanosecond represents a RelationalLiteral with Timestamp Nanoseconds.

func NewRelationalLiteralTimestampNanosecond 

func NewRelationalLiteralTimestampNanosecond(value int64) *RelationalLiteralTimestampNanosecond

NewRelationalLiteralTimestampNanosecond creates a RelationalLiteralTimestampNanosecond instance.

func (RelationalLiteralTimestampNanosecond) ToMap 

func (j RelationalLiteralTimestampNanosecond) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralTimestampNanosecond) Type 

func (j RelationalLiteralTimestampNanosecond) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralTimestampNanosecond) Wrap 

func (j RelationalLiteralTimestampNanosecond) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralTimestampSecond 

type RelationalLiteralTimestampSecond struct {
	Value int64 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralTimestampSecond represents a RelationalLiteral with Timestamp Second.

func NewRelationalLiteralTimestampSecond 

func NewRelationalLiteralTimestampSecond(value int64) *RelationalLiteralTimestampSecond

NewRelationalLiteralTimestampSecond creates a RelationalLiteralTimestampSecond instance.

func (RelationalLiteralTimestampSecond) ToMap 

func (j RelationalLiteralTimestampSecond) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralTimestampSecond) Type 

func (j RelationalLiteralTimestampSecond) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralTimestampSecond) Wrap 

func (j RelationalLiteralTimestampSecond) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralType 

type RelationalLiteralType string

RelationalLiteralType represents a relation literal type enum. 

const (
	RelationalLiteralTypeNull                 RelationalLiteralType = "null"
	RelationalLiteralTypeBoolean              RelationalLiteralType = "boolean"
	RelationalLiteralTypeString               RelationalLiteralType = "string"
	RelationalLiteralTypeInt8                 RelationalLiteralType = "int8"
	RelationalLiteralTypeInt16                RelationalLiteralType = "int16"
	RelationalLiteralTypeInt32                RelationalLiteralType = "int32"
	RelationalLiteralTypeInt64                RelationalLiteralType = "int64"
	RelationalLiteralTypeUint8                RelationalLiteralType = "uint8"
	RelationalLiteralTypeUint16               RelationalLiteralType = "uint16"
	RelationalLiteralTypeUint32               RelationalLiteralType = "uint32"
	RelationalLiteralTypeUint64               RelationalLiteralType = "uint64"
	RelationalLiteralTypeFloat32              RelationalLiteralType = "float32"
	RelationalLiteralTypeFloat64              RelationalLiteralType = "float64"
	RelationalLiteralTypeDecimal128           RelationalLiteralType = "decimal128"
	RelationalLiteralTypeDecimal256           RelationalLiteralType = "decimal256"
	RelationalLiteralTypeDate32               RelationalLiteralType = "date32"
	RelationalLiteralTypeDate64               RelationalLiteralType = "date64"
	RelationalLiteralTypeTime32Second         RelationalLiteralType = "time32_second"
	RelationalLiteralTypeTime32Millisecond    RelationalLiteralType = "time32_millisecond"
	RelationalLiteralTypeTime64Microsecond    RelationalLiteralType = "time64_microsecond"
	RelationalLiteralTypeTime64Nanosecond     RelationalLiteralType = "time64_nanosecond"
	RelationalLiteralTypeTimestampSecond      RelationalLiteralType = "timestamp_second"
	RelationalLiteralTypeTimestampMillisecond RelationalLiteralType = "timestamp_millisecond"
	RelationalLiteralTypeTimestampMicrosecond RelationalLiteralType = "timestamp_microsecond"
	RelationalLiteralTypeTimestampNanosecond  RelationalLiteralType = "timestamp_nanosecond"
	RelationalLiteralTypeDurationSecond       RelationalLiteralType = "duration_second"
	RelationalLiteralTypeDurationMillisecond  RelationalLiteralType = "duration_millisecond"
	RelationalLiteralTypeDurationMicrosecond  RelationalLiteralType = "duration_microsecond"
	RelationalLiteralTypeDurationNanosecond   RelationalLiteralType = "duration_nanosecond"
	RelationalLiteralTypeInterval             RelationalLiteralType = "interval"
)

func ParseRelationalLiteralType 

func ParseRelationalLiteralType(input string) (RelationalLiteralType, error)

ParseRelationType parses a relation type from string.

func (RelationalLiteralType) IsValid 

func (j RelationalLiteralType) IsValid() bool

IsValid checks if the value is invalid.

func (*RelationalLiteralType) UnmarshalJSON 

func (j *RelationalLiteralType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalLiteralUint8 

type RelationalLiteralUint8 struct {
	Value uint8 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralUint8 represents a RelationalLiteral with unsigned 8-bit int.

func NewRelationalLiteralUint8 

func NewRelationalLiteralUint8(value uint8) *RelationalLiteralUint8

NewRelationalLiteralUint8 creates a RelationalLiteralUint8 instance.

func (RelationalLiteralUint8) ToMap 

func (j RelationalLiteralUint8) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralUint8) Type 

func (j RelationalLiteralUint8) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralUint8) Wrap 

func (j RelationalLiteralUint8) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralUint16 

type RelationalLiteralUint16 struct {
	Value uint16 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralUint16 represents a RelationalLiteral with unsigned 16-bit int.

func NewRelationalLiteralUint16 

func NewRelationalLiteralUint16(value uint16) *RelationalLiteralUint16

NewRelationalLiteralUint16 creates a RelationalLiteralUint16 instance.

func (RelationalLiteralUint16) ToMap 

func (j RelationalLiteralUint16) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralUint16) Type 

func (j RelationalLiteralUint16) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralUint16) Wrap 

func (j RelationalLiteralUint16) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralUint32 

type RelationalLiteralUint32 struct {
	Value uint32 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralUint32 represents a RelationalLiteral with unsigned 32-bit int.

func NewRelationalLiteralUint32 

func NewRelationalLiteralUint32(value uint32) *RelationalLiteralUint32

NewRelationalLiteralUint32 creates a RelationalLiteralUint32 instance.

func (RelationalLiteralUint32) ToMap 

func (j RelationalLiteralUint32) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralUint32) Type 

func (j RelationalLiteralUint32) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralUint32) Wrap 

func (j RelationalLiteralUint32) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalLiteralUint64 

type RelationalLiteralUint64 struct {
	Value uint64 `json:"value" mapstructure:"value" yaml:"value"`
}

RelationalLiteralUint64 represents a RelationalLiteral with unsigned 64-bit int.

func NewRelationalLiteralUint64 

func NewRelationalLiteralUint64(value uint64) *RelationalLiteralUint64

NewRelationalLiteralUint64 creates a RelationalLiteralUint64 instance.

func (RelationalLiteralUint64) ToMap 

func (j RelationalLiteralUint64) ToMap() map[string]any

ToMap converts the instance to raw Field.

func (RelationalLiteralUint64) Type 

func (j RelationalLiteralUint64) Type() RelationalLiteralType

Type return the type name of the instance.

func (RelationalLiteralUint64) Wrap 

func (j RelationalLiteralUint64) Wrap() RelationalLiteral

Encode returns the relation wrapper.

type RelationalMutationCapabilities 

type RelationalMutationCapabilities struct {
	// Delete corresponds to the JSON schema field "delete".
	Delete *LeafCapability `json:"delete,omitempty" yaml:"delete,omitempty" mapstructure:"delete,omitempty"`

	// Insert corresponds to the JSON schema field "insert".
	Insert *LeafCapability `json:"insert,omitempty" yaml:"insert,omitempty" mapstructure:"insert,omitempty"`

	// Update corresponds to the JSON schema field "update".
	Update *LeafCapability `json:"update,omitempty" yaml:"update,omitempty" mapstructure:"update,omitempty"`
}

Describes which features of the relational mutation API are supported by the connector. This feature is experimental and subject to breaking changes within minor versions.

type RelationalMutationInfo 

type RelationalMutationInfo struct {
	// Whether deletes are supported for this collection
	Deletable bool `json:"deletable" yaml:"deletable" mapstructure:"deletable"`

	// Whether inserts are supported for this collection
	Insertable bool `json:"insertable" yaml:"insertable" mapstructure:"insertable"`

	// Whether updates are supported for this collection
	Updatable bool `json:"updatable" yaml:"updatable" mapstructure:"updatable"`
}

func (*RelationalMutationInfo) UnmarshalJSON 

func (j *RelationalMutationInfo) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalOrderedAggregateFunctionCapabilities 

type RelationalOrderedAggregateFunctionCapabilities struct {
	// Distinct corresponds to the JSON schema field "distinct".
	Distinct *LeafCapability `json:"distinct,omitempty" yaml:"distinct,omitempty" mapstructure:"distinct,omitempty"`

	// OrderBy corresponds to the JSON schema field "order_by".
	OrderBy *LeafCapability `json:"order_by" yaml:"order_by" mapstructure:"order_by"`
}

type RelationalProjectionCapabilities 

type RelationalProjectionCapabilities struct {
	// Expression corresponds to the JSON schema field "expression".
	Expression RelationalExpressionCapabilities `json:"expression" yaml:"expression" mapstructure:"expression"`
}

func (*RelationalProjectionCapabilities) UnmarshalJSON 

func (j *RelationalProjectionCapabilities) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalQuery 

type RelationalQuery struct {
	// Values to be provided to request-level arguments.
	RequestArguments RelationalQueryRequestArguments `json:"request_arguments,omitempty" yaml:"request_arguments,omitempty" mapstructure:"request_arguments,omitempty"`

	// RootRelation corresponds to the JSON schema field "root_relation".
	RootRelation Relation `json:"root_relation" yaml:"root_relation" mapstructure:"root_relation"`
}

func (*RelationalQuery) UnmarshalJSON 

func (j *RelationalQuery) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalQueryCapabilities 

type RelationalQueryCapabilities struct {
	// Aggregate corresponds to the JSON schema field "aggregate".
	Aggregate *LeafCapability `json:"aggregate,omitempty" yaml:"aggregate,omitempty" mapstructure:"aggregate,omitempty"`

	// Filter corresponds to the JSON schema field "filter".
	Filter *LeafCapability `json:"filter,omitempty" yaml:"filter,omitempty" mapstructure:"filter,omitempty"`

	// Join corresponds to the JSON schema field "join".
	Join *LeafCapability `json:"join,omitempty" yaml:"join,omitempty" mapstructure:"join,omitempty"`

	// Project corresponds to the JSON schema field "project".
	Project RelationalProjectionCapabilities `json:"project" yaml:"project" mapstructure:"project"`

	// Sort corresponds to the JSON schema field "sort".
	Sort *LeafCapability `json:"sort,omitempty" yaml:"sort,omitempty" mapstructure:"sort,omitempty"`

	// Union corresponds to the JSON schema field "union".
	Union *LeafCapability `json:"union,omitempty" yaml:"union,omitempty" mapstructure:"union,omitempty"`

	// Window corresponds to the JSON schema field "window".
	Window *LeafCapability `json:"window,omitempty" yaml:"window,omitempty" mapstructure:"window,omitempty"`
}

Describes which features of the relational query API are supported by the connector. This feature is experimental and subject to breaking changes within minor versions.

func (*RelationalQueryCapabilities) UnmarshalJSON 

func (j *RelationalQueryCapabilities) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalQueryRequestArguments 

type RelationalQueryRequestArguments map[string]Argument

Values to be provided to request-level arguments.

type RelationalQueryResponse 

type RelationalQueryResponse struct {
	// Rows corresponds to the JSON schema field "rows".
	Rows [][]interface{} `json:"rows" yaml:"rows" mapstructure:"rows"`
}

func (*RelationalQueryResponse) UnmarshalJSON 

func (j *RelationalQueryResponse) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalScalarExpressionCapabilities 

type RelationalScalarExpressionCapabilities struct {
	// Abs corresponds to the JSON schema field "abs".
	Abs *LeafCapability `json:"abs,omitempty" yaml:"abs,omitempty" mapstructure:"abs,omitempty"`

	// And corresponds to the JSON schema field "and".
	And *LeafCapability `json:"and,omitempty" yaml:"and,omitempty" mapstructure:"and,omitempty"`

	// ArrayElement corresponds to the JSON schema field "array_element".
	ArrayElement *LeafCapability `json:"array_element,omitempty" yaml:"array_element,omitempty" mapstructure:"array_element,omitempty"`

	// BinaryConcat corresponds to the JSON schema field "binary_concat".
	BinaryConcat *LeafCapability `json:"binary_concat,omitempty" yaml:"binary_concat,omitempty" mapstructure:"binary_concat,omitempty"`

	// Btrim corresponds to the JSON schema field "btrim".
	Btrim *LeafCapability `json:"btrim,omitempty" yaml:"btrim,omitempty" mapstructure:"btrim,omitempty"`

	// Ceil corresponds to the JSON schema field "ceil".
	Ceil *LeafCapability `json:"ceil,omitempty" yaml:"ceil,omitempty" mapstructure:"ceil,omitempty"`

	// CharacterLength corresponds to the JSON schema field "character_length".
	CharacterLength *LeafCapability `json:"character_length,omitempty" yaml:"character_length,omitempty" mapstructure:"character_length,omitempty"`

	// Coalesce corresponds to the JSON schema field "coalesce".
	Coalesce *LeafCapability `json:"coalesce,omitempty" yaml:"coalesce,omitempty" mapstructure:"coalesce,omitempty"`

	// Concat corresponds to the JSON schema field "concat".
	Concat *LeafCapability `json:"concat,omitempty" yaml:"concat,omitempty" mapstructure:"concat,omitempty"`

	// Cos corresponds to the JSON schema field "cos".
	Cos *LeafCapability `json:"cos,omitempty" yaml:"cos,omitempty" mapstructure:"cos,omitempty"`

	// CurrentDate corresponds to the JSON schema field "current_date".
	CurrentDate *LeafCapability `json:"current_date,omitempty" yaml:"current_date,omitempty" mapstructure:"current_date,omitempty"`

	// CurrentTime corresponds to the JSON schema field "current_time".
	CurrentTime *LeafCapability `json:"current_time,omitempty" yaml:"current_time,omitempty" mapstructure:"current_time,omitempty"`

	// CurrentTimestamp corresponds to the JSON schema field "current_timestamp".
	CurrentTimestamp *LeafCapability `json:"current_timestamp,omitempty" yaml:"current_timestamp,omitempty" mapstructure:"current_timestamp,omitempty"`

	// DatePart corresponds to the JSON schema field "date_part".
	DatePart *LeafCapability `json:"date_part,omitempty" yaml:"date_part,omitempty" mapstructure:"date_part,omitempty"`

	// DateTrunc corresponds to the JSON schema field "date_trunc".
	DateTrunc *LeafCapability `json:"date_trunc,omitempty" yaml:"date_trunc,omitempty" mapstructure:"date_trunc,omitempty"`

	// Divide corresponds to the JSON schema field "divide".
	Divide *LeafCapability `json:"divide,omitempty" yaml:"divide,omitempty" mapstructure:"divide,omitempty"`

	// Exp corresponds to the JSON schema field "exp".
	Exp *LeafCapability `json:"exp,omitempty" yaml:"exp,omitempty" mapstructure:"exp,omitempty"`

	// Floor corresponds to the JSON schema field "floor".
	Floor *LeafCapability `json:"floor,omitempty" yaml:"floor,omitempty" mapstructure:"floor,omitempty"`

	// GetField corresponds to the JSON schema field "get_field".
	GetField *LeafCapability `json:"get_field,omitempty" yaml:"get_field,omitempty" mapstructure:"get_field,omitempty"`

	// Greatest corresponds to the JSON schema field "greatest".
	Greatest *LeafCapability `json:"greatest,omitempty" yaml:"greatest,omitempty" mapstructure:"greatest,omitempty"`

	// Least corresponds to the JSON schema field "least".
	Least *LeafCapability `json:"least,omitempty" yaml:"least,omitempty" mapstructure:"least,omitempty"`

	// Left corresponds to the JSON schema field "left".
	Left *LeafCapability `json:"left,omitempty" yaml:"left,omitempty" mapstructure:"left,omitempty"`

	// Ln corresponds to the JSON schema field "ln".
	Ln *LeafCapability `json:"ln,omitempty" yaml:"ln,omitempty" mapstructure:"ln,omitempty"`

	// Log corresponds to the JSON schema field "log".
	Log *LeafCapability `json:"log,omitempty" yaml:"log,omitempty" mapstructure:"log,omitempty"`

	// Log10 corresponds to the JSON schema field "log10".
	Log10 *LeafCapability `json:"log10,omitempty" yaml:"log10,omitempty" mapstructure:"log10,omitempty"`

	// Log2 corresponds to the JSON schema field "log2".
	Log2 *LeafCapability `json:"log2,omitempty" yaml:"log2,omitempty" mapstructure:"log2,omitempty"`

	// Lpad corresponds to the JSON schema field "lpad".
	Lpad *LeafCapability `json:"lpad,omitempty" yaml:"lpad,omitempty" mapstructure:"lpad,omitempty"`

	// Ltrim corresponds to the JSON schema field "ltrim".
	Ltrim *LeafCapability `json:"ltrim,omitempty" yaml:"ltrim,omitempty" mapstructure:"ltrim,omitempty"`

	// Minus corresponds to the JSON schema field "minus".
	Minus *LeafCapability `json:"minus,omitempty" yaml:"minus,omitempty" mapstructure:"minus,omitempty"`

	// Modulo corresponds to the JSON schema field "modulo".
	Modulo *LeafCapability `json:"modulo,omitempty" yaml:"modulo,omitempty" mapstructure:"modulo,omitempty"`

	// Multiply corresponds to the JSON schema field "multiply".
	Multiply *LeafCapability `json:"multiply,omitempty" yaml:"multiply,omitempty" mapstructure:"multiply,omitempty"`

	// Negate corresponds to the JSON schema field "negate".
	Negate *LeafCapability `json:"negate,omitempty" yaml:"negate,omitempty" mapstructure:"negate,omitempty"`

	// Not corresponds to the JSON schema field "not".
	Not *LeafCapability `json:"not,omitempty" yaml:"not,omitempty" mapstructure:"not,omitempty"`

	// Nvl corresponds to the JSON schema field "nvl".
	Nvl *LeafCapability `json:"nvl,omitempty" yaml:"nvl,omitempty" mapstructure:"nvl,omitempty"`

	// Or corresponds to the JSON schema field "or".
	Or *LeafCapability `json:"or,omitempty" yaml:"or,omitempty" mapstructure:"or,omitempty"`

	// Plus corresponds to the JSON schema field "plus".
	Plus *LeafCapability `json:"plus,omitempty" yaml:"plus,omitempty" mapstructure:"plus,omitempty"`

	// Power corresponds to the JSON schema field "power".
	Power *LeafCapability `json:"power,omitempty" yaml:"power,omitempty" mapstructure:"power,omitempty"`

	// Random corresponds to the JSON schema field "random".
	Random *LeafCapability `json:"random,omitempty" yaml:"random,omitempty" mapstructure:"random,omitempty"`

	// Replace corresponds to the JSON schema field "replace".
	Replace *LeafCapability `json:"replace,omitempty" yaml:"replace,omitempty" mapstructure:"replace,omitempty"`

	// Reverse corresponds to the JSON schema field "reverse".
	Reverse *LeafCapability `json:"reverse,omitempty" yaml:"reverse,omitempty" mapstructure:"reverse,omitempty"`

	// Right corresponds to the JSON schema field "right".
	Right *LeafCapability `json:"right,omitempty" yaml:"right,omitempty" mapstructure:"right,omitempty"`

	// Round corresponds to the JSON schema field "round".
	Round *LeafCapability `json:"round,omitempty" yaml:"round,omitempty" mapstructure:"round,omitempty"`

	// Rpad corresponds to the JSON schema field "rpad".
	Rpad *LeafCapability `json:"rpad,omitempty" yaml:"rpad,omitempty" mapstructure:"rpad,omitempty"`

	// Rtrim corresponds to the JSON schema field "rtrim".
	Rtrim *LeafCapability `json:"rtrim,omitempty" yaml:"rtrim,omitempty" mapstructure:"rtrim,omitempty"`

	// Sqrt corresponds to the JSON schema field "sqrt".
	Sqrt *LeafCapability `json:"sqrt,omitempty" yaml:"sqrt,omitempty" mapstructure:"sqrt,omitempty"`

	// StrPos corresponds to the JSON schema field "str_pos".
	StrPos *LeafCapability `json:"str_pos,omitempty" yaml:"str_pos,omitempty" mapstructure:"str_pos,omitempty"`

	// Substr corresponds to the JSON schema field "substr".
	Substr *LeafCapability `json:"substr,omitempty" yaml:"substr,omitempty" mapstructure:"substr,omitempty"`

	// SubstrIndex corresponds to the JSON schema field "substr_index".
	SubstrIndex *LeafCapability `json:"substr_index,omitempty" yaml:"substr_index,omitempty" mapstructure:"substr_index,omitempty"`

	// Tan corresponds to the JSON schema field "tan".
	Tan *LeafCapability `json:"tan,omitempty" yaml:"tan,omitempty" mapstructure:"tan,omitempty"`

	// ToDate corresponds to the JSON schema field "to_date".
	ToDate *LeafCapability `json:"to_date,omitempty" yaml:"to_date,omitempty" mapstructure:"to_date,omitempty"`

	// ToLower corresponds to the JSON schema field "to_lower".
	ToLower *LeafCapability `json:"to_lower,omitempty" yaml:"to_lower,omitempty" mapstructure:"to_lower,omitempty"`

	// ToTimestamp corresponds to the JSON schema field "to_timestamp".
	ToTimestamp *LeafCapability `json:"to_timestamp,omitempty" yaml:"to_timestamp,omitempty" mapstructure:"to_timestamp,omitempty"`

	// ToUpper corresponds to the JSON schema field "to_upper".
	ToUpper *LeafCapability `json:"to_upper,omitempty" yaml:"to_upper,omitempty" mapstructure:"to_upper,omitempty"`

	// Trunc corresponds to the JSON schema field "trunc".
	Trunc *LeafCapability `json:"trunc,omitempty" yaml:"trunc,omitempty" mapstructure:"trunc,omitempty"`
}

type RelationalScalarTypeCapabilities 

type RelationalScalarTypeCapabilities struct {
	// Does the connector support `from_type` in cast?
	FromType *LeafCapability `json:"from_type,omitempty" yaml:"from_type,omitempty" mapstructure:"from_type,omitempty"`

	// Does the connector support the INTERVAL scalar type? Both interval literals and
	// casts to the INTERVAL type are implied by this capability.
	Interval *LeafCapability `json:"interval,omitempty" yaml:"interval,omitempty" mapstructure:"interval,omitempty"`
}

type RelationalSortCapabilities 

type RelationalSortCapabilities struct {
	// Expression corresponds to the JSON schema field "expression".
	Expression RelationalExpressionCapabilities `json:"expression" yaml:"expression" mapstructure:"expression"`
}

func (*RelationalSortCapabilities) UnmarshalJSON 

func (j *RelationalSortCapabilities) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalUpdateRequest 

type RelationalUpdateRequest struct {
	// Values to be provided to any collection arguments
	Arguments RelationalUpdateRequestArguments `json:"arguments" yaml:"arguments" mapstructure:"arguments"`

	// The name of the collection to update
	Collection string `json:"collection" yaml:"collection" mapstructure:"collection"`

	// The relation that identifies which rows to update
	Relation Relation `json:"relation" yaml:"relation" mapstructure:"relation"`
}

func (*RelationalUpdateRequest) UnmarshalJSON 

func (j *RelationalUpdateRequest) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalUpdateRequestArguments 

type RelationalUpdateRequestArguments map[string]Argument

Values to be provided to any collection arguments

type RelationalUpdateResponse 

type RelationalUpdateResponse struct {
	// The number of rows that were updated
	AffectedRows int `json:"affected_rows" yaml:"affected_rows" mapstructure:"affected_rows"`
}

func (*RelationalUpdateResponse) UnmarshalJSON 

func (j *RelationalUpdateResponse) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalWindowCapabilities 

type RelationalWindowCapabilities struct {
	// Expression corresponds to the JSON schema field "expression".
	Expression RelationalExpressionCapabilities `json:"expression" yaml:"expression" mapstructure:"expression"`
}

func (*RelationalWindowCapabilities) UnmarshalJSON 

func (j *RelationalWindowCapabilities) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationalWindowExpressionCapabilities 

type RelationalWindowExpressionCapabilities struct {
	// CumeDist corresponds to the JSON schema field "cume_dist".
	CumeDist *LeafCapability `json:"cume_dist,omitempty" yaml:"cume_dist,omitempty" mapstructure:"cume_dist,omitempty"`

	// DenseRank corresponds to the JSON schema field "dense_rank".
	DenseRank *LeafCapability `json:"dense_rank,omitempty" yaml:"dense_rank,omitempty" mapstructure:"dense_rank,omitempty"`

	// Ntile corresponds to the JSON schema field "ntile".
	Ntile *LeafCapability `json:"ntile,omitempty" yaml:"ntile,omitempty" mapstructure:"ntile,omitempty"`

	// PercentRank corresponds to the JSON schema field "percent_rank".
	PercentRank *LeafCapability `json:"percent_rank,omitempty" yaml:"percent_rank,omitempty" mapstructure:"percent_rank,omitempty"`

	// Rank corresponds to the JSON schema field "rank".
	Rank *LeafCapability `json:"rank,omitempty" yaml:"rank,omitempty" mapstructure:"rank,omitempty"`

	// RowNumber corresponds to the JSON schema field "row_number".
	RowNumber *LeafCapability `json:"row_number,omitempty" yaml:"row_number,omitempty" mapstructure:"row_number,omitempty"`
}

type Relationship 

type Relationship struct {
	// Values to be provided to any collection arguments
	Arguments RelationshipArguments `json:"arguments" yaml:"arguments" mapstructure:"arguments"`

	// A mapping between columns on the source row to columns on the target
	// collection. The column on the target collection is specified via a field path
	// (ie. an array of field names that descend through nested object fields). The
	// field path will only contain a single item, meaning a column on the target
	// collection's type, unless the 'relationships.nested' capability is supported,
	// in which case multiple items denotes a nested object field.
	ColumnMapping RelationshipColumnMapping `json:"column_mapping" yaml:"column_mapping" mapstructure:"column_mapping"`

	// RelationshipType corresponds to the JSON schema field "relationship_type".
	RelationshipType RelationshipType `json:"relationship_type" yaml:"relationship_type" mapstructure:"relationship_type"`

	// The name of a collection
	TargetCollection string `json:"target_collection" yaml:"target_collection" mapstructure:"target_collection"`
}

func (*Relationship) UnmarshalJSON 

func (j *Relationship) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationshipArgument 

type RelationshipArgument map[string]any

RelationshipArgument is provided by reference to a variable or as a literal value.

func (RelationshipArgument) AsColumn 

func (j RelationshipArgument) AsColumn() (*RelationshipArgumentColumn, error)

AsColumn converts the instance to RelationshipArgumentColumn.

func (RelationshipArgument) AsLiteral 

func (j RelationshipArgument) AsLiteral() (*RelationshipArgumentLiteral, error)

AsLiteral converts the instance to RelationshipArgumentLiteral.

func (RelationshipArgument) AsVariable 

func (j RelationshipArgument) AsVariable() (*RelationshipArgumentVariable, error)

AsVariable converts the instance to RelationshipArgumentVariable.

func (*RelationshipArgument) FromValue 

func (j *RelationshipArgument) FromValue(raw map[string]any) error

FromValue decodes the raw object value to the instance.

func (RelationshipArgument) Interface 

func (j RelationshipArgument) Interface() RelationshipArgumentEncoder

Interface converts the comparison value to its generic interface.

func (RelationshipArgument) InterfaceT 

func (j RelationshipArgument) InterfaceT() (RelationshipArgumentEncoder, error)

InterfaceT converts the comparison value to its generic interface safely with explicit error.

func (RelationshipArgument) Type 

func (j RelationshipArgument) Type() (RelationshipArgumentType, error)

Type gets the type enum of the current type.

func (*RelationshipArgument) UnmarshalJSON 

func (j *RelationshipArgument) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationshipArgumentColumn 

type RelationshipArgumentColumn struct {
	Name string `json:"name" mapstructure:"name" yaml:"name"`
}

RelationshipArgumentColumn represents the column relationship argument.

func NewRelationshipArgumentColumn 

func NewRelationshipArgumentColumn(name string) *RelationshipArgumentColumn

NewRelationshipArgumentColumn creates a RelationshipArgumentColumn instance.

func (RelationshipArgumentColumn) Encode 

func (j RelationshipArgumentColumn) Encode() RelationshipArgument

Encode converts the instance to raw Field.

func (RelationshipArgumentColumn) Type 

func (j RelationshipArgumentColumn) Type() RelationshipArgumentType

Type return the type name of the instance.

type RelationshipArgumentEncoder 

type RelationshipArgumentEncoder interface {
	Type() RelationshipArgumentType
	Encode() RelationshipArgument
}

RelationshipArgumentEncoder abstracts the interface for RelationshipArgument.

type RelationshipArgumentLiteral 

type RelationshipArgumentLiteral struct {
	Value any `json:"value" mapstructure:"value" yaml:"value"`
}

RelationshipArgumentLiteral represents the literal relationship argument.

func NewRelationshipArgumentLiteral 

func NewRelationshipArgumentLiteral(value any) *RelationshipArgumentLiteral

NewRelationshipArgumentLiteral creates a RelationshipArgumentLiteral instance.

func (RelationshipArgumentLiteral) Encode 

func (j RelationshipArgumentLiteral) Encode() RelationshipArgument

Encode converts the instance to raw Field.

func (RelationshipArgumentLiteral) Type 

func (j RelationshipArgumentLiteral) Type() RelationshipArgumentType

Type return the type name of the instance.

type RelationshipArgumentType 

type RelationshipArgumentType string

RelationshipArgumentType represents a relationship argument type enum. 

const (
	RelationshipArgumentTypeLiteral  RelationshipArgumentType = "literal"
	RelationshipArgumentTypeVariable RelationshipArgumentType = "variable"
	RelationshipArgumentTypeColumn   RelationshipArgumentType = "column"
)

func ParseRelationshipArgumentType 

func ParseRelationshipArgumentType(input string) (RelationshipArgumentType, error)

ParseRelationshipArgumentType parses a relationship argument type from string.

func (RelationshipArgumentType) IsValid 

func (j RelationshipArgumentType) IsValid() bool

IsValid checks if the value is invalid.

func (*RelationshipArgumentType) UnmarshalJSON 

func (j *RelationshipArgumentType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RelationshipArgumentVariable 

type RelationshipArgumentVariable struct {
	Name string `json:"name" mapstructure:"name" yaml:"name"`
}

RelationshipArgumentVariable represents the variable relationship argument.

func NewRelationshipArgumentVariable 

func NewRelationshipArgumentVariable(name string) *RelationshipArgumentVariable

NewRelationshipArgumentVariable creates a RelationshipArgumentVariable instance.

func (RelationshipArgumentVariable) Encode 

func (j RelationshipArgumentVariable) Encode() RelationshipArgument

Encode converts the instance to raw Field.

func (RelationshipArgumentVariable) Type 

func (j RelationshipArgumentVariable) Type() RelationshipArgumentType

Type return the type name of the instance.

type RelationshipArguments 

type RelationshipArguments map[string]RelationshipArgument

Values to be provided to any collection arguments

type RelationshipCapabilities 

type RelationshipCapabilities struct {
	// Does the connector support navigating a relationship from inside a nested
	// object
	Nested *NestedRelationshipCapabilities `json:"nested,omitempty" yaml:"nested,omitempty" mapstructure:"nested,omitempty"`

	// Does the connector support ordering by an aggregated array relationship?
	OrderByAggregate *LeafCapability `json:"order_by_aggregate" yaml:"order_by_aggregate" mapstructure:"order_by_aggregate"`

	// Does the connector support comparisons that involve related collections (ie.
	// joins)?
	RelationComparisons *LeafCapability `json:"relation_comparisons" yaml:"relation_comparisons" mapstructure:"relation_comparisons"`
}

type RelationshipColumnMapping 

type RelationshipColumnMapping map[string][]string

A mapping between columns on the source row to columns on the target collection. The column on the target collection is specified via a field path (ie. an array of field names that descend through nested object fields). The field path will only contain a single item, meaning a column on the target collection's type, unless the 'relationships.nested' capability is supported, in which case multiple items denotes a nested object field.

type RelationshipField 

type RelationshipField struct {
	// The relationship query
	Query Query `json:"query"        mapstructure:"query"        yaml:"query"`
	// The name of the relationship to follow for the subquery
	Relationship string `json:"relationship" mapstructure:"relationship" yaml:"relationship"`
	// Values to be provided to any collection arguments
	Arguments map[string]RelationshipArgument `json:"arguments"    mapstructure:"arguments"    yaml:"arguments"`
}

RelationshipField represents a relationship field.

func NewRelationshipField 

func NewRelationshipField(
	query Query,
	relationship string,
	arguments map[string]RelationshipArgument,
) *RelationshipField

NewRelationshipField creates a new RelationshipField instance.

func (RelationshipField) Encode 

func (f RelationshipField) Encode() Field

Encode converts the instance to raw Field.

func (RelationshipField) Type 

func (f RelationshipField) Type() FieldType

Type return the type name of the instance.

type RelationshipType 

type RelationshipType string
const RelationshipTypeArray RelationshipType = "array"
const RelationshipTypeObject RelationshipType = "object"

func (*RelationshipType) UnmarshalJSON 

func (j *RelationshipType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RequestLevelArguments 

type RequestLevelArguments struct {
	// Any arguments that all Mutation requests require
	MutationArguments RequestLevelArgumentsMutationArguments `json:"mutation_arguments" yaml:"mutation_arguments" mapstructure:"mutation_arguments"`

	// Any arguments that all Query requests require
	QueryArguments RequestLevelArgumentsQueryArguments `json:"query_arguments" yaml:"query_arguments" mapstructure:"query_arguments"`

	// Any arguments that all Relational Query requests require
	RelationalQueryArguments RequestLevelArgumentsRelationalQueryArguments `json:"relational_query_arguments" yaml:"relational_query_arguments" mapstructure:"relational_query_arguments"`
}

func (*RequestLevelArguments) UnmarshalJSON 

func (j *RequestLevelArguments) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type RequestLevelArgumentsMutationArguments 

type RequestLevelArgumentsMutationArguments map[string]ArgumentInfo

Any arguments that all Mutation requests require

type RequestLevelArgumentsQueryArguments 

type RequestLevelArgumentsQueryArguments map[string]ArgumentInfo

Any arguments that all Query requests require

type RequestLevelArgumentsRelationalQueryArguments 

type RequestLevelArgumentsRelationalQueryArguments map[string]ArgumentInfo

Any arguments that all Relational Query requests require

type RowSet 

type RowSet struct {
	// The results of the aggregates returned by the query
	Aggregates RowSetAggregates `json:"aggregates,omitempty" yaml:"aggregates,omitempty" mapstructure:"aggregates,omitempty"`

	// The results of any grouping operation
	Groups []Group `json:"groups,omitempty" yaml:"groups,omitempty" mapstructure:"groups,omitempty"`

	// The rows returned by the query, corresponding to the query's fields
	Rows []map[string]any `json:"rows,omitempty" yaml:"rows,omitempty" mapstructure:"rows,omitempty"`
}

func (RowSet) MarshalJSON 

func (j RowSet) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler.

func (RowSet) ToMap 

func (j RowSet) ToMap() map[string]any

ToMap encodes the struct to a value map.

type RowSetAggregates 

type RowSetAggregates map[string]interface{}

The results of the aggregates returned by the query

type ScalarType 

type ScalarType struct {
	// A map from aggregate function names to their definitions. Result type names
	// must be defined scalar types declared in ScalarTypesCapabilities.
	AggregateFunctions ScalarTypeAggregateFunctions `json:"aggregate_functions" yaml:"aggregate_functions" mapstructure:"aggregate_functions"`

	// A map from comparison operator names to their definitions. Argument type names
	// must be defined scalar types declared in ScalarTypesCapabilities.
	ComparisonOperators map[string]ComparisonOperatorDefinition `json:"comparison_operators" yaml:"comparison_operators" mapstructure:"comparison_operators"`

	// A map from extraction function names to their definitions.
	ExtractionFunctions ScalarTypeExtractionFunctions `json:"extraction_functions,omitempty" yaml:"extraction_functions,omitempty" mapstructure:"extraction_functions,omitempty"`

	// A description of valid values for this scalar type.
	Representation TypeRepresentation `json:"representation" yaml:"representation" mapstructure:"representation"`
}

The definition of a scalar type, i.e. types that can be used as the types of columns.

func NewScalarType 

func NewScalarType() *ScalarType

NewScalarType creates an empty ScalarType instance.

func (*ScalarType) UnmarshalJSON 

func (j *ScalarType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ScalarTypeAggregateFunctions 

type ScalarTypeAggregateFunctions map[string]AggregateFunctionDefinition

A map from aggregate function names to their definitions. Result type names must be defined scalar types declared in ScalarTypesCapabilities.

type ScalarTypeExtractionFunctions 

type ScalarTypeExtractionFunctions map[string]ExtractionFunctionDefinition

A map from extraction function names to their definitions.

type SchemaPatchedJson 

type SchemaPatchedJson struct {
	// CapabilitiesResponse corresponds to the JSON schema field
	// "capabilities_response".
	CapabilitiesResponse CapabilitiesResponse `json:"capabilities_response" yaml:"capabilities_response" mapstructure:"capabilities_response"`

	// ErrorResponse corresponds to the JSON schema field "error_response".
	ErrorResponse ErrorResponse `json:"error_response" yaml:"error_response" mapstructure:"error_response"`

	// ExplainResponse corresponds to the JSON schema field "explain_response".
	ExplainResponse ExplainResponse `json:"explain_response" yaml:"explain_response" mapstructure:"explain_response"`

	// MutationRequest corresponds to the JSON schema field "mutation_request".
	MutationRequest MutationRequest `json:"mutation_request" yaml:"mutation_request" mapstructure:"mutation_request"`

	// MutationResponse corresponds to the JSON schema field "mutation_response".
	MutationResponse MutationResponse `json:"mutation_response" yaml:"mutation_response" mapstructure:"mutation_response"`

	// QueryRequest corresponds to the JSON schema field "query_request".
	QueryRequest QueryRequest `json:"query_request" yaml:"query_request" mapstructure:"query_request"`

	// QueryResponse corresponds to the JSON schema field "query_response".
	QueryResponse QueryResponse `json:"query_response" yaml:"query_response" mapstructure:"query_response"`

	// RelationalDeleteRequest corresponds to the JSON schema field
	// "relational_delete_request".
	RelationalDeleteRequest RelationalDeleteRequest `json:"relational_delete_request" yaml:"relational_delete_request" mapstructure:"relational_delete_request"`

	// RelationalDeleteResponse corresponds to the JSON schema field
	// "relational_delete_response".
	RelationalDeleteResponse RelationalDeleteResponse `json:"relational_delete_response" yaml:"relational_delete_response" mapstructure:"relational_delete_response"`

	// RelationalInsertRequest corresponds to the JSON schema field
	// "relational_insert_request".
	RelationalInsertRequest RelationalInsertRequest `json:"relational_insert_request" yaml:"relational_insert_request" mapstructure:"relational_insert_request"`

	// RelationalInsertResponse corresponds to the JSON schema field
	// "relational_insert_response".
	RelationalInsertResponse RelationalInsertResponse `json:"relational_insert_response" yaml:"relational_insert_response" mapstructure:"relational_insert_response"`

	// RelationalQuery corresponds to the JSON schema field "relational_query".
	RelationalQuery RelationalQuery `json:"relational_query" yaml:"relational_query" mapstructure:"relational_query"`

	// RelationalQueryResponse corresponds to the JSON schema field
	// "relational_query_response".
	RelationalQueryResponse RelationalQueryResponse `json:"relational_query_response" yaml:"relational_query_response" mapstructure:"relational_query_response"`

	// RelationalUpdateRequest corresponds to the JSON schema field
	// "relational_update_request".
	RelationalUpdateRequest RelationalUpdateRequest `json:"relational_update_request" yaml:"relational_update_request" mapstructure:"relational_update_request"`

	// RelationalUpdateResponse corresponds to the JSON schema field
	// "relational_update_response".
	RelationalUpdateResponse RelationalUpdateResponse `json:"relational_update_response" yaml:"relational_update_response" mapstructure:"relational_update_response"`

	// SchemaResponse corresponds to the JSON schema field "schema_response".
	SchemaResponse SchemaResponse `json:"schema_response" yaml:"schema_response" mapstructure:"schema_response"`

	// ValidateResponse corresponds to the JSON schema field "validate_response".
	ValidateResponse ValidateResponse `json:"validate_response" yaml:"validate_response" mapstructure:"validate_response"`
}

func (*SchemaPatchedJson) UnmarshalJSON 

func (j *SchemaPatchedJson) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type SchemaResponse 

type SchemaResponse struct {
	// Schema data which is relevant to features enabled by capabilities
	Capabilities *CapabilitySchemaInfo `json:"capabilities,omitempty" yaml:"capabilities,omitempty" mapstructure:"capabilities,omitempty"`

	// Collections which are available for queries
	Collections []CollectionInfo `json:"collections" yaml:"collections" mapstructure:"collections"`

	// Functions (i.e. collections which return a single column and row)
	Functions []FunctionInfo `json:"functions" yaml:"functions" mapstructure:"functions"`

	// A list of object types which can be used as the types of arguments, or return
	// types of procedures. Names should not overlap with scalar type names.
	ObjectTypes SchemaResponseObjectTypes `json:"object_types" yaml:"object_types" mapstructure:"object_types"`

	// Procedures which are available for execution as part of mutations
	Procedures []ProcedureInfo `json:"procedures" yaml:"procedures" mapstructure:"procedures"`

	// Request level arguments which are required for queries and mutations
	RequestArguments *RequestLevelArguments `json:"request_arguments,omitempty" yaml:"request_arguments,omitempty" mapstructure:"request_arguments,omitempty"`

	// A list of scalar types which will be used as the types of collection columns
	ScalarTypes SchemaResponseScalarTypes `json:"scalar_types" yaml:"scalar_types" mapstructure:"scalar_types"`
}

func (SchemaResponse) MarshalSchemaJSON 

func (j SchemaResponse) MarshalSchemaJSON() ([]byte, error)

MarshalSchemaJSON encodes the NDC schema response to JSON.

func (*SchemaResponse) UnmarshalJSON 

func (j *SchemaResponse) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type SchemaResponseMarshaler 

type SchemaResponseMarshaler interface {
	MarshalSchemaJSON() ([]byte, error)
}

SchemaResponseMarshaler abstract the response for /schema handler.

type SchemaResponseObjectTypes 

type SchemaResponseObjectTypes map[string]ObjectType

A list of object types which can be used as the types of arguments, or return types of procedures. Names should not overlap with scalar type names.

type SchemaResponseScalarTypes 

type SchemaResponseScalarTypes map[string]ScalarType

A list of scalar types which will be used as the types of collection columns

type Sort 

type Sort struct {
	// Direction corresponds to the JSON schema field "direction".
	Direction OrderDirection `json:"direction" yaml:"direction" mapstructure:"direction"`

	// Expr corresponds to the JSON schema field "expr".
	Expr RelationalExpression `json:"expr" yaml:"expr" mapstructure:"expr"`

	// NullsSort corresponds to the JSON schema field "nulls_sort".
	NullsSort NullsSort `json:"nulls_sort" yaml:"nulls_sort" mapstructure:"nulls_sort"`
}

func (*Sort) UnmarshalJSON 

func (j *Sort) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type Type 

type Type map[string]any

Types track the valid representations of values as JSON.

func UnwrapNullableType 

func UnwrapNullableType(input Type) Type

UnwrapNullableType unwraps nullable types from the input type recursively.

func (Type) AsArray 

func (ty Type) AsArray() (*ArrayType, error)

AsArray tries to convert the current type to ArrayType.

func (Type) AsNamed 

func (ty Type) AsNamed() (*NamedType, error)

AsNamed tries to convert the current type to NamedType.

func (Type) AsNullable 

func (ty Type) AsNullable() (*NullableType, error)

AsNullable tries to convert the current type to NullableType.

func (Type) AsPredicate 

func (ty Type) AsPredicate() (*PredicateType, error)

AsPredicate tries to convert the current type to PredicateType.

func (Type) Interface 

func (ty Type) Interface() TypeEncoder

Interface converts the instance to the TypeEncoder interface.

func (Type) InterfaceT 

func (ty Type) InterfaceT() (TypeEncoder, error)

InterfaceT converts the instance to the TypeEncoder interface safely with explicit error.

func (Type) IsZero 

func (ty Type) IsZero() bool

IsZero checks whether is the instance is empty.

func (Type) String 

func (ty Type) String() string

String implements the fmt.Stringer interface.

func (Type) Type 

func (ty Type) Type() (TypeEnum, error)

Type gets the type enum of the current type.

func (*Type) UnmarshalJSON 

func (j *Type) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type TypeEncoder 

type TypeEncoder interface {
	Type() TypeEnum
	Encode() Type
}

TypeEncoder abstracts the Type interface.

type TypeEnum 

type TypeEnum string
const (
	TypeNamed     TypeEnum = "named"
	TypeNullable  TypeEnum = "nullable"
	TypeArray     TypeEnum = "array"
	TypePredicate TypeEnum = "predicate"
)

func ParseTypeEnum 

func ParseTypeEnum(input string) (TypeEnum, error)

ParseTypeEnum parses a type enum from string.

func (TypeEnum) IsValid 

func (j TypeEnum) IsValid() bool

IsValid checks if the value is invalid.

func (*TypeEnum) UnmarshalJSON 

func (j *TypeEnum) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type TypeRepresentation 

type TypeRepresentation map[string]any

Representations of scalar types.

func (TypeRepresentation) AsBigDecimal 

func (ty TypeRepresentation) AsBigDecimal() (*TypeRepresentationBigDecimal, error)

AsBigDecimal tries to convert the current type to TypeRepresentationBigDecimal.

func (TypeRepresentation) AsBigInteger 

func (ty TypeRepresentation) AsBigInteger() (*TypeRepresentationBigInteger, error)

AsBigInteger tries to convert the current type to TypeRepresentationBigInteger.

func (TypeRepresentation) AsBoolean 

func (ty TypeRepresentation) AsBoolean() (*TypeRepresentationBoolean, error)

AsBoolean tries to convert the current type to TypeRepresentationBoolean.

func (TypeRepresentation) AsBytes 

func (ty TypeRepresentation) AsBytes() (*TypeRepresentationBytes, error)

AsBytes tries to convert the current type to TypeRepresentationBytes.

func (TypeRepresentation) AsDate 

func (ty TypeRepresentation) AsDate() (*TypeRepresentationDate, error)

AsDate tries to convert the current type to TypeRepresentationDate.

func (TypeRepresentation) AsEnum 

func (ty TypeRepresentation) AsEnum() (*TypeRepresentationEnum, error)

AsEnum tries to convert the current type to TypeRepresentationEnum.

func (TypeRepresentation) AsFloat32 

func (ty TypeRepresentation) AsFloat32() (*TypeRepresentationFloat32, error)

AsFloat32 tries to convert the current type to TypeRepresentationFloat32.

func (TypeRepresentation) AsFloat64 

func (ty TypeRepresentation) AsFloat64() (*TypeRepresentationFloat64, error)

AsFloat64 tries to convert the current type to TypeRepresentationFloat64.

func (TypeRepresentation) AsGeography 

func (ty TypeRepresentation) AsGeography() (*TypeRepresentationGeography, error)

AsGeography tries to convert the current type to TypeRepresentationGeography.

func (TypeRepresentation) AsGeometry 

func (ty TypeRepresentation) AsGeometry() (*TypeRepresentationGeometry, error)

AsGeometry tries to convert the current type to TypeRepresentationGeometry.

func (TypeRepresentation) AsInt8 

func (ty TypeRepresentation) AsInt8() (*TypeRepresentationInt8, error)

AsInt8 tries to convert the current type to TypeRepresentationInt8.

func (TypeRepresentation) AsInt16 

func (ty TypeRepresentation) AsInt16() (*TypeRepresentationInt16, error)

AsInt16 tries to convert the current type to TypeRepresentationInt16.

func (TypeRepresentation) AsInt32 

func (ty TypeRepresentation) AsInt32() (*TypeRepresentationInt32, error)

AsInt32 tries to convert the current type to TypeRepresentationInt32.

func (TypeRepresentation) AsInt64 

func (ty TypeRepresentation) AsInt64() (*TypeRepresentationInt64, error)

AsInt64 tries to convert the current type to TypeRepresentationInt64.

func (TypeRepresentation) AsJSON 

func (ty TypeRepresentation) AsJSON() (*TypeRepresentationJSON, error)

AsJSON tries to convert the current type to TypeRepresentationJSON.

func (TypeRepresentation) AsString 

func (ty TypeRepresentation) AsString() (*TypeRepresentationString, error)

AsString tries to convert the current type to TypeRepresentationString.

func (TypeRepresentation) AsTimestamp 

func (ty TypeRepresentation) AsTimestamp() (*TypeRepresentationTimestamp, error)

AsTimestamp tries to convert the current type to TypeRepresentationTimestamp.

func (TypeRepresentation) AsTimestampTZ 

func (ty TypeRepresentation) AsTimestampTZ() (*TypeRepresentationTimestampTZ, error)

AsTimestampTZ tries to convert the current type to TypeRepresentationTimestampTZ.

func (TypeRepresentation) AsUUID 

func (ty TypeRepresentation) AsUUID() (*TypeRepresentationUUID, error)

AsUUID tries to convert the current type to TypeRepresentationUUID.

func (TypeRepresentation) Interface 

func (ty TypeRepresentation) Interface() TypeRepresentationEncoder

Interface converts the instance to the TypeRepresentationEncoder interface.

func (TypeRepresentation) InterfaceT 

func (ty TypeRepresentation) InterfaceT() (TypeRepresentationEncoder, error)

InterfaceT converts the instance to the TypeRepresentationEncoder interface safely with explicit error.

func (TypeRepresentation) Type 

func (ty TypeRepresentation) Type() (TypeRepresentationType, error)

Type gets the type enum of the current type.

func (*TypeRepresentation) UnmarshalJSON 

func (j *TypeRepresentation) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type TypeRepresentationBigDecimal 

type TypeRepresentationBigDecimal struct{}

TypeRepresentationBigDecimal represents an arbitrary-precision decimal string.

func NewTypeRepresentationBigDecimal 

func NewTypeRepresentationBigDecimal() *TypeRepresentationBigDecimal

NewTypeRepresentationBigDecimal creates a new TypeRepresentationBigDecimal instance.

func (TypeRepresentationBigDecimal) Encode 

func (ty TypeRepresentationBigDecimal) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationBigDecimal) Type 

func (ty TypeRepresentationBigDecimal) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationBigInteger 

type TypeRepresentationBigInteger struct{}

TypeRepresentationBigInteger represents an arbitrary-precision integer string.

func NewTypeRepresentationBigInteger 

func NewTypeRepresentationBigInteger() *TypeRepresentationBigInteger

NewTypeRepresentationBigInteger creates a new TypeRepresentationBigInteger instance.

func (TypeRepresentationBigInteger) Encode 

func (ty TypeRepresentationBigInteger) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationBigInteger) Type 

func (ty TypeRepresentationBigInteger) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationBoolean 

type TypeRepresentationBoolean struct{}

TypeRepresentationBoolean represents a JSON boolean type representation.

func NewTypeRepresentationBoolean 

func NewTypeRepresentationBoolean() *TypeRepresentationBoolean

NewTypeRepresentationBoolean creates a new TypeRepresentationBoolean instance.

func (TypeRepresentationBoolean) Encode 

func (ty TypeRepresentationBoolean) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationBoolean) Type 

func (ty TypeRepresentationBoolean) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationBytes 

type TypeRepresentationBytes struct{}

TypeRepresentationBytes represent a base64-encoded bytes.

func NewTypeRepresentationBytes 

func NewTypeRepresentationBytes() *TypeRepresentationBytes

NewTypeRepresentationBytes creates a new TypeRepresentationBytes instance.

func (TypeRepresentationBytes) Encode 

func (ty TypeRepresentationBytes) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationBytes) Type 

func (ty TypeRepresentationBytes) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationDate 

type TypeRepresentationDate struct{}

TypeRepresentationDate represents an ISO 8601 date.

func NewTypeRepresentationDate 

func NewTypeRepresentationDate() *TypeRepresentationDate

NewTypeRepresentationDate creates a new TypeRepresentationDate instance.

func (TypeRepresentationDate) Encode 

func (ty TypeRepresentationDate) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationDate) Type 

func (ty TypeRepresentationDate) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationEncoder 

type TypeRepresentationEncoder interface {
	Type() TypeRepresentationType
	Encode() TypeRepresentation
}

TypeRepresentationEncoder abstracts the TypeRepresentation interface.

type TypeRepresentationEnum 

type TypeRepresentationEnum struct {
	OneOf []string `json:"one_of" mapstructure:"one_of" yaml:"one_of"`
}

TypeRepresentationEnum represents an enum type representation.

func NewTypeRepresentationEnum 

func NewTypeRepresentationEnum(oneOf []string) *TypeRepresentationEnum

NewTypeRepresentationEnum creates a new TypeRepresentationEnum instance.

func (TypeRepresentationEnum) Encode 

func (ty TypeRepresentationEnum) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationEnum) Type 

func (ty TypeRepresentationEnum) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationFloat32 

type TypeRepresentationFloat32 struct{}

TypeRepresentationFloat32 represents an IEEE-754 single-precision floating-point number.

func NewTypeRepresentationFloat32 

func NewTypeRepresentationFloat32() *TypeRepresentationFloat32

NewTypeRepresentationFloat32 creates a new TypeRepresentationFloat32 instance.

func (TypeRepresentationFloat32) Encode 

func (ty TypeRepresentationFloat32) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationFloat32) Type 

func (ty TypeRepresentationFloat32) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationFloat64 

type TypeRepresentationFloat64 struct{}

TypeRepresentationFloat64 represents an IEEE-754 double-precision floating-point number.

func NewTypeRepresentationFloat64 

func NewTypeRepresentationFloat64() *TypeRepresentationFloat64

NewTypeRepresentationFloat64 creates a new TypeRepresentationFloat64 instance.

func (TypeRepresentationFloat64) Encode 

func (ty TypeRepresentationFloat64) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationFloat64) Type 

func (ty TypeRepresentationFloat64) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationGeography 

type TypeRepresentationGeography struct{}

TypeRepresentationGeography represents a geography JSON object.

func NewTypeRepresentationGeography 

func NewTypeRepresentationGeography() *TypeRepresentationGeography

NewTypeRepresentationGeography creates a new TypeRepresentationGeography instance.

func (TypeRepresentationGeography) Encode 

func (ty TypeRepresentationGeography) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationGeography) Type 

func (ty TypeRepresentationGeography) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationGeometry 

type TypeRepresentationGeometry struct{}

TypeRepresentationGeometry represents a geography JSON object.

func NewTypeRepresentationGeometry 

func NewTypeRepresentationGeometry() *TypeRepresentationGeometry

NewTypeRepresentationGeometry creates a new TypeRepresentationGeometry instance.

func (TypeRepresentationGeometry) Encode 

func (ty TypeRepresentationGeometry) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationGeometry) Type 

func (ty TypeRepresentationGeometry) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationInt8 

type TypeRepresentationInt8 struct{}

TypeRepresentationInt8 represents a 8-bit signed integer with a minimum value of -2^7 and a maximum value of 2^7 - 1.

func NewTypeRepresentationInt8 

func NewTypeRepresentationInt8() *TypeRepresentationInt8

NewTypeRepresentationInt8 creates a new TypeRepresentationInt8 instance.

func (TypeRepresentationInt8) Encode 

func (ty TypeRepresentationInt8) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationInt8) Type 

func (ty TypeRepresentationInt8) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationInt16 

type TypeRepresentationInt16 struct{}

TypeRepresentationInt16 represents a 16-bit signed integer with a minimum value of -2^15 and a maximum value of 2^15 - 1.

func NewTypeRepresentationInt16 

func NewTypeRepresentationInt16() *TypeRepresentationInt16

NewTypeRepresentationInt16 creates a new TypeRepresentationInt16 instance.

func (TypeRepresentationInt16) Encode 

func (ty TypeRepresentationInt16) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationInt16) Type 

func (ty TypeRepresentationInt16) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationInt32 

type TypeRepresentationInt32 struct{}

TypeRepresentationInt32 represents a 32-bit signed integer with a minimum value of -2^31 and a maximum value of 2^31 - 1.

func NewTypeRepresentationInt32 

func NewTypeRepresentationInt32() *TypeRepresentationInt32

NewTypeRepresentationInt32 creates a new TypeRepresentationInt32 instance.

func (TypeRepresentationInt32) Encode 

func (ty TypeRepresentationInt32) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationInt32) Type 

func (ty TypeRepresentationInt32) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationInt64 

type TypeRepresentationInt64 struct{}

TypeRepresentationInt64 represents a 64-bit signed integer with a minimum value of -2^63 and a maximum value of 2^63 - 1.

func NewTypeRepresentationInt64 

func NewTypeRepresentationInt64() *TypeRepresentationInt64

NewTypeRepresentationInt64 creates a new TypeRepresentationInt64 instance.

func (TypeRepresentationInt64) Encode 

func (ty TypeRepresentationInt64) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationInt64) Type 

func (ty TypeRepresentationInt64) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationJSON 

type TypeRepresentationJSON struct{}

TypeRepresentationJSON represents an arbitrary JSON.

func NewTypeRepresentationJSON 

func NewTypeRepresentationJSON() *TypeRepresentationJSON

NewTypeRepresentationJSON creates a new TypeRepresentationBytes instance.

func (TypeRepresentationJSON) Encode 

func (ty TypeRepresentationJSON) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationJSON) Type 

func (ty TypeRepresentationJSON) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationString 

type TypeRepresentationString struct{}

TypeRepresentationString represents a JSON string type representation.

func NewTypeRepresentationString 

func NewTypeRepresentationString() *TypeRepresentationString

NewTypeRepresentationString creates a new TypeRepresentationString instance.

func (TypeRepresentationString) Encode 

func (ty TypeRepresentationString) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationString) Type 

func (ty TypeRepresentationString) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationTimestamp 

type TypeRepresentationTimestamp struct{}

TypeRepresentationTimestamp represents an ISO 8601 timestamp.

func NewTypeRepresentationTimestamp 

func NewTypeRepresentationTimestamp() *TypeRepresentationTimestamp

NewTypeRepresentationTimestamp creates a new TypeRepresentationTimestamp instance.

func (TypeRepresentationTimestamp) Encode 

func (ty TypeRepresentationTimestamp) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationTimestamp) Type 

func (ty TypeRepresentationTimestamp) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationTimestampTZ 

type TypeRepresentationTimestampTZ struct{}

TypeRepresentationTimestampTZ represents an ISO 8601 timestamp-with-timezone.

func NewTypeRepresentationTimestampTZ 

func NewTypeRepresentationTimestampTZ() *TypeRepresentationTimestampTZ

NewTypeRepresentationTimestampTZ creates a new TypeRepresentationTimestampTZ instance.

func (TypeRepresentationTimestampTZ) Encode 

func (ty TypeRepresentationTimestampTZ) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationTimestampTZ) Type 

func (ty TypeRepresentationTimestampTZ) Type() TypeRepresentationType

Type return the type name of the instance.

type TypeRepresentationType 

type TypeRepresentationType string

TypeRepresentationType represents the type enum of TypeRepresentation. 

const (
	// JSON booleans.
	TypeRepresentationTypeBoolean TypeRepresentationType = "boolean"
	// JSON booleans.
	TypeRepresentationTypeString TypeRepresentationType = "string"
	// One of the specified string values.
	TypeRepresentationTypeEnum TypeRepresentationType = "enum"
	// A 8-bit signed integer with a minimum value of -2^7 and a maximum value of 2^7 - 1.
	TypeRepresentationTypeInt8 TypeRepresentationType = "int8"
	// A 16-bit signed integer with a minimum value of -2^15 and a maximum value of 2^15 - 1.
	TypeRepresentationTypeInt16 TypeRepresentationType = "int16"
	// A 32-bit signed integer with a minimum value of -2^31 and a maximum value of 2^31 - 1.
	TypeRepresentationTypeInt32 TypeRepresentationType = "int32"
	// A 64-bit signed integer with a minimum value of -2^63 and a maximum value of 2^63 - 1.
	TypeRepresentationTypeInt64 TypeRepresentationType = "int64"
	// An IEEE-754 single-precision floating-point number.
	TypeRepresentationTypeFloat32 TypeRepresentationType = "float32"
	// An IEEE-754 double-precision floating-point number.
	TypeRepresentationTypeFloat64 TypeRepresentationType = "float64"
	// Arbitrary-precision integer string.
	TypeRepresentationTypeBigInteger TypeRepresentationType = "biginteger"
	// Arbitrary-precision decimal string.
	TypeRepresentationTypeBigDecimal TypeRepresentationType = "bigdecimal"
	// UUID string (8-4-4-4-12).
	TypeRepresentationTypeUUID TypeRepresentationType = "uuid"
	// ISO 8601 date.
	TypeRepresentationTypeDate TypeRepresentationType = "date"
	// ISO 8601 timestamp.
	TypeRepresentationTypeTimestamp TypeRepresentationType = "timestamp"
	// ISO 8601 timestamp-with-timezone.
	TypeRepresentationTypeTimestampTZ TypeRepresentationType = "timestamptz"
	// GeoJSON, per RFC 7946.
	TypeRepresentationTypeGeography TypeRepresentationType = "geography"
	// GeoJSON Geometry object, per RFC 7946.
	TypeRepresentationTypeGeometry TypeRepresentationType = "geometry"
	// Base64-encoded bytes.
	TypeRepresentationTypeBytes TypeRepresentationType = "bytes"
	// Arbitrary JSON.
	TypeRepresentationTypeJSON TypeRepresentationType = "json"
)

func ParseTypeRepresentationType 

func ParseTypeRepresentationType(input string) (TypeRepresentationType, error)

ParseTypeRepresentationType parses a TypeRepresentationType enum from string.

func (TypeRepresentationType) IsValid 

func (j TypeRepresentationType) IsValid() bool

IsValid checks if the value is invalid.

func (*TypeRepresentationType) UnmarshalJSON 

func (j *TypeRepresentationType) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type TypeRepresentationUUID 

type TypeRepresentationUUID struct{}

TypeRepresentationUUID represents an UUID string (8-4-4-4-12).

func NewTypeRepresentationUUID 

func NewTypeRepresentationUUID() *TypeRepresentationUUID

NewTypeRepresentationUUID creates a new TypeRepresentationUUID instance.

func (TypeRepresentationUUID) Encode 

func (ty TypeRepresentationUUID) Encode() TypeRepresentation

Encode returns the raw TypeRepresentation instance.

func (TypeRepresentationUUID) Type 

func (ty TypeRepresentationUUID) Type() TypeRepresentationType

Type return the type name of the instance.

type UnaryComparisonOperator 

type UnaryComparisonOperator string
const UnaryComparisonOperatorIsNull UnaryComparisonOperator = "is_null"

func (*UnaryComparisonOperator) UnmarshalJSON 

func (j *UnaryComparisonOperator) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type UniquenessConstraint 

type UniquenessConstraint struct {
	// A list of columns which this constraint requires to be unique
	UniqueColumns []string `json:"unique_columns" yaml:"unique_columns" mapstructure:"unique_columns"`
}

func (*UniquenessConstraint) UnmarshalJSON 

func (j *UniquenessConstraint) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

type ValidateResponse 

type ValidateResponse struct {
	// Capabilities corresponds to the JSON schema field "capabilities".
	Capabilities CapabilitiesResponse `json:"capabilities" yaml:"capabilities" mapstructure:"capabilities"`

	// ResolvedConfiguration corresponds to the JSON schema field
	// "resolved_configuration".
	ResolvedConfiguration string `json:"resolved_configuration" yaml:"resolved_configuration" mapstructure:"resolved_configuration"`

	// Schema corresponds to the JSON schema field "schema".
	Schema SchemaResponse `json:"schema" yaml:"schema" mapstructure:"schema"`
}

func (*ValidateResponse) UnmarshalJSON 

func (j *ValidateResponse) UnmarshalJSON(b []byte) error

UnmarshalJSON implements json.Unmarshaler.

Source Files

View all Source files

Jump to

Keyboard shortcuts

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