mcs/class/referencesource/System.Data.Entity/System/Data/Query/InternalTrees/Visitors.cs

   1 //---------------------------------------------------------------------
   2 // <copyright file="Visitors.cs" company="Microsoft">
   3 //      Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 //
   6 // @owner  [....]
   7 // @backupOwner [....]
   8 //---------------------------------------------------------------------
   9
  10 namespace System.Data.Query.InternalTrees
  11 {
  12     using System;
  13     using pc = System.Data.Query.PlanCompiler; // To be able to use PlanCompiler.Assert instead of Debug.Assert in this class.
  14
  15     /// <summary>
  16     /// Simple implemenation of the BasicOpVisitor interface.
  17     /// </summary>
  18     internal abstract class BasicOpVisitor
  19     {
  20         /// <summary>
  21         /// Default constructor.
  22         /// </summary>
  23         internal BasicOpVisitor() { }
  24
  25         #region Visitor Helpers
  26         /// <summary>
  27         /// Visit the children of this Node
  28         /// </summary>
  29         /// <param name="n">The Node that references the Op</param>
  30         protected virtual void VisitChildren(Node n)
  31         {
  32             foreach (Node chi in n.Children)
  33             {
  34                 VisitNode(chi);
  35             }
  36         }
  37
  38         /// <summary>
  39         /// Visit the children of this Node. but in reverse order
  40         /// </summary>
  41         /// <param name="n">The current node</param>
  42         protected virtual void VisitChildrenReverse(Node n)
  43         {
  44             for (int i = n.Children.Count - 1; i >= 0; i--)
  45             {
  46                 VisitNode(n.Children[i]);
  47             }
  48         }
  49
  50         /// <summary>
  51         /// Visit this node
  52         /// </summary>
  53         /// <param name="n"></param>
  54         internal virtual void VisitNode(Node n)
  55         {
  56             n.Op.Accept(this, n);
  57         }
  58         /// <summary>
  59         /// Default node visitor
  60         /// </summary>
  61         /// <param name="n"></param>
  62         protected virtual void VisitDefault(Node n)
  63         {
  64             VisitChildren(n);
  65         }
  66
  67         /// <summary>
  68         /// Default handler for all constantOps
  69         /// </summary>
  70         /// <param name="op">the constant op</param>
  71         /// <param name="n">the node</param>
  72         protected virtual void VisitConstantOp(ConstantBaseOp op, Node n)
  73         {
  74             VisitScalarOpDefault(op, n);
  75         }
  76
  77         /// <summary>
  78         /// Default handler for all TableOps
  79         /// </summary>
  80         /// <param name="op"></param>
  81         /// <param name="n"></param>
  82         protected virtual void VisitTableOp(ScanTableBaseOp op, Node n)
  83         {
  84             VisitRelOpDefault(op, n);
  85         }
  86
  87         /// <summary>
  88         /// Default handler for all JoinOps
  89         /// </summary>
  90         /// <param name="op">join op</param>
  91         /// <param name="n"></param>
  92         protected virtual void VisitJoinOp(JoinBaseOp op, Node n)
  93         {
  94             VisitRelOpDefault(op, n);
  95         }
  96
  97         /// <summary>
  98         /// Default handler for all ApplyOps
  99         /// </summary>
 100         /// <param name="op">apply op</param>
 101         /// <param name="n"></param>
 102         protected virtual void VisitApplyOp(ApplyBaseOp op, Node n)
 103         {
 104             VisitRelOpDefault(op, n);
 105         }
 106         /// <summary>
 107         /// Default handler for all SetOps
 108         /// </summary>
 109         /// <param name="op">set op</param>
 110         /// <param name="n"></param>
 111         protected virtual void VisitSetOp(SetOp op, Node n)
 112         {
 113             VisitRelOpDefault(op, n);
 114         }
 115
 116         /// <summary>
 117         /// Default handler for all SortOps
 118         /// </summary>
 119         /// <param name="op">sort op</param>
 120         /// <param name="n"></param>
 121         protected virtual void VisitSortOp(SortBaseOp op, Node n)
 122         {
 123             VisitRelOpDefault(op, n);
 124         }
 125
 126         /// <summary>
 127         /// Default handler for all GroupBy ops
 128         /// </summary>
 129         /// <param name="op">sort op</param>
 130         /// <param name="n"></param>
 131         protected virtual void VisitGroupByOp(GroupByBaseOp op, Node n)
 132         {
 133             VisitRelOpDefault(op, n);
 134         }
 135         #endregion
 136
 137         #region BasicOpVisitor Members
 138
 139         /// <summary>
 140         /// Trap method for unrecognized Op types
 141         /// </summary>
 142         /// <param name="op">The Op being visited</param>
 143         /// <param name="n">The Node that references the Op</param>
 144         public virtual void Visit(Op op, Node n)
 145         {
 146             throw new NotSupportedException(System.Data.Entity.Strings.Iqt_General_UnsupportedOp(op.GetType().FullName));
 147         }
 148
 149         #region ScalarOps
 150         protected virtual void VisitScalarOpDefault(ScalarOp op, Node n)
 151         {
 152             VisitDefault(n);
 153         }
 154
 155         /// <summary>
 156         /// Visitor pattern method for ConstantOp
 157         /// </summary>
 158         /// <param name="op">The ConstantOp being visited</param>
 159         /// <param name="n">The Node that references the Op</param>
 160         public virtual void Visit(ConstantOp op, Node n)
 161         {
 162             VisitConstantOp(op, n);
 163         }
 164
 165         /// <summary>
 166         /// Visitor pattern method for NullOp
 167         /// </summary>
 168         /// <param name="op">The NullOp being visited</param>
 169         /// <param name="n">The Node that references the Op</param>
 170         public virtual void Visit(NullOp op, Node n)
 171         {
 172             VisitConstantOp(op, n);
 173         }
 174
 175         /// <summary>
 176         /// Visitor pattern method for NullSentinelOp
 177         /// </summary>
 178         /// <param name="op">The NullSentinelOp being visited</param>
 179         /// <param name="n">The Node that references the Op</param>
 180         public virtual void Visit(NullSentinelOp op, Node n)
 181         {
 182             VisitConstantOp(op, n);
 183         }
 184
 185         /// <summary>
 186         /// Visitor pattern method for InternalConstantOp
 187         /// </summary>
 188         /// <param name="op">The InternalConstantOp being visited</param>
 189         /// <param name="n">The Node that references the Op</param>
 190         public virtual void Visit(InternalConstantOp op, Node n)
 191         {
 192             VisitConstantOp(op, n);
 193         }
 194
 195         /// <summary>
 196         /// Visitor pattern method for ConstantPredicateOp
 197         /// </summary>
 198         /// <param name="op">The ConstantPredicateOp being visited</param>
 199         /// <param name="n">The Node that references the Op</param>
 200         public virtual void Visit(ConstantPredicateOp op, Node n)
 201         {
 202             VisitConstantOp(op, n);
 203         }
 204
 205         /// <summary>
 206         /// Visitor pattern method for FunctionOp
 207         /// </summary>
 208         /// <param name="op">The FunctionOp being visited</param>
 209         /// <param name="n">The Node that references the Op</param>
 210         public virtual void Visit(FunctionOp op, Node n)
 211         {
 212             VisitScalarOpDefault(op, n);
 213         }
 214
 215         /// <summary>
 216         /// Visitor pattern method for PropertyOp
 217         /// </summary>
 218         /// <param name="op">The PropertyOp being visited</param>
 219         /// <param name="n">The Node that references the Op</param>
 220         public virtual void Visit(PropertyOp op, Node n)
 221         {
 222             VisitScalarOpDefault(op, n);
 223         }
 224
 225         /// <summary>
 226         /// Visitor pattern method for RelPropertyOp
 227         /// </summary>
 228         /// <param name="op">The RelPropertyOp being visited</param>
 229         /// <param name="n">The Node that references the Op</param>
 230         public virtual void Visit(RelPropertyOp op, Node n)
 231         {
 232             VisitScalarOpDefault(op, n);
 233         }
 234
 235         /// <summary>
 236         /// Visitor pattern method for CaseOp
 237         /// </summary>
 238         /// <param name="op">The CaseOp being visited</param>
 239         /// <param name="n">The Node that references the Op</param>
 240         public virtual void Visit(CaseOp op, Node n)
 241         {
 242             VisitScalarOpDefault(op, n);
 243         }
 244
 245         /// <summary>
 246         /// Visitor pattern method for ComparisonOp
 247         /// </summary>
 248         /// <param name="op">The ComparisonOp being visited</param>
 249         /// <param name="n">The Node that references the Op</param>
 250         public virtual void Visit(ComparisonOp op, Node n)
 251         {
 252             VisitScalarOpDefault(op, n);
 253         }
 254
 255         /// <summary>
 256         /// Visitor pattern method for LikeOp
 257         /// </summary>
 258         /// <param name="op">The LikeOp being visited</param>
 259         /// <param name="n">The Node that references the Op</param>
 260         public virtual void Visit(LikeOp op, Node n)
 261         {
 262             VisitScalarOpDefault(op, n);
 263         }
 264
 265         /// <summary>
 266         /// Visitor pattern method for AggregateOp
 267         /// </summary>
 268         /// <param name="op">The AggregateOp being visited</param>
 269         /// <param name="n">The Node that references the Op</param>
 270         public virtual void Visit(AggregateOp op, Node n)
 271         {
 272             VisitScalarOpDefault(op, n);
 273         }
 274
 275         /// <summary>
 276         /// Visitor pattern method for NewInstanceOp
 277         /// </summary>
 278         /// <param name="op">The NewInstanceOp being visited</param>
 279         /// <param name="n">The Node that references the Op</param>
 280         public virtual void Visit(NewInstanceOp op, Node n)
 281         {
 282             VisitScalarOpDefault(op, n);
 283         }
 284
 285         /// <summary>
 286         /// Visitor pattern method for NewEntityOp
 287         /// </summary>
 288         /// <param name="op">The NewEntityOp being visited</param>
 289         /// <param name="n">The Node that references the Op</param>
 290         public virtual void Visit(NewEntityOp op, Node n)
 291         {
 292             VisitScalarOpDefault(op, n);
 293         }
 294
 295         /// <summary>
 296         /// Visitor pattern method for DiscriminatedNewInstanceOp
 297         /// </summary>
 298         /// <param name="op">The DiscriminatedNewInstanceOp being visited</param>
 299         /// <param name="n">The Node that references the Op</param>
 300         public virtual void Visit(DiscriminatedNewEntityOp op, Node n)
 301         {
 302             VisitScalarOpDefault(op, n);
 303         }
 304
 305         /// <summary>
 306         /// Visitor pattern method for NewMultisetOp
 307         /// </summary>
 308         /// <param name="op">The NewMultisetOp being visited</param>
 309         /// <param name="n">The Node that references the Op</param>
 310         public virtual void Visit(NewMultisetOp op, Node n)
 311         {
 312             VisitScalarOpDefault(op, n);
 313         }
 314
 315         /// <summary>
 316         /// Visitor pattern method for NewRecordOp
 317         /// </summary>
 318         /// <param name="op">The NewRecordOp being visited</param>
 319         /// <param name="n">The Node that references the Op</param>
 320         public virtual void Visit(NewRecordOp op, Node n)
 321         {
 322             VisitScalarOpDefault(op, n);
 323         }
 324
 325         /// <summary>
 326         /// Visitor pattern method for RefOp
 327         /// </summary>
 328         /// <param name="op">The RefOp being visited</param>
 329         /// <param name="n">The Node that references the Op</param>
 330         public virtual void Visit(RefOp op, Node n)
 331         {
 332             VisitScalarOpDefault(op, n);
 333         }
 334
 335         /// <summary>
 336         /// Visitor pattern method for VarRefOp
 337         /// </summary>
 338         /// <param name="op">The VarRefOp being visited</param>
 339         /// <param name="n">The Node that references the Op</param>
 340         public virtual void Visit(VarRefOp op, Node n)
 341         {
 342             VisitScalarOpDefault(op, n);
 343         }
 344
 345         /// <summary>
 346         /// Visitor pattern method for ConditionalOp
 347         /// </summary>
 348         /// <param name="op">The ConditionalOp being visited</param>
 349         /// <param name="n">The Node that references the Op</param>
 350         public virtual void Visit(ConditionalOp op, Node n)
 351         {
 352             VisitScalarOpDefault(op, n);
 353         }
 354
 355         /// <summary>
 356         /// Visitor pattern method for ArithmeticOp
 357         /// </summary>
 358         /// <param name="op">The ArithmeticOp being visited</param>
 359         /// <param name="n">The Node that references the Op</param>
 360         public virtual void Visit(ArithmeticOp op, Node n)
 361         {
 362             VisitScalarOpDefault(op, n);
 363         }
 364
 365         /// <summary>
 366         /// Visitor pattern method for TreatOp
 367         /// </summary>
 368         /// <param name="op">The TreatOp being visited</param>
 369         /// <param name="n">The Node that references the Op</param>
 370         public virtual void Visit(TreatOp op, Node n)
 371         {
 372             VisitScalarOpDefault(op, n);
 373         }
 374
 375         /// <summary>
 376         /// Visitor pattern method for CastOp
 377         /// </summary>
 378         /// <param name="op">The CastOp being visited</param>
 379         /// <param name="n">The Node that references the Op</param>
 380         public virtual void Visit(CastOp op, Node n)
 381         {
 382             VisitScalarOpDefault(op, n);
 383         }
 384         /// <summary>
 385         /// Visitor pattern method for SoftCastOp
 386         /// </summary>
 387         /// <param name="op">The SoftCastOp being visited</param>
 388         /// <param name="n">The Node that references the Op</param>
 389         public virtual void Visit(SoftCastOp op, Node n)
 390         {
 391             VisitScalarOpDefault(op, n);
 392         }
 393
 394         /// <summary>
 395         /// Visitor pattern method for IsOp
 396         /// </summary>
 397         /// <param name="op">The IsOp being visited</param>
 398         /// <param name="n">The Node that references the Op</param>
 399         public virtual void Visit(IsOfOp op, Node n)
 400         {
 401             VisitScalarOpDefault(op, n);
 402         }
 403
 404         /// <summary>
 405         /// Visitor pattern method for ExistsOp
 406         /// </summary>
 407         /// <param name="op">The ExistsOp being visited</param>
 408         /// <param name="n">The Node that references the Op</param>
 409         public virtual void Visit(ExistsOp op, Node n)
 410         {
 411             VisitScalarOpDefault(op, n);
 412         }
 413
 414         /// <summary>
 415         /// Visitor pattern method for ElementOp
 416         /// </summary>
 417         /// <param name="op">The ElementOp being visited</param>
 418         /// <param name="n">The Node that references the Op</param>
 419         public virtual void Visit(ElementOp op, Node n)
 420         {
 421             VisitScalarOpDefault(op, n);
 422         }
 423
 424         /// <summary>
 425         /// Visitor pattern method for GetEntityRefOp
 426         /// </summary>
 427         /// <param name="op">The GetEntityRefOp being visited</param>
 428         /// <param name="n">The Node that references the Op</param>
 429         public virtual void Visit(GetEntityRefOp op, Node n)
 430         {
 431             VisitScalarOpDefault(op, n);
 432         }
 433
 434         /// <summary>
 435         /// Visitor pattern method for GetRefKeyOp
 436         /// </summary>
 437         /// <param name="op">The GetRefKeyOp being visited</param>
 438         /// <param name="n">The Node that references the Op</param>
 439         public virtual void Visit(GetRefKeyOp op, Node n)
 440         {
 441             VisitScalarOpDefault(op, n);
 442         }
 443
 444         /// <summary>
 445         /// Visitor pattern method for NestOp
 446         /// </summary>
 447         /// <param name="op">The NestOp being visited</param>
 448         /// <param name="n">The Node that references the Op</param>
 449         public virtual void Visit(CollectOp op, Node n)
 450         {
 451             VisitScalarOpDefault(op, n);
 452         }
 453
 454         public virtual void Visit(DerefOp op, Node n)
 455         {
 456             VisitScalarOpDefault(op, n);
 457         }
 458
 459         public virtual void Visit(NavigateOp op, Node n)
 460         {
 461             VisitScalarOpDefault(op, n);
 462         }
 463
 464         #endregion
 465
 466         #region AncillaryOps
 467         protected virtual void VisitAncillaryOpDefault(AncillaryOp op, Node n)
 468         {
 469             VisitDefault(n);
 470         }
 471
 472         /// <summary>
 473         /// Visitor pattern method for VarDefOp
 474         /// </summary>
 475         /// <param name="op">The VarDefOp being visited</param>
 476         /// <param name="n">The Node that references the Op</param>
 477         public virtual void Visit(VarDefOp op, Node n)
 478         {
 479             VisitAncillaryOpDefault(op, n);
 480         }
 481
 482         /// <summary>
 483         /// Visitor pattern method for VarDefListOp
 484         /// </summary>
 485         /// <param name="op">The VarDefListOp being visited</param>
 486         /// <param name="n">The Node that references the Op</param>
 487         public virtual void Visit(VarDefListOp op, Node n)
 488         {
 489             VisitAncillaryOpDefault(op, n);
 490         }
 491
 492         #endregion
 493
 494         #region RelOps
 495
 496         protected virtual void VisitRelOpDefault(RelOp op, Node n)
 497         {
 498             VisitDefault(n);
 499         }
 500
 501         /// <summary>
 502         /// Visitor pattern method for ScanTableOp
 503         /// </summary>
 504         /// <param name="op">The ScanTableOp being visited</param>
 505         /// <param name="n">The Node that references the Op</param>
 506         public virtual void Visit(ScanTableOp op, Node n)
 507         {
 508             VisitTableOp(op, n);
 509         }
 510
 511         /// <summary>
 512         /// Visitor pattern method for ScanViewOp
 513         /// </summary>
 514         /// <param name="op">The ScanViewOp being visited</param>
 515         /// <param name="n">The Node that references the Op</param>
 516         public virtual void Visit(ScanViewOp op, Node n)
 517         {
 518             VisitTableOp(op, n);
 519         }
 520
 521         /// <summary>
 522         /// Visitor pattern method for UnnestOp
 523         /// </summary>
 524         /// <param name="op">The UnnestOp being visited</param>
 525         /// <param name="n">The Node that references the Op</param>
 526         public virtual void Visit(UnnestOp op, Node n)
 527         {
 528             VisitRelOpDefault(op, n);
 529         }
 530
 531         /// <summary>
 532         /// Visitor pattern method for ProjectOp
 533         /// </summary>
 534         /// <param name="op">The ProjectOp being visited</param>
 535         /// <param name="n">The Node that references the Op</param>
 536         public virtual void Visit(ProjectOp op, Node n)
 537         {
 538             VisitRelOpDefault(op, n);
 539         }
 540
 541         /// <summary>
 542         /// Visitor pattern method for FilterOp
 543         /// </summary>
 544         /// <param name="op">The FilterOp being visited</param>
 545         /// <param name="n">The Node that references the Op</param>
 546         public virtual void Visit(FilterOp op, Node n)
 547         {
 548             VisitRelOpDefault(op, n);
 549         }
 550
 551         /// <summary>
 552         /// Visitor pattern method for SortOp
 553         /// </summary>
 554         /// <param name="op">The SortOp being visited</param>
 555         /// <param name="n">The Node that references the Op</param>
 556         public virtual void Visit(SortOp op, Node n)
 557         {
 558             VisitSortOp(op, n);
 559         }
 560
 561         /// <summary>
 562         /// Visitor pattern method for ConstrainedSortOp
 563         /// </summary>
 564         /// <param name="op">The ConstrainedSortOp being visited</param>
 565         /// <param name="n">The Node that references the Op</param>
 566         public virtual void Visit(ConstrainedSortOp op, Node n)
 567         {
 568             VisitSortOp(op, n);
 569         }
 570
 571         /// <summary>
 572         /// Visitor pattern method for GroupByOp
 573         /// </summary>
 574         /// <param name="op">The GroupByOp being visited</param>
 575         /// <param name="n">The Node that references the Op</param>
 576         public virtual void Visit(GroupByOp op, Node n)
 577         {
 578             VisitGroupByOp(op, n);
 579         }
 580
 581         /// <summary>
 582         /// Visitor pattern method for GroupByIntoOp
 583         /// </summary>
 584         /// <param name="op">The GroupByIntoOp being visited</param>
 585         /// <param name="n">The Node that references the Op</param>
 586         public virtual void Visit(GroupByIntoOp op, Node n)
 587         {
 588             VisitGroupByOp(op, n);
 589         }
 590
 591         /// <summary>
 592         /// Visitor pattern method for CrossJoinOp
 593         /// </summary>
 594         /// <param name="op">The CrossJoinOp being visited</param>
 595         /// <param name="n">The Node that references the Op</param>
 596         public virtual void Visit(CrossJoinOp op, Node n)
 597         {
 598             VisitJoinOp(op, n);
 599         }
 600
 601         /// <summary>
 602         /// Visitor pattern method for InnerJoinOp
 603         /// </summary>
 604         /// <param name="op">The InnerJoinOp being visited</param>
 605         /// <param name="n">The Node that references the Op</param>
 606         public virtual void Visit(InnerJoinOp op, Node n)
 607         {
 608             VisitJoinOp(op, n);
 609         }
 610
 611         /// <summary>
 612         /// Visitor pattern method for LeftOuterJoinOp
 613         /// </summary>
 614         /// <param name="op">The LeftOuterJoinOp being visited</param>
 615         /// <param name="n">The Node that references the Op</param>
 616         public virtual void Visit(LeftOuterJoinOp op, Node n)
 617         {
 618             VisitJoinOp(op, n);
 619         }
 620
 621         /// <summary>
 622         /// Visitor pattern method for FullOuterJoinOp
 623         /// </summary>
 624         /// <param name="op">The FullOuterJoinOp being visited</param>
 625         /// <param name="n">The Node that references the Op</param>
 626         public virtual void Visit(FullOuterJoinOp op, Node n)
 627         {
 628             VisitJoinOp(op, n);
 629         }
 630
 631         /// <summary>
 632         /// Visitor pattern method for CrossApplyOp
 633         /// </summary>
 634         /// <param name="op">The CrossApplyOp being visited</param>
 635         /// <param name="n">The Node that references the Op</param>
 636         public virtual void Visit(CrossApplyOp op, Node n)
 637         {
 638             VisitApplyOp(op, n);
 639         }
 640
 641         /// <summary>
 642         /// Visitor pattern method for OuterApplyOp
 643         /// </summary>
 644         /// <param name="op">The OuterApplyOp being visited</param>
 645         /// <param name="n">The Node that references the Op</param>
 646         public virtual void Visit(OuterApplyOp op, Node n)
 647         {
 648             VisitApplyOp(op, n);
 649         }
 650
 651         /// <summary>
 652         /// Visitor pattern method for UnionAllOp
 653         /// </summary>
 654         /// <param name="op">The UnionAllOp being visited</param>
 655         /// <param name="n">The Node that references the Op</param>
 656         public virtual void Visit(UnionAllOp op, Node n)
 657         {
 658             VisitSetOp(op, n);
 659         }
 660
 661         /// <summary>
 662         /// Visitor pattern method for IntersectOp
 663         /// </summary>
 664         /// <param name="op">The IntersectOp being visited</param>
 665         /// <param name="n">The Node that references the Op</param>
 666         public virtual void Visit(IntersectOp op, Node n)
 667         {
 668             VisitSetOp(op, n);
 669         }
 670
 671         /// <summary>
 672         /// Visitor pattern method for ExceptOp
 673         /// </summary>
 674         /// <param name="op">The ExceptOp being visited</param>
 675         /// <param name="n">The Node that references the Op</param>
 676         public virtual void Visit(ExceptOp op, Node n)
 677         {
 678             VisitSetOp(op, n);
 679         }
 680
 681         /// <summary>
 682         /// Visitor pattern method for DistinctOp
 683         /// </summary>
 684         /// <param name="op">The DistinctOp being visited</param>
 685         /// <param name="n">The Node that references the Op</param>
 686         public virtual void Visit(DistinctOp op, Node n)
 687         {
 688             VisitRelOpDefault(op, n);
 689         }
 690
 691         /// <summary>
 692         /// Visitor pattern method for SingleRowOp
 693         /// </summary>
 694         /// <param name="op">The SingleRowOp being visited</param>
 695         /// <param name="n">The Node that references the Op</param>
 696         public virtual void Visit(SingleRowOp op, Node n)
 697         {
 698             VisitRelOpDefault(op, n);
 699         }
 700
 701         /// <summary>
 702         /// Visitor pattern method for SingleRowTableOp
 703         /// </summary>
 704         /// <param name="op">The SingleRowTableOp being visited</param>
 705         /// <param name="n">The Node that references the Op</param>
 706         public virtual void Visit(SingleRowTableOp op, Node n)
 707         {
 708             VisitRelOpDefault(op, n);
 709         }
 710
 711         #endregion
 712
 713         #region PhysicalOps
 714         protected virtual void VisitPhysicalOpDefault(PhysicalOp op, Node n)
 715         {
 716             VisitDefault(n);
 717         }
 718
 719         /// <summary>
 720         /// Visitor pattern method for PhysicalProjectOp
 721         /// </summary>
 722         /// <param name="op">The op being visited</param>
 723         /// <param name="n">The Node that references the Op</param>
 724         public virtual void Visit(PhysicalProjectOp op, Node n)
 725         {
 726             VisitPhysicalOpDefault(op, n);
 727         }
 728
 729         #region NestOps
 730         /// <summary>
 731         /// Common handling for all nestOps
 732         /// </summary>
 733         /// <param name="op">nest op</param>
 734         /// <param name="n"></param>
 735         protected virtual void VisitNestOp(NestBaseOp op, Node n)
 736         {
 737             VisitPhysicalOpDefault(op, n);
 738         }
 739         /// <summary>
 740         /// Visitor pattern method for SingleStreamNestOp
 741         /// </summary>
 742         /// <param name="op">The op being visited</param>
 743         /// <param name="n">The Node that references the Op</param>
 744         public virtual void Visit(SingleStreamNestOp op, Node n)
 745         {
 746             VisitNestOp(op, n);
 747         }
 748         /// <summary>
 749         /// Visitor pattern method for MultistreamNestOp
 750         /// </summary>
 751         /// <param name="op">The op being visited</param>
 752         /// <param name="n">The Node that references the Op</param>
 753         public virtual void Visit(MultiStreamNestOp op, Node n)
 754         {
 755             VisitNestOp(op, n);
 756         }
 757         #endregion
 758         #endregion
 759
 760         #endregion
 761     }
 762
 763     /// <summary>
 764     /// Simple implementation of the BasicOpVisitorOfT interface"/>
 765     /// </summary>
 766     /// <typeparam name="TResultType">type parameter</typeparam>
 767     internal abstract class BasicOpVisitorOfT<TResultType>
 768     {
 769         #region visitor helpers
 770
 771         /// <summary>
 772         /// Simply iterates over all children, and manages any updates
 773         /// </summary>
 774         /// <param name="n">The current node</param>
 775         protected virtual void VisitChildren(Node n)
 776         {
 777             for (int i = 0; i < n.Children.Count; i++)
 778             {
 779                 VisitNode(n.Children[i]);
 780             }
 781         }
 782
 783         /// <summary>
 784         /// Simply iterates over all children, and manages any updates, but in reverse order
 785         /// </summary>
 786         /// <param name="n">The current node</param>
 787         protected virtual void VisitChildrenReverse(Node n)
 788         {
 789             for (int i = n.Children.Count - 1; i >= 0; i--)
 790             {
 791                 VisitNode(n.Children[i]);
 792             }
 793         }
 794
 795         /// <summary>
 796         /// Simple wrapper to invoke the appropriate action on a node
 797         /// </summary>
 798         /// <param name="n">the node to process</param>
 799         /// <returns></returns>
 800         internal TResultType VisitNode(Node n)
 801         {
 802             // Invoke the visitor
 803             return n.Op.Accept<TResultType>(this, n);
 804         }
 805
 806         /// <summary>
 807         /// A default processor for any node. Visits the children and returns itself unmodified.
 808         /// </summary>
 809         /// <param name="n">the node to process</param>
 810         /// <returns>a potentially new node</returns>
 811         protected virtual TResultType VisitDefault(Node n)
 812         {
 813             VisitChildren(n);
 814             return default(TResultType);
 815         }
 816
 817         #endregion
 818
 819         /// <summary>
 820         /// No processing yet for this node - raises an exception
 821         /// </summary>
 822         /// <param name="n"></param>
 823         internal virtual TResultType Unimplemented(Node n)
 824         {
 825             pc.PlanCompiler.Assert(false, "Not implemented op type");
 826             return default(TResultType);
 827         }
 828
 829         /// <summary>
 830         /// Catch-all processor - raises an exception
 831         /// </summary>
 832         /// <param name="op"></param>
 833         /// <param name="n"></param>
 834         /// <returns></returns>
 835         public virtual TResultType Visit(Op op, Node n)
 836         {
 837             return Unimplemented(n);
 838         }
 839
 840         #region AncillaryOp Visitors
 841
 842         /// <summary>
 843         /// A default processor for all AncillaryOps.
 844         ///
 845         /// Allows new visitors to just override this to handle all AncillaryOps
 846         /// </summary>
 847         /// <param name="op">the AncillaryOp</param>
 848         /// <param name="n">the node to process</param>
 849         /// <returns>a potentially modified subtree</returns>
 850         protected virtual TResultType VisitAncillaryOpDefault(AncillaryOp op, Node n)
 851         {
 852             return VisitDefault(n);
 853         }
 854
 855         /// <summary>
 856         /// VarDefOp
 857         /// </summary>
 858         /// <param name="op"></param>
 859         /// <param name="n"></param>
 860         /// <returns></returns>
 861         public virtual TResultType Visit(VarDefOp op, Node n)
 862         {
 863             return VisitAncillaryOpDefault(op, n);
 864         }
 865
 866         /// <summary>
 867         /// VarDefListOp
 868         /// </summary>
 869         /// <param name="op"></param>
 870         /// <param name="n"></param>
 871         /// <returns></returns>
 872         public virtual TResultType Visit(VarDefListOp op, Node n)
 873         {
 874             return VisitAncillaryOpDefault(op, n);
 875         }
 876
 877         #endregion
 878
 879         #region PhysicalOp Visitors
 880
 881         /// <summary>
 882         /// A default processor for all PhysicalOps.
 883         ///
 884         /// Allows new visitors to just override this to handle all PhysicalOps
 885         /// </summary>
 886         /// <param name="op">the PhysicalOp</param>
 887         /// <param name="n">the node to process</param>
 888         /// <returns>a potentially modified subtree</returns>
 889         protected virtual TResultType VisitPhysicalOpDefault(PhysicalOp op, Node n)
 890         {
 891             return VisitDefault(n);
 892         }
 893
 894         /// <summary>
 895         /// PhysicalProjectOp
 896         /// </summary>
 897         /// <param name="op"></param>
 898         /// <param name="n"></param>
 899         /// <returns></returns>
 900         public virtual TResultType Visit(PhysicalProjectOp op, Node n)
 901         {
 902             return VisitPhysicalOpDefault(op, n);
 903         }
 904
 905         #region NestOp Visitors
 906
 907         /// <summary>
 908         /// A default processor for all NestOps.
 909         ///
 910         /// Allows new visitors to just override this to handle all NestOps
 911         /// </summary>
 912         /// <param name="op">the NestOp</param>
 913         /// <param name="n">the node to process</param>
 914         /// <returns>a potentially modified subtree</returns>
 915         protected virtual TResultType VisitNestOp(NestBaseOp op, Node n)
 916         {
 917             return VisitPhysicalOpDefault(op, n);
 918         }
 919
 920         /// <summary>
 921         /// SingleStreamNestOp
 922         /// </summary>
 923         /// <param name="op"></param>
 924         /// <param name="n"></param>
 925         /// <returns></returns>
 926         public virtual TResultType Visit(SingleStreamNestOp op, Node n)
 927         {
 928             return VisitNestOp(op, n);
 929         }
 930         /// <summary>
 931         /// MultiStreamNestOp
 932         /// </summary>
 933         /// <param name="op"></param>
 934         /// <param name="n"></param>
 935         /// <returns></returns>
 936         public virtual TResultType Visit(MultiStreamNestOp op, Node n)
 937         {
 938             return VisitNestOp(op, n);
 939         }
 940
 941         #endregion
 942
 943         #endregion
 944
 945         #region RelOp Visitors
 946
 947         /// <summary>
 948         /// A default processor for all RelOps.
 949         ///
 950         /// Allows new visitors to just override this to handle all RelOps
 951         /// </summary>
 952         /// <param name="op">the RelOp</param>
 953         /// <param name="n">the node to process</param>
 954         /// <returns>a potentially modified subtree</returns>
 955         protected virtual TResultType VisitRelOpDefault(RelOp op, Node n)
 956         {
 957             return VisitDefault(n);
 958         }
 959
 960         #region ApplyOp Visitors
 961
 962         /// <summary>
 963         /// Common handling for all ApplyOps
 964         /// </summary>
 965         /// <param name="op">the ApplyOp</param>
 966         /// <param name="n">the node to process</param>
 967         /// <returns>a potentially modified subtree</returns>
 968         protected virtual TResultType VisitApplyOp(ApplyBaseOp op, Node n)
 969         {
 970             return VisitRelOpDefault(op, n);
 971         }
 972
 973         /// <summary>
 974         /// CrossApply
 975         /// </summary>
 976         /// <param name="op"></param>
 977         /// <param name="n"></param>
 978         /// <returns></returns>
 979         public virtual TResultType Visit(CrossApplyOp op, Node n)
 980         {
 981             return VisitApplyOp(op, n);
 982         }
 983
 984         /// <summary>
 985         /// OuterApply
 986         /// </summary>
 987         /// <param name="op"></param>
 988         /// <param name="n"></param>
 989         /// <returns></returns>
 990         public virtual TResultType Visit(OuterApplyOp op, Node n)
 991         {
 992             return VisitApplyOp(op, n);
 993         }
 994
 995         #endregion
 996
 997         #region JoinOp Visitors
 998
 999         /// <summary>
1000         /// A default processor for all JoinOps.
1001         ///
1002         /// Allows new visitors to just override this to handle all JoinOps.
1003         /// </summary>
1004         /// <param name="op">the JoinOp</param>
1005         /// <param name="n">the node to process</param>
1006         /// <returns>a potentially modified subtree</returns>
1007         protected virtual TResultType VisitJoinOp(JoinBaseOp op, Node n)
1008         {
1009             return VisitRelOpDefault(op, n);
1010         }
1011
1012         /// <summary>
1013         /// CrossJoin
1014         /// </summary>
1015         /// <param name="op"></param>
1016         /// <param name="n"></param>
1017         /// <returns></returns>
1018         public virtual TResultType Visit(CrossJoinOp op, Node n)
1019         {
1020             return VisitJoinOp(op, n);
1021         }
1022
1023         /// <summary>
1024         /// FullOuterJoin
1025         /// </summary>
1026         /// <param name="op"></param>
1027         /// <param name="n"></param>
1028         /// <returns></returns>
1029         public virtual TResultType Visit(FullOuterJoinOp op, Node n)
1030         {
1031             return VisitJoinOp(op, n);
1032         }
1033
1034         /// <summary>
1035         /// LeftOuterJoin
1036         /// </summary>
1037         /// <param name="op"></param>
1038         /// <param name="n"></param>
1039         /// <returns></returns>
1040         public virtual TResultType Visit(LeftOuterJoinOp op, Node n)
1041         {
1042             return VisitJoinOp(op, n);
1043         }
1044
1045         /// <summary>
1046         /// InnerJoin
1047         /// </summary>
1048         /// <param name="op"></param>
1049         /// <param name="n"></param>
1050         /// <returns></returns>
1051         public virtual TResultType Visit(InnerJoinOp op, Node n)
1052         {
1053             return VisitJoinOp(op, n);
1054         }
1055
1056         #endregion
1057
1058         #region SetOp Visitors
1059
1060         /// <summary>
1061         /// A default processor for all SetOps.
1062         ///
1063         /// Allows new visitors to just override this to handle all SetOps.
1064         /// </summary>
1065         /// <param name="op">the SetOp</param>
1066         /// <param name="n">the node to process</param>
1067         /// <returns>a potentially modified subtree</returns>
1068         protected virtual TResultType VisitSetOp(SetOp op, Node n)
1069         {
1070             return VisitRelOpDefault(op, n);
1071         }
1072
1073         /// <summary>
1074         /// Except
1075         /// </summary>
1076         /// <param name="op"></param>
1077         /// <param name="n"></param>
1078         /// <returns></returns>
1079         public virtual TResultType Visit(ExceptOp op, Node n)
1080         {
1081             return VisitSetOp(op, n);
1082         }
1083
1084         /// <summary>
1085         /// Intersect
1086         /// </summary>
1087         /// <param name="op"></param>
1088         /// <param name="n"></param>
1089         /// <returns></returns>
1090         public virtual TResultType Visit(IntersectOp op, Node n)
1091         {
1092             return VisitSetOp(op, n);
1093         }
1094
1095         /// <summary>
1096         /// UnionAll
1097         /// </summary>
1098         /// <param name="op"></param>
1099         /// <param name="n"></param>
1100         /// <returns></returns>
1101         public virtual TResultType Visit(UnionAllOp op, Node n)
1102         {
1103             return VisitSetOp(op, n);
1104         }
1105
1106         #endregion
1107
1108         /// <summary>
1109         /// Distinct
1110         /// </summary>
1111         /// <param name="op"></param>
1112         /// <param name="n"></param>
1113         /// <returns></returns>
1114         public virtual TResultType Visit(DistinctOp op, Node n)
1115         {
1116             return VisitRelOpDefault(op, n);
1117         }
1118
1119         /// <summary>
1120         /// FilterOp
1121         /// </summary>
1122         /// <param name="op"></param>
1123         /// <param name="n"></param>
1124         /// <returns></returns>
1125         public virtual TResultType Visit(FilterOp op, Node n)
1126         {
1127             return VisitRelOpDefault(op, n);
1128         }
1129
1130         /// <summary>
1131         /// GroupByBaseOp
1132         /// </summary>
1133         /// <param name="op"></param>
1134         /// <param name="n"></param>
1135         /// <returns></returns>
1136         protected virtual TResultType VisitGroupByOp(GroupByBaseOp op, Node n)
1137         {
1138             return VisitRelOpDefault(op, n);
1139         }
1140
1141
1142         /// <summary>
1143         /// GroupByOp
1144         /// </summary>
1145         /// <param name="op"></param>
1146         /// <param name="n"></param>
1147         /// <returns></returns>
1148         public virtual TResultType Visit(GroupByOp op, Node n)
1149         {
1150             return VisitGroupByOp(op, n);
1151         }
1152
1153         /// <summary>
1154         /// GroupByIntoOp
1155         /// </summary>
1156         /// <param name="op"></param>
1157         /// <param name="n"></param>
1158         /// <returns></returns>
1159         public virtual TResultType Visit(GroupByIntoOp op, Node n)
1160         {
1161             return VisitGroupByOp(op, n);
1162         }
1163
1164         /// <summary>
1165         /// ProjectOp
1166         /// </summary>
1167         /// <param name="op"></param>
1168         /// <param name="n"></param>
1169         /// <returns></returns>
1170         public virtual TResultType Visit(ProjectOp op, Node n)
1171         {
1172             return VisitRelOpDefault(op, n);
1173         }
1174
1175         #region TableOps
1176         /// <summary>
1177         /// Default handler for all TableOps
1178         /// </summary>
1179         /// <param name="op"></param>
1180         /// <param name="n"></param>
1181         /// <returns></returns>
1182         protected virtual TResultType VisitTableOp(ScanTableBaseOp op, Node n)
1183         {
1184             return VisitRelOpDefault(op, n);
1185         }
1186         /// <summary>
1187         /// ScanTableOp
1188         /// </summary>
1189         /// <param name="op"></param>
1190         /// <param name="n"></param>
1191         /// <returns></returns>
1192         public virtual TResultType Visit(ScanTableOp op, Node n)
1193         {
1194             return VisitTableOp(op, n);
1195         }
1196
1197         /// <summary>
1198         /// ScanViewOp
1199         /// </summary>
1200         /// <param name="op"></param>
1201         /// <param name="n"></param>
1202         /// <returns></returns>
1203         public virtual TResultType Visit(ScanViewOp op, Node n)
1204         {
1205             return VisitTableOp(op, n);
1206         }
1207         #endregion
1208
1209         /// <summary>
1210         /// Visitor pattern method for SingleRowOp
1211         /// </summary>
1212         /// <param name="op">The SingleRowOp being visited</param>
1213         /// <param name="n">The Node that references the Op</param>
1214         /// <returns></returns>
1215         public virtual TResultType Visit(SingleRowOp op, Node n)
1216         {
1217             return VisitRelOpDefault(op, n);
1218         }
1219
1220         /// <summary>
1221         /// Visitor pattern method for SingleRowTableOp
1222         /// </summary>
1223         /// <param name="op">The SingleRowTableOp being visited</param>
1224         /// <param name="n">The Node that references the Op</param>
1225         /// <returns></returns>
1226         public virtual TResultType Visit(SingleRowTableOp op, Node n)
1227         {
1228             return VisitRelOpDefault(op, n);
1229         }
1230
1231         /// <summary>
1232         /// A default processor for all SortOps.
1233         ///
1234         /// Allows new visitors to just override this to handle ConstrainedSortOp/SortOp.
1235         /// </summary>
1236         /// <param name="op">the SetOp</param>
1237         /// <param name="n">the node to process</param>
1238         /// <returns>a potentially modified subtree</returns>
1239         protected virtual TResultType VisitSortOp(SortBaseOp op, Node n)
1240         {
1241             return VisitRelOpDefault(op, n);
1242         }
1243
1244         /// <summary>
1245         /// SortOp
1246         /// </summary>
1247         /// <param name="op"></param>
1248         /// <param name="n"></param>
1249         /// <returns></returns>
1250         public virtual TResultType Visit(SortOp op, Node n)
1251         {
1252             return VisitSortOp(op, n);
1253         }
1254
1255         /// <summary>
1256         /// ConstrainedSortOp
1257         /// </summary>
1258         /// <param name="op"></param>
1259         /// <param name="n"></param>
1260         /// <returns></returns>
1261         public virtual TResultType Visit(ConstrainedSortOp op, Node n)
1262         {
1263             return VisitSortOp(op, n);
1264         }
1265
1266         /// <summary>
1267         /// UnnestOp
1268         /// </summary>
1269         /// <param name="op"></param>
1270         /// <param name="n"></param>
1271         /// <returns></returns>
1272         public virtual TResultType Visit(UnnestOp op, Node n)
1273         {
1274             return VisitRelOpDefault(op, n);
1275         }
1276
1277         #endregion
1278
1279         #region ScalarOp Visitors
1280
1281         /// <summary>
1282         /// A default processor for all ScalarOps.
1283         ///
1284         /// Allows new visitors to just override this to handle all ScalarOps
1285         /// </summary>
1286         /// <param name="op">the ScalarOp</param>
1287         /// <param name="n">the node to process</param>
1288         /// <returns>a potentially new node</returns>
1289         protected virtual TResultType VisitScalarOpDefault(ScalarOp op, Node n)
1290         {
1291             return VisitDefault(n);
1292         }
1293
1294         /// <summary>
1295         /// Default handler for all constant Ops
1296         /// </summary>
1297         /// <param name="op"></param>
1298         /// <param name="n"></param>
1299         /// <returns></returns>
1300         protected virtual TResultType VisitConstantOp(ConstantBaseOp op, Node n)
1301         {
1302             return VisitScalarOpDefault(op, n);
1303         }
1304
1305         /// <summary>
1306         /// AggregateOp
1307         /// </summary>
1308         /// <param name="op"></param>
1309         /// <param name="n"></param>
1310         /// <returns></returns>
1311         public virtual TResultType Visit(AggregateOp op, Node n)
1312         {
1313             return VisitScalarOpDefault(op, n);
1314         }
1315
1316         /// <summary>
1317         /// ArithmeticOp
1318         /// </summary>
1319         /// <param name="op"></param>
1320         /// <param name="n"></param>
1321         /// <returns></returns>
1322         public virtual TResultType Visit(ArithmeticOp op, Node n)
1323         {
1324             return VisitScalarOpDefault(op, n);
1325         }
1326
1327         /// <summary>
1328         /// CaseOp
1329         /// </summary>
1330         /// <param name="op"></param>
1331         /// <param name="n"></param>
1332         /// <returns></returns>
1333         public virtual TResultType Visit(CaseOp op, Node n)
1334         {
1335             return VisitScalarOpDefault(op, n);
1336         }
1337
1338         /// <summary>
1339         /// CastOp
1340         /// </summary>
1341         /// <param name="op"></param>
1342         /// <param name="n"></param>
1343         /// <returns></returns>
1344         public virtual TResultType Visit(CastOp op, Node n)
1345         {
1346             return VisitScalarOpDefault(op, n);
1347         }
1348
1349         /// <summary>
1350         /// SoftCastOp
1351         /// </summary>
1352         /// <param name="op"></param>
1353         /// <param name="n"></param>
1354         /// <returns></returns>
1355         public virtual TResultType Visit(SoftCastOp op, Node n)
1356         {
1357             return VisitScalarOpDefault(op, n);
1358         }
1359
1360         /// <summary>
1361         /// NestOp
1362         /// </summary>
1363         /// <param name="op"></param>
1364         /// <param name="n"></param>
1365         /// <returns></returns>
1366         public virtual TResultType Visit(CollectOp op, Node n)
1367         {
1368             return VisitScalarOpDefault(op, n);
1369         }
1370
1371         /// <summary>
1372         /// ComparisonOp
1373         /// </summary>
1374         /// <param name="op"></param>
1375         /// <param name="n"></param>
1376         /// <returns></returns>
1377         public virtual TResultType Visit(ComparisonOp op, Node n)
1378         {
1379             return VisitScalarOpDefault(op, n);
1380         }
1381
1382         /// <summary>
1383         /// ConditionalOp
1384         /// </summary>
1385         /// <param name="op"></param>
1386         /// <param name="n"></param>
1387         /// <returns></returns>
1388         public virtual TResultType Visit(ConditionalOp op, Node n)
1389         {
1390             return VisitScalarOpDefault(op, n);
1391         }
1392
1393         /// <summary>
1394         /// ConstantOp
1395         /// </summary>
1396         /// <param name="op"></param>
1397         /// <param name="n"></param>
1398         /// <returns></returns>
1399         public virtual TResultType Visit(ConstantOp op, Node n)
1400         {
1401             return VisitConstantOp(op, n);
1402         }
1403
1404         /// <summary>
1405         /// ConstantPredicateOp
1406         /// </summary>
1407         /// <param name="op"></param>
1408         /// <param name="n"></param>
1409         /// <returns></returns>
1410         public virtual TResultType Visit(ConstantPredicateOp op, Node n)
1411         {
1412             return VisitConstantOp(op, n);
1413         }
1414
1415         /// <summary>
1416         /// ElementOp
1417         /// </summary>
1418         /// <param name="op"></param>
1419         /// <param name="n"></param>
1420         /// <returns></returns>
1421         public virtual TResultType Visit(ElementOp op, Node n)
1422         {
1423             return VisitScalarOpDefault(op, n);
1424         }
1425
1426         /// <summary>
1427         /// ExistsOp
1428         /// </summary>
1429         /// <param name="op"></param>
1430         /// <param name="n"></param>
1431         /// <returns></returns>
1432         public virtual TResultType Visit(ExistsOp op, Node n)
1433         {
1434             return VisitScalarOpDefault(op, n);
1435         }
1436
1437         /// <summary>
1438         /// FunctionOp
1439         /// </summary>
1440         /// <param name="op"></param>
1441         /// <param name="n"></param>
1442         /// <returns></returns>
1443         public virtual TResultType Visit(FunctionOp op, Node n)
1444         {
1445             return VisitScalarOpDefault(op, n);
1446         }
1447
1448         /// <summary>
1449         /// GetEntityRefOp
1450         /// </summary>
1451         /// <param name="op"></param>
1452         /// <param name="n"></param>
1453         /// <returns></returns>
1454         public virtual TResultType Visit(GetEntityRefOp op, Node n)
1455         {
1456             return VisitScalarOpDefault(op, n);
1457         }
1458
1459         /// <summary>
1460         /// GetRefKeyOp
1461         /// </summary>
1462         /// <param name="op"></param>
1463         /// <param name="n"></param>
1464         /// <returns></returns>
1465         public virtual TResultType Visit(GetRefKeyOp op, Node n)
1466         {
1467             return VisitScalarOpDefault(op, n);
1468         }
1469
1470         /// <summary>
1471         /// InternalConstantOp
1472         /// </summary>
1473         /// <param name="op"></param>
1474         /// <param name="n"></param>
1475         /// <returns></returns>
1476         public virtual TResultType Visit(InternalConstantOp op, Node n)
1477         {
1478             return VisitConstantOp(op, n);
1479         }
1480
1481         /// <summary>
1482         /// IsOfOp
1483         /// </summary>
1484         /// <param name="op"></param>
1485         /// <param name="n"></param>
1486         /// <returns></returns>
1487         public virtual TResultType Visit(IsOfOp op, Node n)
1488         {
1489             return VisitScalarOpDefault(op, n);
1490         }
1491
1492         /// <summary>
1493         /// LikeOp
1494         /// </summary>
1495         /// <param name="op"></param>
1496         /// <param name="n"></param>
1497         /// <returns></returns>
1498         public virtual TResultType Visit(LikeOp op, Node n)
1499         {
1500             return VisitScalarOpDefault(op, n);
1501         }
1502
1503         /// <summary>
1504         /// NewEntityOp
1505         /// </summary>
1506         /// <param name="op"></param>
1507         /// <param name="n"></param>
1508         /// <returns></returns>
1509         public virtual TResultType Visit(NewEntityOp op, Node n)
1510         {
1511             return VisitScalarOpDefault(op, n);
1512         }
1513
1514         /// <summary>
1515         /// NewInstanceOp
1516         /// </summary>
1517         /// <param name="op"></param>
1518         /// <param name="n"></param>
1519         /// <returns></returns>
1520         public virtual TResultType Visit(NewInstanceOp op, Node n)
1521         {
1522             return VisitScalarOpDefault(op, n);
1523         }
1524
1525         /// <summary>
1526         /// DiscriminatedNewInstanceOp
1527         /// </summary>
1528         /// <param name="op"></param>
1529         /// <param name="n"></param>
1530         /// <returns></returns>
1531         public virtual TResultType Visit(DiscriminatedNewEntityOp op, Node n)
1532         {
1533             return VisitScalarOpDefault(op, n);
1534         }
1535
1536         /// <summary>
1537         /// NewMultisetOp
1538         /// </summary>
1539         /// <param name="op"></param>
1540         /// <param name="n"></param>
1541         /// <returns></returns>
1542         public virtual TResultType Visit(NewMultisetOp op, Node n)
1543         {
1544             return VisitScalarOpDefault(op, n);
1545         }
1546
1547         /// <summary>
1548         /// NewRecordOp
1549         /// </summary>
1550         /// <param name="op"></param>
1551         /// <param name="n"></param>
1552         /// <returns></returns>
1553         public virtual TResultType Visit(NewRecordOp op, Node n)
1554         {
1555             return VisitScalarOpDefault(op, n);
1556         }
1557
1558         /// <summary>
1559         /// NullOp
1560         /// </summary>
1561         /// <param name="op"></param>
1562         /// <param name="n"></param>
1563         /// <returns></returns>
1564         public virtual TResultType Visit(NullOp op, Node n)
1565         {
1566             return VisitConstantOp(op, n);
1567         }
1568
1569         /// <summary>
1570         /// NullSentinelOp
1571         /// </summary>
1572         /// <param name="op"></param>
1573         /// <param name="n"></param>
1574         /// <returns></returns>
1575         public virtual TResultType Visit(NullSentinelOp op, Node n)
1576         {
1577             return VisitConstantOp(op, n);
1578         }
1579
1580         /// <summary>
1581         /// PropertyOp
1582         /// </summary>
1583         /// <param name="op"></param>
1584         /// <param name="n"></param>
1585         /// <returns></returns>
1586         public virtual TResultType Visit(PropertyOp op, Node n)
1587         {
1588             return VisitScalarOpDefault(op, n);
1589         }
1590         /// <summary>
1591         /// RelPropertyOp
1592         /// </summary>
1593         /// <param name="op"></param>
1594         /// <param name="n"></param>
1595         /// <returns></returns>
1596         public virtual TResultType Visit(RelPropertyOp op, Node n)
1597         {
1598             return VisitScalarOpDefault(op, n);
1599         }
1600
1601         /// <summary>
1602         /// RefOp
1603         /// </summary>
1604         /// <param name="op"></param>
1605         /// <param name="n"></param>
1606         /// <returns></returns>
1607         public virtual TResultType Visit(RefOp op, Node n)
1608         {
1609             return VisitScalarOpDefault(op, n);
1610         }
1611
1612         /// <summary>
1613         /// TreatOp
1614         /// </summary>
1615         /// <param name="op"></param>
1616         /// <param name="n"></param>
1617         /// <returns></returns>
1618         public virtual TResultType Visit(TreatOp op, Node n)
1619         {
1620             return VisitScalarOpDefault(op, n);
1621         }
1622
1623         /// <summary>
1624         /// VarRefOp
1625         /// </summary>
1626         /// <param name="op"></param>
1627         /// <param name="n"></param>
1628         /// <returns></returns>
1629         public virtual TResultType Visit(VarRefOp op, Node n)
1630         {
1631             return VisitScalarOpDefault(op, n);
1632         }
1633
1634         public virtual TResultType Visit(DerefOp op, Node n)
1635         {
1636             return VisitScalarOpDefault(op, n);
1637         }
1638         public virtual TResultType Visit(NavigateOp op, Node n)
1639         {
1640             return VisitScalarOpDefault(op, n);
1641         }
1642         #endregion
1643     }
1644
1645     /// <summary>
1646     /// A visitor implementation that allows subtrees to be modified (in a bottom-up
1647     /// fashion)
1648     /// </summary>
1649     internal abstract class BasicOpVisitorOfNode : BasicOpVisitorOfT<Node>
1650     {
1651         #region visitor helpers
1652
1653         /// <summary>
1654         /// Simply iterates over all children, and manages any updates
1655         /// </summary>
1656         /// <param name="n">The current node</param>
1657         protected override void VisitChildren(Node n)
1658         {
1659             for (int i = 0; i < n.Children.Count; i++)
1660             {
1661                 n.Children[i] = VisitNode(n.Children[i]);
1662             }
1663         }
1664
1665         /// <summary>
1666         /// Simply iterates over all children, and manages any updates, but in reverse order
1667         /// </summary>
1668         /// <param name="n">The current node</param>
1669         protected override void VisitChildrenReverse(Node n)
1670         {
1671             for (int i = n.Children.Count - 1; i >= 0; i--)
1672             {
1673                 n.Children[i] = VisitNode(n.Children[i]);
1674             }
1675         }
1676
1677         /// <summary>
1678         /// A default processor for any node. Visits the children and returns itself unmodified.
1679         /// </summary>
1680         /// <param name="n">the node to process</param>
1681         /// <returns>a potentially new node</returns>
1682         protected override Node VisitDefault(Node n)
1683         {
1684             VisitChildren(n);
1685             return n;
1686         }
1687
1688         #endregion
1689
1690         #region AncillaryOp Visitors
1691
1692         /// <summary>
1693         /// A default processor for all AncillaryOps.
1694         ///
1695         /// Allows new visitors to just override this to handle all AncillaryOps
1696         /// </summary>
1697         /// <param name="op">the AncillaryOp</param>
1698         /// <param name="n">the node to process</param>
1699         /// <returns>a potentially modified subtree</returns>
1700         protected override Node VisitAncillaryOpDefault(AncillaryOp op, Node n)
1701         {
1702             return VisitDefault(n);
1703         }
1704
1705         #endregion
1706
1707         #region PhysicalOp Visitors
1708
1709         /// <summary>
1710         /// A default processor for all PhysicalOps.
1711         ///
1712         /// Allows new visitors to just override this to handle all PhysicalOps
1713         /// </summary>
1714         /// <param name="op">the PhysicalOp</param>
1715         /// <param name="n">the node to process</param>
1716         /// <returns>a potentially modified subtree</returns>
1717         protected override Node VisitPhysicalOpDefault(PhysicalOp op, Node n)
1718         {
1719             return VisitDefault(n);
1720         }
1721
1722         #endregion
1723
1724         #region RelOp Visitors
1725
1726         /// <summary>
1727         /// A default processor for all RelOps.
1728         ///
1729         /// Allows new visitors to just override this to handle all RelOps
1730         /// </summary>
1731         /// <param name="op">the RelOp</param>
1732         /// <param name="n">the node to process</param>
1733         /// <returns>a potentially modified subtree</returns>
1734         protected override Node VisitRelOpDefault(RelOp op, Node n)
1735         {
1736             return VisitDefault(n);
1737         }
1738         #endregion
1739
1740         #region ScalarOp Visitors
1741
1742         /// <summary>
1743         /// A default processor for all ScalarOps.
1744         ///
1745         /// Allows new visitors to just override this to handle all ScalarOps
1746         /// </summary>
1747         /// <param name="op">the ScalarOp</param>
1748         /// <param name="n">the node to process</param>
1749         /// <returns>a potentially new node</returns>
1750         protected override Node VisitScalarOpDefault(ScalarOp op, Node n)
1751         {
1752             return VisitDefault(n);
1753         }
1754         #endregion
1755
1756     }
1757 }