query

type CascadeArgs ¶

type CascadeArgs struct {
	Fields []string
	First  int
	Offset int
}

CascadeArgs stores the arguments needed to process @cascade directive. It is introduced to ensure correct behaviour for cascade with pagination.

type ContextKey ¶

type ContextKey int

ContextKey is used to set options in the context object.

const (
	// DebugKey is the key used to toggle debug mode.
	DebugKey ContextKey = iota
)

type ExecutionResult ¶

type ExecutionResult struct {
	Subgraphs  []*SubGraph
	SchemaNode []*pb.SchemaNode
	Types      []*pb.TypeUpdate
	Metrics    map[string]uint64
}

ExecutionResult holds the result of running a query.

type Extensions ¶

type Extensions struct {
	Latency *api.Latency    `json:"server_latency,omitempty"`
	Txn     *api.TxnContext `json:"txn,omitempty"`
	Metrics *api.Metrics    `json:"metrics,omitempty"`
}

Extensions represents the extra information appended to query results.

type Function ¶

type Function struct {
	Name       string    // Specifies the name of the function.
	Args       []dql.Arg // Contains the arguments of the function.
	IsCount    bool      // gt(count(friends),0)
	IsValueVar bool      // eq(val(s), 10)
	IsLenVar   bool      // eq(len(s), 10)
}

Function holds the information about dql functions.

type Latency ¶

type Latency struct {
	Start           time.Time     `json:"-"`
	Parsing         time.Duration `json:"query_parsing"`
	AssignTimestamp time.Duration `json:"assign_timestamp"`
	Processing      time.Duration `json:"processing"`
	Json            time.Duration `json:"json_conversion"`
}

Latency is used to keep track of the latency involved in parsing and processing the query. It also contains information about the time it took to convert the result into a format(JSON/Protocol Buffer) that the client expects.

type Request ¶

type Request struct {
	ReadTs   uint64 // ReadTs for the transaction.
	Cache    int    // 0 represents use txn cache, 1 represents not to use cache.
	Latency  *Latency
	DqlQuery *dql.Result

	Subgraphs []*SubGraph

	Vars map[string]varValue
}

Request wraps the state that is used when executing query. Initially ReadTs, Cache and DQLQuery are set. Subgraphs, Vars and Latency are filled when processing query.

func (req *Request) Process(ctx context.Context) (er ExecutionResult, err error)

func (req *Request) ProcessQuery(ctx context.Context) (err error)

type SubGraph ¶

type SubGraph struct {
	ReadTs      uint64
	Cache       int
	Attr        string
	UnknownAttr bool
	// read only parameters which are populated before the execution of the query and are used to
	// execute this query.
	Params params

	ExpandPreds []*pb.ValueList
	GroupbyRes  []*groupResults // one result for each uid list.
	LangTags    []*pb.LangList

	// SrcUIDs is a list of unique source UIDs. They are always copies of destUIDs
	// of parent nodes in GraphQL structure.
	SrcUIDs *pb.List
	// SrcFunc specified using func. Should only be non-nil at root. At other levels,
	// filters are used.
	SrcFunc *Function

	FilterOp string
	Filters  []*SubGraph // List of filters specified at the current node.

	MathExp  *mathTree
	Children []*SubGraph // children of the current node, should be empty for leaf nodes.

	// destUIDs is a list of destination UIDs, after applying filters, pagination.
	DestUIDs *pb.List
	List     bool // whether predicate is of list type
	// contains filtered or unexported fields
}

SubGraph is the way to represent data. It contains both the request parameters and the response. Once generated, this can then be encoded to other client convenient formats, like GraphQL / JSON. SubGraphs are recursively nested. Each SubGraph contain the following:

• SrcUIDS: A list of UIDs that were sent to this query. If this subgraph is a child graph, then the DestUIDs of the parent must match the SrcUIDs of the children.
• DestUIDs: A list of UIDs for which there can be output found in the Children field
• Children: A list of child results for this query
• valueMatrix: A list of values, against a single attribute, such as name (for a scalar subgraph). This must be the same length as the SrcUIDs
• uidMatrix: A list of outgoing edges. This must be same length as the SrcUIDs list.

Example, say we are creating a SubGraph for a query "users", which returns one user with name 'Foo', you may get SubGraph

Params: { Alias: "users" }
SrcUIDs: [1]
DestUIDs: [1]
uidMatrix: [[1]]
Children:
  SubGraph:
    Attr: "name"
    SrcUIDs: [1]
    uidMatrix: [[]]
    valueMatrix: [["Foo"]]

func ToSubGraph(ctx context.Context, gq *dql.GraphQuery) (*SubGraph, error)

func (sg *SubGraph) DebugPrint(prefix string)

func (sg *SubGraph) IsGroupBy() bool

func (sg *SubGraph) IsInternal() bool