Documentation

Overview

    Package sqlgraph provides graph abstraction capabilities on top of sql-based databases for ent codegen.

    Index

    Constants

    View Source
    const FuncSelector entql.Func = "func_selector"

      FuncSelector represents a selector function to be used as an entql foreign-function.

      Variables

      This section is empty.

      Functions

      func BatchCreate

      func BatchCreate(ctx context.Context, drv dialect.Driver, spec *BatchCreateSpec) error

        BatchCreate applies the BatchCreateSpec on the graph.

        func CountNodes

        func CountNodes(ctx context.Context, drv dialect.Driver, spec *QuerySpec) (int, error)

          CountNodes counts the nodes in the given graph query.

          func CreateNode

          func CreateNode(ctx context.Context, drv dialect.Driver, spec *CreateSpec) error

            CreateNode applies the CreateSpec on the graph.

            func DeleteNodes

            func DeleteNodes(ctx context.Context, drv dialect.Driver, spec *DeleteSpec) (int, error)

              DeleteNodes applies the DeleteSpec on the graph.

              func HasNeighbors

              func HasNeighbors(q *sql.Selector, s *Step)

                HasNeighbors applies on the given Selector a neighbors check.

                func HasNeighborsWith

                func HasNeighborsWith(q *sql.Selector, s *Step, pred func(*sql.Selector))

                  HasNeighborsWith applies on the given Selector a neighbors check. The given predicate applies its filtering on the selector.

                  func Neighbors

                  func Neighbors(dialect string, s *Step) (q *sql.Selector)

                    Neighbors returns a Selector for evaluating the path-step and getting the neighbors of one vertex.

                    func QueryEdges

                    func QueryEdges(ctx context.Context, drv dialect.Driver, spec *EdgeQuerySpec) error

                      QueryEdges queries the edges in the graph and scans the result with the given dest function.

                      func QueryNodes

                      func QueryNodes(ctx context.Context, drv dialect.Driver, spec *QuerySpec) error

                        QueryNodes queries the nodes in the graph query and scans them to the given values.

                        func SetNeighbors

                        func SetNeighbors(dialect string, s *Step) (q *sql.Selector)

                          SetNeighbors returns a Selector for evaluating the path-step and getting the neighbors of set of vertices.

                          func UpdateNode

                          func UpdateNode(ctx context.Context, drv dialect.Driver, spec *UpdateSpec) error

                            UpdateNode applies the UpdateSpec on one node in the graph.

                            func UpdateNodes

                            func UpdateNodes(ctx context.Context, drv dialect.Driver, spec *UpdateSpec) (int, error)

                              UpdateNodes applies the UpdateSpec on a set of nodes in the graph.

                              func WrapFunc

                              func WrapFunc(s func(*sql.Selector)) *entql.CallExpr

                                WrapFunc wraps a selector-func with an entql call expression.

                                Types

                                type BatchCreateSpec

                                type BatchCreateSpec struct {
                                	Nodes []*CreateSpec
                                }

                                  BatchCreateSpec holds the information for creating multiple nodes in the graph.

                                  type ConstraintError

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

                                    A ConstraintError represents an error from mutation that violates a specific constraint.

                                    func (ConstraintError) Error

                                    func (e ConstraintError) Error() string

                                    type CreateSpec

                                    type CreateSpec struct {
                                    	Table  string
                                    	Schema string
                                    	ID     *FieldSpec
                                    	Fields []*FieldSpec
                                    	Edges  []*EdgeSpec
                                    }

                                      CreateSpec holds the information for creating a node in the graph.

                                      type DeleteSpec

                                      type DeleteSpec struct {
                                      	Node      *NodeSpec
                                      	Predicate func(*sql.Selector)
                                      }

                                        DeleteSpec holds the information for delete one or more nodes in the graph.

                                        type EdgeMut

                                        type EdgeMut struct {
                                        	Add   []*EdgeSpec
                                        	Clear []*EdgeSpec
                                        }

                                          EdgeMut defines edge mutations.

                                          type EdgeQuerySpec

                                          type EdgeQuerySpec struct {
                                          	Edge       *EdgeSpec
                                          	Predicate  func(*sql.Selector)
                                          	ScanValues func() [2]interface{}
                                          	Assign     func(out, in interface{}) error
                                          }

                                            EdgeQuerySpec holds the information for querying edges in the graph.

                                            type EdgeSpec

                                            type EdgeSpec struct {
                                            	Rel     Rel
                                            	Inverse bool
                                            	Table   string
                                            	Schema  string
                                            	Columns []string
                                            	Bidi    bool        // bidirectional edge.
                                            	Target  *EdgeTarget // target nodes.
                                            }

                                              EdgeSpec holds the information for updating a field column in the database.

                                              type EdgeSpecs

                                              type EdgeSpecs []*EdgeSpec

                                                EdgeSpecs used for perform common operations on list of edges.

                                                func (EdgeSpecs) FilterRel

                                                func (es EdgeSpecs) FilterRel(r Rel) EdgeSpecs

                                                  FilterRel returns edges for the given relation type.

                                                  func (EdgeSpecs) GroupRel

                                                  func (es EdgeSpecs) GroupRel() map[Rel][]*EdgeSpec

                                                    GroupRel groups edges by their relation type.

                                                    func (EdgeSpecs) GroupTable

                                                    func (es EdgeSpecs) GroupTable() map[string][]*EdgeSpec

                                                      GroupTable groups edges by their table name.

                                                      type EdgeTarget

                                                      type EdgeTarget struct {
                                                      	Nodes  []driver.Value
                                                      	IDSpec *FieldSpec
                                                      }

                                                        EdgeTarget holds the information for the target nodes of an edge.

                                                        type FieldMut

                                                        type FieldMut struct {
                                                        	Set   []*FieldSpec // field = ?
                                                        	Add   []*FieldSpec // field = field + ?
                                                        	Clear []*FieldSpec // field = NULL
                                                        }

                                                          FieldMut defines field mutations.

                                                          type FieldSpec

                                                          type FieldSpec struct {
                                                          	Column string
                                                          	Type   field.Type
                                                          	Value  driver.Value // value to be stored.
                                                          }

                                                            FieldSpec holds the information for updating a field column in the database.

                                                            type Node

                                                            type Node struct {
                                                            	NodeSpec
                                                            
                                                            	// Type holds the node type (schema name).
                                                            	Type string
                                                            
                                                            	// Fields maps from field names to their spec.
                                                            	Fields map[string]*FieldSpec
                                                            
                                                            	// Edges maps from edge names to their spec.
                                                            	Edges map[string]struct {
                                                            		To   *Node
                                                            		Spec *EdgeSpec
                                                            	}
                                                            }

                                                              A Node in the graph holds the SQL information for an ent/schema.

                                                              type NodeSpec

                                                              type NodeSpec struct {
                                                              	Table   string
                                                              	Schema  string
                                                              	Columns []string
                                                              	ID      *FieldSpec
                                                              }

                                                                NodeSpec defines the information for querying and decoding nodes in the graph.

                                                                type NotFoundError

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

                                                                  NotFoundError returns when trying to update an entity and it was not found in the database.

                                                                  func (*NotFoundError) Error

                                                                  func (e *NotFoundError) Error() string

                                                                  type QuerySpec

                                                                  type QuerySpec struct {
                                                                  	Node *NodeSpec     // Nodes info.
                                                                  	From *sql.Selector // Optional query source (from path).
                                                                  
                                                                  	Limit     int
                                                                  	Offset    int
                                                                  	Unique    bool
                                                                  	Order     func(*sql.Selector)
                                                                  	Predicate func(*sql.Selector)
                                                                  
                                                                  	ScanValues func(columns []string) ([]interface{}, error)
                                                                  	Assign     func(columns []string, values []interface{}) error
                                                                  }

                                                                    QuerySpec holds the information for querying nodes in the graph.

                                                                    type Rel

                                                                    type Rel int

                                                                      Rel is a relation type of an edge.

                                                                      const (
                                                                      	O2O Rel // One to one / has one.
                                                                      	O2M     // One to many / has many.
                                                                      	M2O     // Many to one (inverse perspective for O2M).
                                                                      	M2M     // Many to many.
                                                                      )

                                                                        Relation types.

                                                                        func (Rel) String

                                                                        func (r Rel) String() (s string)

                                                                          String returns the relation name.

                                                                          type Schema

                                                                          type Schema struct {
                                                                          	Nodes []*Node
                                                                          }

                                                                            A Schema holds a representation of ent/schema at runtime. Each Node represents a single schema-type and its relations in the graph (storage).

                                                                            It is used for translating common graph traversal operations to the underlying SQL storage. For example, an operation like `has_edge(E)`, will be translated to an SQL lookup based on the relation type and the FK configuration.

                                                                            func (*Schema) AddE

                                                                            func (g *Schema) AddE(name string, spec *EdgeSpec, from, to string) error

                                                                              AddE adds an edge to the graph. It fails, if one of the node types is missing.

                                                                              g.AddE("pets", spec, "user", "pet")
                                                                              g.AddE("friends", spec, "user", "user")
                                                                              

                                                                              func (*Schema) EvalP

                                                                              func (g *Schema) EvalP(nodeType string, p entql.P, selector *sql.Selector) error

                                                                                EvalP evaluates the entql predicate on the given selector (query builder).

                                                                                func (*Schema) MustAddE

                                                                                func (g *Schema) MustAddE(name string, spec *EdgeSpec, from, to string)

                                                                                  MustAddE is like AddE but panics if the edge can be added to the graph.

                                                                                  type Step

                                                                                  type Step struct {
                                                                                  	// From is the source of the step.
                                                                                  	From struct {
                                                                                  		// V can be either one vertex or set of vertices.
                                                                                  		// It can be a pre-processed step (sql.Query) or a simple Go type (integer or string).
                                                                                  		V interface{}
                                                                                  		// Table holds the table name of V (from).
                                                                                  		Table string
                                                                                  		// Column to join with. Usually the "id" column.
                                                                                  		Column string
                                                                                  	}
                                                                                  	// Edge holds the edge information for getting the neighbors.
                                                                                  	Edge struct {
                                                                                  		// Rel of the edge.
                                                                                  		Rel Rel
                                                                                  		// Schema is an optional name of the database
                                                                                  		// where the table is defined.
                                                                                  		Schema string
                                                                                  		// Table name of where this edge columns reside.
                                                                                  		Table string
                                                                                  		// Columns of the edge.
                                                                                  		// In O2O and M2O, it holds the foreign-key column. Hence, len == 1.
                                                                                  		// In M2M, it holds the primary-key columns of the join table. Hence, len == 2.
                                                                                  		Columns []string
                                                                                  		// Inverse indicates if the edge is an inverse edge.
                                                                                  		Inverse bool
                                                                                  	}
                                                                                  	// To is the dest of the path (the neighbors).
                                                                                  	To struct {
                                                                                  		// Table holds the table name of the neighbors (to).
                                                                                  		Table string
                                                                                  		// Schema is an optional name of the database
                                                                                  		// where the table is defined.
                                                                                  		Schema string
                                                                                  		// Column to join with. Usually the "id" column.
                                                                                  		Column string
                                                                                  	}
                                                                                  }

                                                                                    A Step provides a path-step information to the traversal functions.

                                                                                    func NewStep

                                                                                    func NewStep(opts ...StepOption) *Step

                                                                                      NewStep gets list of options and returns a configured step.

                                                                                      NewStep(
                                                                                      	From("table", "pk", V),
                                                                                      	To("table", "pk"),
                                                                                      	Edge("name", O2M, "fk"),
                                                                                      )
                                                                                      

                                                                                      type StepOption

                                                                                      type StepOption func(*Step)

                                                                                        StepOption allows configuring Steps using functional options.

                                                                                        func Edge

                                                                                        func Edge(rel Rel, inverse bool, table string, columns ...string) StepOption

                                                                                          Edge sets the edge info for getting the neighbors.

                                                                                          func From

                                                                                          func From(table, column string, v ...interface{}) StepOption

                                                                                            From sets the source of the step.

                                                                                            func To

                                                                                            func To(table, column string) StepOption

                                                                                              To sets the destination of the step.

                                                                                              type UpdateSpec

                                                                                              type UpdateSpec struct {
                                                                                              	Node      *NodeSpec
                                                                                              	Edges     EdgeMut
                                                                                              	Fields    FieldMut
                                                                                              	Predicate func(*sql.Selector)
                                                                                              
                                                                                              	ScanValues func(columns []string) ([]interface{}, error)
                                                                                              	Assign     func(columns []string, values []interface{}) error
                                                                                              }

                                                                                                UpdateSpec holds the information for updating one or more nodes in the graph.

                                                                                                Source Files