Documentation

Overview

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

Index

Constants

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
	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
	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
	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() []interface{}
	Assign     func(...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

AddEdge 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
		// 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
		// 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 []interface{}
	Assign     func(...interface{}) error
}

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

Source Files