Method executeManagedQuery

core/managed_query.go:74–138

(c context.Context)

}

func (s *gstate) executeManagedQuery(c context.Context) (bool, error) {
	if s.r.operation != qcode.QTQuery || s.cs == nil || s.cs.st.qc == nil {
		return false, nil
	}

	dbName := s.database
	if dbName == "" {
		dbName = s.gj.defaultDB
	}
	handler := s.gj.managedQueryHandlers[dbName]
	if handler == nil {
		return false, nil
	}

	managedTables := make(map[string]struct{})
	for _, table := range handler.ManagedQueryTables() {
		managedTables[strings.ToLower(table.Name)] = struct{}{}
	}

	qc := s.cs.st.qc
	var managedRoots, normalRoots int
	for _, rootID := range qc.Roots {
		sel := qc.Selects[rootID]
		if _, ok := managedTables[strings.ToLower(sel.Ti.Name)]; ok {
			managedRoots++
		} else {
			normalRoots++
		}
	}

	if managedRoots == 0 {
		return false, nil
	}
	if normalRoots != 0 {
		return true, fmt.Errorf("GraphJin system roots cannot be mixed with normal database roots; run discovery/control-plane calls separately")
	}

	req := ManagedQueryRequest{
		Database: dbName,
		Roots:    make([]ManagedQueryRoot, 0, len(qc.Roots)),
	}
	for _, rootID := range qc.Roots {
		sel := qc.Selects[rootID]
		root := ManagedQueryRoot{
			FieldName: sel.FieldName,
			Table:     sel.Ti.Name,
			Fields:    managedSelectedFields(sel.Fields),
			Where:     managedFilterToValue(sel.Where.Exp, s.vmap),
			OrderBy:   managedOrderBy(sel.OrderBy),
			Limit:     int(sel.Paging.Limit),
			Offset:    int(sel.Paging.Offset),
		}
		req.Roots = append(req.Roots, root)
	}

	data, err := handler.ExecuteManagedQuery(c, req)
	if err != nil {
		return true, err