Function inScopeVariables

Parameters

• op: Algebra.BaseOperation

  Input algebra tree.

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

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

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

    • Visit a selected subTree given a startObject, steering the visits based on Typed nodes. Will first call the preVisitor on the project and notice it should not iterate on its descendants. It then visits the project, and the outermost distinct, printing '21'. The pre-visitor visits starting from the root, going deeper, while the actual visitor goes in reverse.

      Parameters

      • startObject: object

        the object from which we will start visiting, potentially visiting its descendants along the way.

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

        a dictionary mapping the various operation types to objects optionally containing preVisitor and visitor. The preVisitor allows you to provide VisitContext for the current object, altering how it will be visited. The visitor allows you to visit the object from deepest to the outermost object. This is useful if you for example want to manipulate the objects you visit during your visits, similar to this.transformNode.

      Returns void