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 OtherP

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

                                                                                                                                                                                                                    OtherP is the interface for predicates of type other (`type P[other]`).

                                                                                                                                                                                                                    func OtherAnd

                                                                                                                                                                                                                    func OtherAnd(x, y OtherP, z ...OtherP) OtherP

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

                                                                                                                                                                                                                      func OtherEQ

                                                                                                                                                                                                                      func OtherEQ(v driver.Valuer) OtherP

                                                                                                                                                                                                                        OtherEQ applies the EQ operation on the given value.

                                                                                                                                                                                                                        func OtherNEQ

                                                                                                                                                                                                                        func OtherNEQ(v driver.Valuer) OtherP

                                                                                                                                                                                                                          OtherNEQ applies the NEQ operation on the given value.

                                                                                                                                                                                                                          func OtherNot

                                                                                                                                                                                                                          func OtherNot(x OtherP) OtherP

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

                                                                                                                                                                                                                            func OtherOr

                                                                                                                                                                                                                            func OtherOr(x, y OtherP, z ...OtherP) OtherP

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

                                                                                                                                                                                                                              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.

                                                                                                                                                                                                                                                                                                                                                                                                                                          type ValueP

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

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

                                                                                                                                                                                                                                                                                                                                                                                                                                            func ValueAnd

                                                                                                                                                                                                                                                                                                                                                                                                                                            func ValueAnd(x, y ValueP, z ...ValueP) ValueP

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

                                                                                                                                                                                                                                                                                                                                                                                                                                              func ValueEQ

                                                                                                                                                                                                                                                                                                                                                                                                                                              func ValueEQ(v driver.Valuer) ValueP

                                                                                                                                                                                                                                                                                                                                                                                                                                                ValueEQ applies the EQ operation on the given value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                func ValueNEQ

                                                                                                                                                                                                                                                                                                                                                                                                                                                func ValueNEQ(v driver.Valuer) ValueP

                                                                                                                                                                                                                                                                                                                                                                                                                                                  ValueNEQ applies the NEQ operation on the given value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func ValueNot

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func ValueNot(x ValueP) ValueP

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func ValueOr

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func ValueOr(x, y ValueP, z ...ValueP) ValueP

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

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Source Files

                                                                                                                                                                                                                                                                                                                                                                                                                                                      Directories

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