Traqula
    Preparing search index...
    • Detects all in-scope variables. In practice this means iterating through the entire algebra tree, finding all variables, and stopping when a project function is found.

      Parameters

      • op: Algebra.BaseOperation

        Input algebra tree.

      • Optionalvisitor: (
            startObject: object,
            nodeCallBacks: {
                add?: {
                    preVisitor?: (op: Algebra.Add) => VisitContext;
                    visitor?: (op: Algebra.Add) => void;
                };
                alt?: {
                    preVisitor?: (op: Algebra.Alt) => VisitContext;
                    visitor?: (op: Algebra.Alt) => void;
                };
                ask?: {
                    preVisitor?: (op: Algebra.Ask) => VisitContext;
                    visitor?: (op: Algebra.Ask) => void;
                };
                bgp?: {
                    preVisitor?: (op: Algebra.Bgp) => VisitContext;
                    visitor?: (op: Algebra.Bgp) => void;
                };
                clear?: {
                    preVisitor?: (op: Algebra.Clear) => VisitContext;
                    visitor?: (op: Algebra.Clear) => void;
                };
                compositeupdate?: {
                    preVisitor?: (op: Algebra.CompositeUpdate) => VisitContext;
                    visitor?: (op: Algebra.CompositeUpdate) => void;
                };
                construct?: {
                    preVisitor?: (op: Algebra.Construct) => VisitContext;
                    visitor?: (op: Algebra.Construct) => void;
                };
                copy?: {
                    preVisitor?: (op: Algebra.Copy) => VisitContext;
                    visitor?: (op: Algebra.Copy) => void;
                };
                create?: {
                    preVisitor?: (op: Algebra.Create) => VisitContext;
                    visitor?: (op: Algebra.Create) => void;
                };
                deleteinsert?: {
                    preVisitor?: (op: Algebra.DeleteInsert) => VisitContext;
                    visitor?: (op: Algebra.DeleteInsert) => void;
                };
                describe?: {
                    preVisitor?: (op: Algebra.Describe) => VisitContext;
                    visitor?: (op: Algebra.Describe) => void;
                };
                distinct?: {
                    preVisitor?: (op: Algebra.Distinct) => VisitContext;
                    visitor?: (op: Algebra.Distinct) => void;
                };
                drop?: {
                    preVisitor?: (op: Algebra.Drop) => VisitContext;
                    visitor?: (op: Algebra.Drop) => void;
                };
                expression?: {
                    preVisitor?: (op: Algebra.Expression) => VisitContext;
                    visitor?: (op: Algebra.Expression) => void;
                };
                extend?: {
                    preVisitor?: (op: Algebra.Extend) => VisitContext;
                    visitor?: (op: Algebra.Extend) => void;
                };
                filter?: {
                    preVisitor?: (op: Algebra.Filter) => VisitContext;
                    visitor?: (op: Algebra.Filter) => void;
                };
                from?: {
                    preVisitor?: (op: Algebra.From) => VisitContext;
                    visitor?: (op: Algebra.From) => void;
                };
                graph?: {
                    preVisitor?: (op: Algebra.Graph) => VisitContext;
                    visitor?: (op: Algebra.Graph) => void;
                };
                group?: {
                    preVisitor?: (op: Algebra.Group) => VisitContext;
                    visitor?: (op: Algebra.Group) => void;
                };
                inv?: {
                    preVisitor?: (op: Algebra.Inv) => VisitContext;
                    visitor?: (op: Algebra.Inv) => void;
                };
                join?: {
                    preVisitor?: (op: Algebra.Join) => VisitContext;
                    visitor?: (op: Algebra.Join) => void;
                };
                leftjoin?: {
                    preVisitor?: (op: Algebra.LeftJoin) => VisitContext;
                    visitor?: (op: Algebra.LeftJoin) => void;
                };
                link?: {
                    preVisitor?: (op: Algebra.Link) => VisitContext;
                    visitor?: (op: Algebra.Link) => void;
                };
                load?: {
                    preVisitor?: (op: Algebra.Load) => VisitContext;
                    visitor?: (op: Algebra.Load) => void;
                };
                minus?: {
                    preVisitor?: (op: Algebra.Minus) => VisitContext;
                    visitor?: (op: Algebra.Minus) => void;
                };
                move?: {
                    preVisitor?: (op: Algebra.Move) => VisitContext;
                    visitor?: (op: Algebra.Move) => void;
                };
                nop?: {
                    preVisitor?: (op: Algebra.Nop) => VisitContext;
                    visitor?: (op: Algebra.Nop) => void;
                };
                nps?: {
                    preVisitor?: (op: Algebra.Nps) => VisitContext;
                    visitor?: (op: Algebra.Nps) => void;
                };
                OneOrMorePath?: {
                    preVisitor?: (op: Algebra.OneOrMorePath) => VisitContext;
                    visitor?: (op: Algebra.OneOrMorePath) => void;
                };
                orderby?: {
                    preVisitor?: (op: Algebra.OrderBy) => VisitContext;
                    visitor?: (op: Algebra.OrderBy) => void;
                };
                path?: {
                    preVisitor?: (op: Algebra.Path) => VisitContext;
                    visitor?: (op: Algebra.Path) => void;
                };
                pattern?: {
                    preVisitor?: (op: Algebra.Pattern) => VisitContext;
                    visitor?: (op: Algebra.Pattern) => void;
                };
                project?: {
                    preVisitor?: (op: Algebra.Project) => VisitContext;
                    visitor?: (op: Algebra.Project) => void;
                };
                reduced?: {
                    preVisitor?: (op: Algebra.Reduced) => VisitContext;
                    visitor?: (op: Algebra.Reduced) => void;
                };
                seq?: {
                    preVisitor?: (op: Algebra.Seq) => VisitContext;
                    visitor?: (op: Algebra.Seq) => void;
                };
                service?: {
                    preVisitor?: (op: Algebra.Service) => VisitContext;
                    visitor?: (op: Algebra.Service) => void;
                };
                slice?: {
                    preVisitor?: (op: Algebra.Slice) => VisitContext;
                    visitor?: (op: Algebra.Slice) => void;
                };
                union?: {
                    preVisitor?: (op: Algebra.Union) => VisitContext;
                    visitor?: (op: Algebra.Union) => void;
                };
                values?: {
                    preVisitor?: (op: Algebra.Values) => VisitContext;
                    visitor?: (op: Algebra.Values) => void;
                };
                ZeroOrMorePath?: {
                    preVisitor?: (op: Algebra.ZeroOrMorePath) => VisitContext;
                    visitor?: (op: Algebra.ZeroOrMorePath) => void;
                };
                ZeroOrOnePath?: {
                    preVisitor?: (op: Algebra.ZeroOrOnePath) => VisitContext;
                    visitor?: (op: Algebra.ZeroOrOnePath) => void;
                };
            },
        ) => void

        the visitor to be used to traverse the various nodes. Allows you to provide a visitor with different default preVisitor cotexts.

      Returns Variable[]

      • List of unique in-scope variables.