Documentation

Overview

Package entql provides an experimental API for interacting dynamically with ent queries. For more info, search for it in https://entgo.io.

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type BinaryExpr

type BinaryExpr struct {
	Op   Op
	X, Y Expr
}

A BinaryExpr represents a binary expression.

func (*BinaryExpr) Negate

func (e *BinaryExpr) Negate() P

Negate negates the predicate.

func (*BinaryExpr) String

func (e *BinaryExpr) String() string

String returns the text representation of a binary expression.

type BoolP

type BoolP interface {
	Fielder
	// contains filtered or unexported methods
}

BoolP is the interface for predicates of type bool (`type P[bool]`).

func BoolAnd

func BoolAnd(x, y BoolP, z ...BoolP) BoolP

BoolAnd returns a composed predicate that represents the logical AND predicate.

func BoolEQ

func BoolEQ(v bool) BoolP

BoolEQ applies the EQ operation on the given value.

func BoolNEQ

func BoolNEQ(v bool) BoolP

BoolNEQ applies the NEQ operation on the given value.

func BoolNot

func BoolNot(x BoolP) BoolP

BoolNot returns a predicate that represents the logical negation of the given predicate.

func BoolOr

func BoolOr(x, y BoolP, z ...BoolP) BoolP

BoolOr returns a composed predicate that represents the logical OR predicate.

type BytesP

type BytesP interface {
	Fielder
	// contains filtered or unexported methods
}

BytesP is the interface for predicates of type []byte (`type P[[]byte]`).

func BytesAnd

func BytesAnd(x, y BytesP, z ...BytesP) BytesP

BytesAnd returns a composed predicate that represents the logical AND predicate.

func BytesEQ

func BytesEQ(v []byte) BytesP

BytesEQ applies the EQ operation on the given value.

func BytesNEQ

func BytesNEQ(v []byte) BytesP

BytesNEQ applies the NEQ operation on the given value.

func BytesNot

func BytesNot(x BytesP) BytesP

BytesNot returns a predicate that represents the logical negation of the given predicate.

func BytesOr

func BytesOr(x, y BytesP, z ...BytesP) BytesP

BytesOr returns a composed predicate that represents the logical OR predicate.

type CallExpr

type CallExpr struct {
	Func Func
	Args []Expr
}

A CallExpr represents a function call with its arguments.

func (*CallExpr) Negate

func (e *CallExpr) Negate() P

Negate negates the predicate.

func (*CallExpr) String

func (e *CallExpr) String() string

String returns the text representation of a call expression.

type Edge

type Edge struct {
	Name string
}

An Edge represents an edge in the graph.

func (*Edge) String

func (e *Edge) String() string

String returns the text representation of an edge.

type Expr

type Expr interface {
	fmt.Stringer
	// contains filtered or unexported methods
}

Expr represents an entql expression. All expressions implement the Expr interface.

type Field

type Field struct {
	Name string
}

A Field represents a node field.

func F

func F(name string) *Field

F returns a field expression for the given name.

func (*Field) String

func (f *Field) String() string

String returns the text representation of a field.

type Fielder

type Fielder interface {
	Field(string) P
}

Fielder is the interface for creating a predicate (entql.P) by a field name from the different builder types below.

type Float32P

type Float32P interface {
	Fielder
	// contains filtered or unexported methods
}

Float32P is the interface for predicates of type float32 (`type P[float32]`).

func Float32And

func Float32And(x, y Float32P, z ...Float32P) Float32P

Float32And returns a composed predicate that represents the logical AND predicate.

func Float32EQ

func Float32EQ(v float32) Float32P

Float32EQ applies the EQ operation on the given value.

func Float32GT

func Float32GT(v float32) Float32P

Float32GT applies the GT operation on the given value.

func Float32GTE

func Float32GTE(v float32) Float32P

Float32GTE applies the GTE operation on the given value.

func Float32LT

func Float32LT(v float32) Float32P

Float32LT applies the LT operation on the given value.

func Float32LTE

func Float32LTE(v float32) Float32P

Float32LTE applies the LTE operation on the given value.

func Float32NEQ

func Float32NEQ(v float32) Float32P

Float32NEQ applies the NEQ operation on the given value.

func Float32Not

func Float32Not(x Float32P) Float32P

Float32Not returns a predicate that represents the logical negation of the given predicate.

func Float32Or

func Float32Or(x, y Float32P, z ...Float32P) Float32P

Float32Or returns a composed predicate that represents the logical OR predicate.

type Float64P

type Float64P interface {
	Fielder
	// contains filtered or unexported methods
}

Float64P is the interface for predicates of type float64 (`type P[float64]`).

func Float64And

func Float64And(x, y Float64P, z ...Float64P) Float64P

Float64And returns a composed predicate that represents the logical AND predicate.

func Float64EQ

func Float64EQ(v float64) Float64P

Float64EQ applies the EQ operation on the given value.

func Float64GT

func Float64GT(v float64) Float64P

Float64GT applies the GT operation on the given value.

func Float64GTE

func Float64GTE(v float64) Float64P

Float64GTE applies the GTE operation on the given value.

func Float64LT

func Float64LT(v float64) Float64P

Float64LT applies the LT operation on the given value.

func Float64LTE

func Float64LTE(v float64) Float64P

Float64LTE applies the LTE operation on the given value.

func Float64NEQ

func Float64NEQ(v float64) Float64P

Float64NEQ applies the NEQ operation on the given value.

func Float64Not

func Float64Not(x Float64P) Float64P

Float64Not returns a predicate that represents the logical negation of the given predicate.

func Float64Or

func Float64Or(x, y Float64P, z ...Float64P) Float64P

Float64Or returns a composed predicate that represents the logical OR predicate.

type Func

type Func string

A Func represents a function expression.

const (
	FuncEqualFold    Func = "equal_fold"    // equals case-insensitive
	FuncContains     Func = "contains"      // containing
	FuncContainsFold Func = "contains_fold" // containing case-insensitive
	FuncHasPrefix    Func = "has_prefix"    // startingWith
	FuncHasSuffix    Func = "has_suffix"    // endingWith
	FuncHasEdge      Func = "has_edge"      // HasEdge
)

Builtin functions.

type Int16P

type Int16P interface {
	Fielder
	// contains filtered or unexported methods
}

Int16P is the interface for predicates of type int16 (`type P[int16]`).

func Int16And

func Int16And(x, y Int16P, z ...Int16P) Int16P

Int16And returns a composed predicate that represents the logical AND predicate.

func Int16EQ

func Int16EQ(v int16) Int16P

Int16EQ applies the EQ operation on the given value.

func Int16GT

func Int16GT(v int16) Int16P

Int16GT applies the GT operation on the given value.

func Int16GTE

func Int16GTE(v int16) Int16P

Int16GTE applies the GTE operation on the given value.

func Int16LT

func Int16LT(v int16) Int16P

Int16LT applies the LT operation on the given value.

func Int16LTE

func Int16LTE(v int16) Int16P

Int16LTE applies the LTE operation on the given value.

func Int16NEQ

func Int16NEQ(v int16) Int16P

Int16NEQ applies the NEQ operation on the given value.

func Int16Not

func Int16Not(x Int16P) Int16P

Int16Not returns a predicate that represents the logical negation of the given predicate.

func Int16Or

func Int16Or(x, y Int16P, z ...Int16P) Int16P

Int16Or returns a composed predicate that represents the logical OR predicate.

type Int32P

type Int32P interface {
	Fielder
	// contains filtered or unexported methods
}

Int32P is the interface for predicates of type int32 (`type P[int32]`).

func Int32And

func Int32And(x, y Int32P, z ...Int32P) Int32P

Int32And returns a composed predicate that represents the logical AND predicate.

func Int32EQ

func Int32EQ(v int32) Int32P

Int32EQ applies the EQ operation on the given value.

func Int32GT

func Int32GT(v int32) Int32P

Int32GT applies the GT operation on the given value.

func Int32GTE

func Int32GTE(v int32) Int32P

Int32GTE applies the GTE operation on the given value.

func Int32LT

func Int32LT(v int32) Int32P

Int32LT applies the LT operation on the given value.

func Int32LTE

func Int32LTE(v int32) Int32P

Int32LTE applies the LTE operation on the given value.

func Int32NEQ

func Int32NEQ(v int32) Int32P

Int32NEQ applies the NEQ operation on the given value.

func Int32Not

func Int32Not(x Int32P) Int32P

Int32Not returns a predicate that represents the logical negation of the given predicate.

func Int32Or

func Int32Or(x, y Int32P, z ...Int32P) Int32P

Int32Or returns a composed predicate that represents the logical OR predicate.

type Int64P

type Int64P interface {
	Fielder
	// contains filtered or unexported methods
}

Int64P is the interface for predicates of type int64 (`type P[int64]`).

func Int64And

func Int64And(x, y Int64P, z ...Int64P) Int64P

Int64And returns a composed predicate that represents the logical AND predicate.

func Int64EQ

func Int64EQ(v int64) Int64P

Int64EQ applies the EQ operation on the given value.

func Int64GT

func Int64GT(v int64) Int64P

Int64GT applies the GT operation on the given value.

func Int64GTE

func Int64GTE(v int64) Int64P

Int64GTE applies the GTE operation on the given value.

func Int64LT

func Int64LT(v int64) Int64P

Int64LT applies the LT operation on the given value.

func Int64LTE

func Int64LTE(v int64) Int64P

Int64LTE applies the LTE operation on the given value.

func Int64NEQ

func Int64NEQ(v int64) Int64P

Int64NEQ applies the NEQ operation on the given value.

func Int64Not

func Int64Not(x Int64P) Int64P

Int64Not returns a predicate that represents the logical negation of the given predicate.

func Int64Or

func Int64Or(x, y Int64P, z ...Int64P) Int64P

Int64Or returns a composed predicate that represents the logical OR predicate.

type Int8P

type Int8P interface {
	Fielder
	// contains filtered or unexported methods
}

Int8P is the interface for predicates of type int8 (`type P[int8]`).

func Int8And

func Int8And(x, y Int8P, z ...Int8P) Int8P

Int8And returns a composed predicate that represents the logical AND predicate.

func Int8EQ

func Int8EQ(v int8) Int8P

Int8EQ applies the EQ operation on the given value.

func Int8GT

func Int8GT(v int8) Int8P

Int8GT applies the GT operation on the given value.

func Int8GTE

func Int8GTE(v int8) Int8P

Int8GTE applies the GTE operation on the given value.

func Int8LT

func Int8LT(v int8) Int8P

Int8LT applies the LT operation on the given value.

func Int8LTE

func Int8LTE(v int8) Int8P

Int8LTE applies the LTE operation on the given value.

func Int8NEQ

func Int8NEQ(v int8) Int8P

Int8NEQ applies the NEQ operation on the given value.

func Int8Not

func Int8Not(x Int8P) Int8P

Int8Not returns a predicate that represents the logical negation of the given predicate.

func Int8Or

func Int8Or(x, y Int8P, z ...Int8P) Int8P

Int8Or returns a composed predicate that represents the logical OR predicate.

type IntP

type IntP interface {
	Fielder
	// contains filtered or unexported methods
}

IntP is the interface for predicates of type int (`type P[int]`).

func IntAnd

func IntAnd(x, y IntP, z ...IntP) IntP

IntAnd returns a composed predicate that represents the logical AND predicate.

func IntEQ

func IntEQ(v int) IntP

IntEQ applies the EQ operation on the given value.

func IntGT

func IntGT(v int) IntP

IntGT applies the GT operation on the given value.

func IntGTE

func IntGTE(v int) IntP

IntGTE applies the GTE operation on the given value.

func IntLT

func IntLT(v int) IntP

IntLT applies the LT operation on the given value.

func IntLTE

func IntLTE(v int) IntP

IntLTE applies the LTE operation on the given value.

func IntNEQ

func IntNEQ(v int) IntP

IntNEQ applies the NEQ operation on the given value.

func IntNot

func IntNot(x IntP) IntP

IntNot returns a predicate that represents the logical negation of the given predicate.

func IntOr

func IntOr(x, y IntP, z ...IntP) IntP

IntOr returns a composed predicate that represents the logical OR predicate.

type NaryExpr

type NaryExpr struct {
	Op Op
	Xs []Expr
}

A NaryExpr represents a n-ary expression.

func (*NaryExpr) Negate

func (e *NaryExpr) Negate() P

Negate negates the predicate.

func (*NaryExpr) String

func (e *NaryExpr) String() string

String returns the text representation of an n-ary expression.

type Op

type Op int

An Op represents a predicate operator.

const (
	OpAnd   Op = iota // logical and.
	OpOr              // logical or.
	OpNot             // logical negation.
	OpEQ              // =
	OpNEQ             // <>
	OpGT              // >
	OpGTE             // >=
	OpLT              // <
	OpLTE             // <=
	OpIn              // IN
	OpNotIn           // NOT IN
)

Builtin operators.

func (Op) String

func (o Op) String() string

String returns the text representation of an operator.

type P

type P interface {
	Expr
	Negate() P
}

P represents an expression that returns a boolean value depending on its variables.

func And

func And(x, y P, z ...P) P

And returns a composed predicate that represents the logical AND predicate.

func EQ

func EQ(x, y Expr) P

EQ returns a predicate to check if the expressions are equal.

func FieldContains

func FieldContains(name, substr string) P

FieldContains returns a predicate to check if the field value contains a substr.

func FieldContainsFold

func FieldContainsFold(name, substr string) P

FieldContainsFold returns a predicate to check if the field value contains a substr under case-folding.

func FieldEQ

func FieldEQ(name string, v interface{}) P

FieldEQ returns a predicate to check if a field is equivalent to a given value.

func FieldEqualFold

func FieldEqualFold(name, v string) P

FieldEqualFold returns a predicate to check if the field is equal to the given string under case-folding.

func FieldGT

func FieldGT(name string, v interface{}) P

FieldGT returns a predicate to check if a field is > than the given value.

func FieldGTE

func FieldGTE(name string, v interface{}) P

FieldGTE returns a predicate to check if a field is >= than the given value.

func FieldHasPrefix

func FieldHasPrefix(name, prefix string) P

FieldHasPrefix returns a predicate to check if the field starts with the given prefix.

func FieldHasSuffix

func FieldHasSuffix(name, suffix string) P

FieldHasSuffix returns a predicate to check if the field ends with the given suffix.

func FieldIn

func FieldIn(name string, vs ...interface{}) P

FieldIn returns a predicate to check if the field value matches any value in the given list.

func FieldLT

func FieldLT(name string, v interface{}) P

FieldLT returns a predicate to check if a field is < than the given value.

func FieldLTE

func FieldLTE(name string, v interface{}) P

FieldLTE returns a predicate to check if a field is <= >than the given value.

func FieldNEQ

func FieldNEQ(name string, v interface{}) P

FieldNEQ returns a predicate to check if a field is not equivalent to a given value.

func FieldNil

func FieldNil(name string) P

FieldNil returns a predicate to check if a field is nil (null in databases).

func FieldNotIn

func FieldNotIn(name string, vs ...interface{}) P

FieldNotIn returns a predicate to check if the field value doesn't match any value in the given list.

func FieldNotNil

func FieldNotNil(name string) P

FieldNotNil returns a predicate to check if a field is not nil (not null in databases).

func GT

func GT(x, y Expr) P

GT returns a predicate to check if the expression x > than expression y.

func GTE

func GTE(x, y Expr) P

GTE returns a predicate to check if the expression x >= than expression y.

func HasEdge

func HasEdge(name string) P

HasEdge returns a predicate to check if an edge exists (not null in databases).

func HasEdgeWith

func HasEdgeWith(name string, p ...P) P

HasEdgeWith returns a predicate to check if the "other nodes" that are connected to the edge returns true on the provided predicate.

func LT

func LT(x, y Expr) P

LT returns a predicate to check if the expression x < than expression y.

func LTE

func LTE(x, y Expr) P

LTE returns a predicate to check if the expression x <= than expression y.

func NEQ

func NEQ(x, y Expr) P

NEQ returns a predicate to check if the expressions are not equal.

func Not

func Not(x P) P

Not returns a predicate that represents the logical negation of the given predicate.

func Or

func Or(x, y P, z ...P) P

Or returns a composed predicate that represents the logical OR predicate.

type StringP

type StringP interface {
	Fielder
	// contains filtered or unexported methods
}

StringP is the interface for predicates of type string (`type P[string]`).

func StringAnd

func StringAnd(x, y StringP, z ...StringP) StringP

StringAnd returns a composed predicate that represents the logical AND predicate.

func StringEQ

func StringEQ(v string) StringP

StringEQ applies the EQ operation on the given value.

func StringGT

func StringGT(v string) StringP

StringGT applies the GT operation on the given value.

func StringGTE

func StringGTE(v string) StringP

StringGTE applies the GTE operation on the given value.

func StringLT

func StringLT(v string) StringP

StringLT applies the LT operation on the given value.

func StringLTE

func StringLTE(v string) StringP

StringLTE applies the LTE operation on the given value.

func StringNEQ

func StringNEQ(v string) StringP

StringNEQ applies the NEQ operation on the given value.

func StringNot

func StringNot(x StringP) StringP

StringNot returns a predicate that represents the logical negation of the given predicate.

func StringOr

func StringOr(x, y StringP, z ...StringP) StringP

StringOr returns a composed predicate that represents the logical OR predicate.

type TimeP

type TimeP interface {
	Fielder
	// contains filtered or unexported methods
}

TimeP is the interface for predicates of type time.Time (`type P[time.Time]`).

func TimeAnd

func TimeAnd(x, y TimeP, z ...TimeP) TimeP

TimeAnd returns a composed predicate that represents the logical AND predicate.

func TimeEQ

func TimeEQ(v time.Time) TimeP

TimeEQ applies the EQ operation on the given value.

func TimeGT

func TimeGT(v time.Time) TimeP

TimeGT applies the GT operation on the given value.

func TimeGTE

func TimeGTE(v time.Time) TimeP

TimeGTE applies the GTE operation on the given value.

func TimeLT

func TimeLT(v time.Time) TimeP

TimeLT applies the LT operation on the given value.

func TimeLTE

func TimeLTE(v time.Time) TimeP

TimeLTE applies the LTE operation on the given value.

func TimeNEQ

func TimeNEQ(v time.Time) TimeP

TimeNEQ applies the NEQ operation on the given value.

func TimeNot

func TimeNot(x TimeP) TimeP

TimeNot returns a predicate that represents the logical negation of the given predicate.

func TimeOr

func TimeOr(x, y TimeP, z ...TimeP) TimeP

TimeOr returns a composed predicate that represents the logical OR predicate.

type Uint16P

type Uint16P interface {
	Fielder
	// contains filtered or unexported methods
}

Uint16P is the interface for predicates of type uint16 (`type P[uint16]`).

func Uint16And

func Uint16And(x, y Uint16P, z ...Uint16P) Uint16P

Uint16And returns a composed predicate that represents the logical AND predicate.

func Uint16EQ

func Uint16EQ(v uint16) Uint16P

Uint16EQ applies the EQ operation on the given value.

func Uint16GT

func Uint16GT(v uint16) Uint16P

Uint16GT applies the GT operation on the given value.

func Uint16GTE

func Uint16GTE(v uint16) Uint16P

Uint16GTE applies the GTE operation on the given value.

func Uint16LT

func Uint16LT(v uint16) Uint16P

Uint16LT applies the LT operation on the given value.

func Uint16LTE

func Uint16LTE(v uint16) Uint16P

Uint16LTE applies the LTE operation on the given value.

func Uint16NEQ

func Uint16NEQ(v uint16) Uint16P

Uint16NEQ applies the NEQ operation on the given value.

func Uint16Not

func Uint16Not(x Uint16P) Uint16P

Uint16Not returns a predicate that represents the logical negation of the given predicate.

func Uint16Or

func Uint16Or(x, y Uint16P, z ...Uint16P) Uint16P

Uint16Or returns a composed predicate that represents the logical OR predicate.

type Uint32P

type Uint32P interface {
	Fielder
	// contains filtered or unexported methods
}

Uint32P is the interface for predicates of type uint32 (`type P[uint32]`).

func Uint32And

func Uint32And(x, y Uint32P, z ...Uint32P) Uint32P

Uint32And returns a composed predicate that represents the logical AND predicate.

func Uint32EQ

func Uint32EQ(v uint32) Uint32P

Uint32EQ applies the EQ operation on the given value.

func Uint32GT

func Uint32GT(v uint32) Uint32P

Uint32GT applies the GT operation on the given value.

func Uint32GTE

func Uint32GTE(v uint32) Uint32P

Uint32GTE applies the GTE operation on the given value.

func Uint32LT

func Uint32LT(v uint32) Uint32P

Uint32LT applies the LT operation on the given value.

func Uint32LTE

func Uint32LTE(v uint32) Uint32P

Uint32LTE applies the LTE operation on the given value.

func Uint32NEQ

func Uint32NEQ(v uint32) Uint32P

Uint32NEQ applies the NEQ operation on the given value.

func Uint32Not

func Uint32Not(x Uint32P) Uint32P

Uint32Not returns a predicate that represents the logical negation of the given predicate.

func Uint32Or

func Uint32Or(x, y Uint32P, z ...Uint32P) Uint32P

Uint32Or returns a composed predicate that represents the logical OR predicate.

type Uint64P

type Uint64P interface {
	Fielder
	// contains filtered or unexported methods
}

Uint64P is the interface for predicates of type uint64 (`type P[uint64]`).

func Uint64And

func Uint64And(x, y Uint64P, z ...Uint64P) Uint64P

Uint64And returns a composed predicate that represents the logical AND predicate.

func Uint64EQ

func Uint64EQ(v uint64) Uint64P

Uint64EQ applies the EQ operation on the given value.

func Uint64GT

func Uint64GT(v uint64) Uint64P

Uint64GT applies the GT operation on the given value.

func Uint64GTE

func Uint64GTE(v uint64) Uint64P

Uint64GTE applies the GTE operation on the given value.

func Uint64LT

func Uint64LT(v uint64) Uint64P

Uint64LT applies the LT operation on the given value.

func Uint64LTE

func Uint64LTE(v uint64) Uint64P

Uint64LTE applies the LTE operation on the given value.

func Uint64NEQ

func Uint64NEQ(v uint64) Uint64P

Uint64NEQ applies the NEQ operation on the given value.

func Uint64Not

func Uint64Not(x Uint64P) Uint64P

Uint64Not returns a predicate that represents the logical negation of the given predicate.

func Uint64Or

func Uint64Or(x, y Uint64P, z ...Uint64P) Uint64P

Uint64Or returns a composed predicate that represents the logical OR predicate.

type Uint8P

type Uint8P interface {
	Fielder
	// contains filtered or unexported methods
}

Uint8P is the interface for predicates of type uint8 (`type P[uint8]`).

func Uint8And

func Uint8And(x, y Uint8P, z ...Uint8P) Uint8P

Uint8And returns a composed predicate that represents the logical AND predicate.

func Uint8EQ

func Uint8EQ(v uint8) Uint8P

Uint8EQ applies the EQ operation on the given value.

func Uint8GT

func Uint8GT(v uint8) Uint8P

Uint8GT applies the GT operation on the given value.

func Uint8GTE

func Uint8GTE(v uint8) Uint8P

Uint8GTE applies the GTE operation on the given value.

func Uint8LT

func Uint8LT(v uint8) Uint8P

Uint8LT applies the LT operation on the given value.

func Uint8LTE

func Uint8LTE(v uint8) Uint8P

Uint8LTE applies the LTE operation on the given value.

func Uint8NEQ

func Uint8NEQ(v uint8) Uint8P

Uint8NEQ applies the NEQ operation on the given value.

func Uint8Not

func Uint8Not(x Uint8P) Uint8P

Uint8Not returns a predicate that represents the logical negation of the given predicate.

func Uint8Or

func Uint8Or(x, y Uint8P, z ...Uint8P) Uint8P

Uint8Or returns a composed predicate that represents the logical OR predicate.

type UintP

type UintP interface {
	Fielder
	// contains filtered or unexported methods
}

UintP is the interface for predicates of type uint (`type P[uint]`).

func UintAnd

func UintAnd(x, y UintP, z ...UintP) UintP

UintAnd returns a composed predicate that represents the logical AND predicate.

func UintEQ

func UintEQ(v uint) UintP

UintEQ applies the EQ operation on the given value.

func UintGT

func UintGT(v uint) UintP

UintGT applies the GT operation on the given value.

func UintGTE

func UintGTE(v uint) UintP

UintGTE applies the GTE operation on the given value.

func UintLT

func UintLT(v uint) UintP

UintLT applies the LT operation on the given value.

func UintLTE

func UintLTE(v uint) UintP

UintLTE applies the LTE operation on the given value.

func UintNEQ

func UintNEQ(v uint) UintP

UintNEQ applies the NEQ operation on the given value.

func UintNot

func UintNot(x UintP) UintP

UintNot returns a predicate that represents the logical negation of the given predicate.

func UintOr

func UintOr(x, y UintP, z ...UintP) UintP

UintOr returns a composed predicate that represents the logical OR predicate.

type UnaryExpr

type UnaryExpr struct {
	Op Op
	X  Expr
}

A UnaryExpr represents a unary expression.

func (*UnaryExpr) Negate

func (e *UnaryExpr) Negate() P

Negate negates the predicate.

func (*UnaryExpr) String

func (e *UnaryExpr) String() string

String returns the text representation of a unary expression.

type Value

type Value struct {
	V interface{}
}

A Value represents an arbitrary value.

func (*Value) String

func (v *Value) String() string

String returns the text representation of a value.

Source Files

Directories

Path Synopsis
internal A codegen cmd for generating builder types from template.