linux-packaging-mono/mcs/class/referencesource/System.Data.Entity/System/Data/Query/InternalTrees/OpCopier.cs

//---------------------------------------------------------------------
// <copyright file="OpCopier.cs" company="Microsoft">
//      Copyright (c) Microsoft Corporation.  All rights reserved.
// </copyright>
//
// @owner  Microsoft
// @backupOwner Microsoft
//---------------------------------------------------------------------

// Interesting cases: Unnest
// More generally, note that any subtree that is left-correlated will stay as such.
//

namespace System.Data.Query.InternalTrees
{
    using System;
    using System.Collections.Generic;
    using System.Diagnostics;

    /// <summary>
    /// Handles copying of operators
    /// </summary>
    internal class OpCopier : BasicOpVisitorOfNode
    {
        #region (pseudo) Public API
        internal static Node Copy(Command cmd, Node n)
        {
            VarMap varMap;
            return Copy(cmd, n, out varMap);
        }

        /// <summary>
        /// Make a copy of the current node. Also return an ordered list of the new
        /// Vars corresponding to the vars in "varList"
        /// </summary>
        /// <param name="cmd">current command</param>
        /// <param name="node">the node to clone</param>
        /// <param name="varList">list of Vars</param>
        /// <param name="newVarList">list of "new" Vars</param>
        /// <returns>the cloned node</returns>
        internal static Node Copy(Command cmd, Node node, VarList varList, out VarList newVarList)
        {
            VarMap varMap;
            Node newNode = Copy(cmd, node, out varMap);
            newVarList = Command.CreateVarList();
            foreach (Var v in varList)
            {
                Var newVar = varMap[v];
                newVarList.Add(newVar);
            }
            return newNode;
        }

        internal static Node Copy(Command cmd, Node n, out VarMap varMap)
        {
            OpCopier oc = new OpCopier(cmd);
            Node newNode = oc.CopyNode(n);
            varMap = oc.m_varMap;
            return newNode;
        }

        internal static List<SortKey> Copy(Command cmd, List<SortKey> sortKeys)
        {
            OpCopier oc = new OpCopier(cmd);
            return oc.Copy(sortKeys);
        }
        #endregion

        // WARNING
        // Everything below this line should be local to this class
        // WARNING

        #region Private State
        private Command m_srcCmd;
        protected Command m_destCmd;
        // Map of var to cloned Var
        protected VarMap m_varMap;
        #endregion

        #region Constructors (private)
        /// <summary>
        /// Constructor. Allows for cloning of nodes within the same command
        /// </summary>
        /// <param name="cmd">The command</param>
        protected OpCopier(Command cmd) : this(cmd, cmd) {}

        /// <summary>
        /// Constructor. Allows for cloning of nodes across commands
        /// </summary>
        /// <param name="destCommand">The Command to which Nodes to be cloned must belong</param>
        /// <param name="sourceCommand">The Command to which cloned Nodes will belong</param>
        private OpCopier(Command destCommand, Command sourceCommand)
        {
            m_srcCmd = sourceCommand;
            m_destCmd = destCommand;
            m_varMap = new VarMap();
        }
        #endregion

        #region Private State Management

        /// <summary>
        /// Get the "cloned" var for a given Var.
        /// If no cloned var exists, return the input Var itself
        /// </summary>
        /// <param name="v">The Var for which the cloned Var should be retrieved</param>
        /// <returns>The cloned Var that corresponds to the specified Var if this OpCopier is cloning across two different Commands; otherwise it is safe to return the specified Var itself</returns>
        private Var GetMappedVar(Var v)
        {
            Var mappedVar;

            //
            // Return a mapping if there is one
            //
            if (m_varMap.TryGetValue(v, out mappedVar))
            {
                return mappedVar;
            }

            //
            // No mapping found.
            // If we're cloning to a different command, this is an error
            //
            if (m_destCmd != m_srcCmd)
            {
                throw EntityUtil.InternalError(EntityUtil.InternalErrorCode.UnknownVar, 6); 
            }

            //
            // otherwise return the current Var itself
            //
            return v;
        }

        /// <summary>
        /// Set the "cloned" var for a given Var
        /// WARNING: If a mapping already exists, an exception is raised
        /// </summary>
        /// <param name="v">The original Var</param>
        /// <param name="mappedVar">The cloned Var</param>
        private void SetMappedVar(Var v, Var mappedVar)
        {
            m_varMap.Add(v, mappedVar);
        }

        /// <summary>
        /// Maps columns of an existing table to those of the cloned table
        /// </summary>
        /// <param name="newTable">The original Table</param>
        /// <param name="oldTable">The cloned Table</param>
        private void MapTable(Table newTable, Table oldTable)
        {
            // Map the corresponding columns of the table
            // Now set up the column map
            for (int i = 0; i < oldTable.Columns.Count; i++)
            {
                SetMappedVar(oldTable.Columns[i], newTable.Columns[i]);
            }
        }

        /// <summary>
        /// Produce the "mapped" Vars for each Var in the input sequence, while
        /// preserving the original order
        /// </summary>
        /// <param name="vars">input var sequence</param>
        /// <returns>output mapped vars</returns>
        private IEnumerable<Var> MapVars(IEnumerable<Var> vars)
        {
            foreach (Var v in vars)
            {
                Var mappedVar = GetMappedVar(v);
                yield return mappedVar;
            }
        }

        /// <summary>
        /// Create a mapped varvec. A new varvec that "maps" all the Vars from
        /// the original Varvec
        /// </summary>
        /// <param name="vars">the varvec to clone</param>
        /// <returns>a mapped varvec</returns>
        private VarVec Copy(VarVec vars)
        {
            VarVec newVarVec = m_destCmd.CreateVarVec(MapVars(vars));
            return newVarVec;
        }

        /// <summary>
        /// Create a mapped copy of the input VarList - each var from the input varlist
        /// is represented by its mapped var (and in exactly the same order) in the output
        /// varlist
        /// </summary>
        /// <param name="varList">varList to map</param>
        /// <returns>mapped varlist</returns>
        private VarList Copy(VarList varList)
        {
            VarList newVarList = Command.CreateVarList(MapVars(varList));
            return newVarList;
        }

        /// <summary>
        /// Copies a sortkey
        /// </summary>
        /// <param name="sortKey">The SortKey to clone</param>
        /// <returns>A new SortKey that is a clone of sortKey</returns>
        private SortKey Copy(SortKey sortKey)
        {
            return Command.CreateSortKey(
                GetMappedVar(sortKey.Var),
                sortKey.AscendingSort,
                sortKey.Collation
            );
        }

        /// <summary>
        /// Copies a list of Sortkeys
        /// </summary>
        /// <param name="sortKeys">The list of SortKeys</param>
        /// <returns>A new list containing clones of the specified SortKeys</returns>
        private List<SortKey> Copy(List<SortKey> sortKeys)
        {
            List<SortKey> newSortKeys = new List<SortKey>();
            foreach (SortKey k in sortKeys)
            {
                newSortKeys.Add(Copy(k));
            }
            return newSortKeys;
        }

        #endregion

        #region Visitor Helpers

        /// <summary>
        /// Simple wrapper for all copy operations
        /// </summary>
        /// <param name="n">The Node to copy</param>
        /// <returns>A new Node that is a copy of the specified Node</returns>
        protected Node CopyNode(Node n)
        {
            return n.Op.Accept<Node>(this, n);
        }

        /// <summary>
        /// Copies all the Child Nodes of the specified Node
        /// </summary>
        /// <param name="n">The Node for which the child Nodes should be copied</param>
        /// <returns>A new list containing copies of the specified Node's children</returns>
        private List<Node> ProcessChildren(Node n)
        {
            List<Node> children = new List<Node>();
            foreach (Node chi in n.Children)
            {
                children.Add(CopyNode(chi));
            }
            return children;
        }

        /// <summary>
        /// Creates a new Node with the specified Op as its Op and the result of visiting the specified Node's children as its children
        /// </summary>
        /// <param name="op">The Op that the new Node should reference</param>
        /// <param name="original">The Node for which the children should be visited and the resulting cloned Nodes used as the children of the new Node returned by this method</param>
        /// <returns>A new Node with the specified Op as its Op and the cloned child Nodes as its children</returns>
        private Node CopyDefault(Op op, Node original)
        {
            return m_destCmd.CreateNode(op, ProcessChildren(original));
        }
        #endregion

        #region IOpVisitor<Node> Members

        /// <summary>
        /// Default Visitor pattern method for unrecognized Ops
        /// </summary>
        /// <param name="op">The unrecognized Op</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>This method always throws NotSupportedException</returns>
        /// <exception cref="NotSupportedException">By design to indicate that the Op was not recognized and is therefore unsupported</exception>
        public override Node Visit(Op op, Node n)
        {
            throw new NotSupportedException(System.Data.Entity.Strings.Iqt_General_UnsupportedOp(op.GetType().FullName));
        }

        #region ScalarOps

        /// <summary>
        /// Copies a ConstantOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(ConstantOp op, Node n)
        {
            ConstantBaseOp newOp = m_destCmd.CreateConstantOp(op.Type, op.Value);
            return m_destCmd.CreateNode(newOp);
        }

        /// <summary>
        /// Copies a NullOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(NullOp op, Node n)
        {
            return m_destCmd.CreateNode(m_destCmd.CreateNullOp(op.Type));
        }

        /// <summary>
        /// Copies a ConstantPredicateOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(ConstantPredicateOp op, Node n)
        {
            return m_destCmd.CreateNode(m_destCmd.CreateConstantPredicateOp(op.Value));
        }

        /// <summary>
        /// Copies an InternalConstantOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(InternalConstantOp op, Node n)
        {
            InternalConstantOp newOp = m_destCmd.CreateInternalConstantOp(op.Type, op.Value);
            return m_destCmd.CreateNode(newOp);
        }

        /// <summary>
        /// Copies a NullSentinelOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(NullSentinelOp op, Node n)
        {
            NullSentinelOp newOp = m_destCmd.CreateNullSentinelOp();
            return m_destCmd.CreateNode(newOp);
        }

        /// <summary>
        /// Copies a FunctionOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(FunctionOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateFunctionOp(op.Function), n);
        }

        /// <summary>
        /// Copies a PropertyOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(PropertyOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreatePropertyOp(op.PropertyInfo), n);
        }

        /// <summary>
        /// Copies a RelPropertyOp
        /// </summary>
        /// <param name="op">the RelPropertyOp to copy</param>
        /// <param name="n">node tree corresponding to 'op'</param>
        /// <returns>a copy of the node tree</returns>
        public override Node Visit(RelPropertyOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateRelPropertyOp(op.PropertyInfo), n);
        }

        /// <summary>
        /// Copies a CaseOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(CaseOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateCaseOp(op.Type), n);
        }

        /// <summary>
        /// Copies a ComparisonOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(ComparisonOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateComparisonOp(op.OpType), n);
        }

        /// <summary>
        /// Copies a like-op
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(LikeOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateLikeOp(), n);
        }

        /// <summary>
        /// Clone an aggregateop
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(AggregateOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateAggregateOp(op.AggFunc, op.IsDistinctAggregate), n);
        }

        /// <summary>
        /// Copies a type constructor
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(NewInstanceOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateNewInstanceOp(op.Type), n);
        }

        /// <summary>
        /// Copies a NewEntityOp
        /// </summary>
        /// <param name="op">the NewEntityOp to copy</param>
        /// <param name="n">node tree corresponding to the NewEntityOp</param>
        /// <returns>a copy of the node tree</returns>
        public override Node Visit(NewEntityOp op, Node n)
        {
            NewEntityOp opCopy;
            if (op.Scoped)
            {
                opCopy = m_destCmd.CreateScopedNewEntityOp(op.Type, op.RelationshipProperties, op.EntitySet);
            }
            else
            {
                Debug.Assert(op.EntitySet == null, "op.EntitySet must be null for the constructor that hasn't been scoped yet.");
                opCopy = m_destCmd.CreateNewEntityOp(op.Type, op.RelationshipProperties);
            }
            return CopyDefault(opCopy, n);
        }

        /// <summary>
        /// Copies a discriminated type constructor
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>        
        public override Node Visit(DiscriminatedNewEntityOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateDiscriminatedNewEntityOp(op.Type, op.DiscriminatorMap, op.EntitySet, op.RelationshipProperties), n);
        }

        /// <summary>
        /// Copies a multiset constructor
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(NewMultisetOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateNewMultisetOp(op.Type), n);
        }

        /// <summary>
        /// Copies a record constructor
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(NewRecordOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateNewRecordOp(op.Type), n);
        }

        /// <summary>
        /// Copies a RefOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(RefOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateRefOp(op.EntitySet, op.Type), n);
        }

        /// <summary>
        /// Copies a VarRefOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(VarRefOp op, Node n)
        {
            // Look up the newVar.
            // If no var is available in the map, that implies that the Var is defined
            // outside this subtree (and it is therefore safe to use it).
            Var newVar;
            if (!m_varMap.TryGetValue(op.Var, out newVar))
                newVar = op.Var;
            // no children for a VarRef
            return m_destCmd.CreateNode(m_destCmd.CreateVarRefOp(newVar));
        }

        /// <summary>
        /// Copies a ConditionalOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(ConditionalOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateConditionalOp(op.OpType), n);
        }

        /// <summary>
        /// Copies an ArithmeticOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(ArithmeticOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateArithmeticOp(op.OpType, op.Type), n);
        }

        /// <summary>
        /// Copies a TreatOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(TreatOp op, Node n)
        {
            TreatOp newTreatOp = op.IsFakeTreat ? m_destCmd.CreateFakeTreatOp(op.Type) : m_destCmd.CreateTreatOp(op.Type);
            return CopyDefault(newTreatOp, n);
        }

        /// <summary>
        /// Copies a CastOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(CastOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateCastOp(op.Type), n);
        }

        /// <summary>
        /// Copies a SoftCastOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(SoftCastOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateSoftCastOp(op.Type), n);
        }

        /// <summary>
        /// Copies a DerefOp
        /// </summary>
        /// <param name="op">the derefOp to copy</param>
        /// <param name="n">the subtree</param>
        /// <returns>a copy of the subtree</returns>
        public override Node Visit(DerefOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateDerefOp(op.Type), n);
        }

        /// <summary>
        /// Copies a NavigateOp
        /// </summary>
        /// <param name="op">the NavigateOp</param>
        /// <param name="n">the subtree</param>
        /// <returns>a copy of the subtree</returns>
        public override Node Visit(NavigateOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateNavigateOp(op.Type, op.RelProperty), n);
        }

        /// <summary>
        /// Clone an IsOfOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(IsOfOp op, Node n)
        {
            if (op.IsOfOnly)
                return CopyDefault(m_destCmd.CreateIsOfOnlyOp(op.IsOfType), n);
            else
                return CopyDefault(m_destCmd.CreateIsOfOp(op.IsOfType), n);
        }

        /// <summary>
        /// Clone an ExistsOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(ExistsOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateExistsOp(), n);
        }

        /// <summary>
        /// Clone an ElementOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(ElementOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateElementOp(op.Type), n);
        }

        /// <summary>
        /// Copies a GetRefKeyOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(GetRefKeyOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateGetRefKeyOp(op.Type), n);
        }

        /// <summary>
        /// Copies a GetEntityRefOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(GetEntityRefOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateGetEntityRefOp(op.Type), n);
        }

        /// <summary>
        /// Copies a CollectOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(CollectOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateCollectOp(op.Type), n);
        }

        #endregion

        #region RelOps

        /// <summary>
        /// Copies a ScanTableOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(ScanTableOp op, Node n)
        {
            // First create a new ScanTableOp based on the metadata of the existing Op
            ScanTableOp newScan = m_destCmd.CreateScanTableOp(op.Table.TableMetadata);
            // Map the corresponding tables/columns
            MapTable(newScan.Table, op.Table);

            // Create the new node
            Debug.Assert(!n.HasChild0);
            return m_destCmd.CreateNode(newScan);
        }

        /// <summary>
        /// Copies a ScanViewOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(ScanViewOp op, Node n)
        {
            // First create a new ScanViewOp based on the metadata of the existing Op
            ScanViewOp newScan = m_destCmd.CreateScanViewOp(op.Table.TableMetadata);
            // Map the corresponding tables/columns
            MapTable(newScan.Table, op.Table);

            // Create the new node
            Debug.Assert(n.HasChild0);
            List<Node> children = ProcessChildren(n);
            return m_destCmd.CreateNode(newScan, children);
        }

        /// <summary>
        /// Clone an UnnestOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(UnnestOp op, Node n)
        {
            // Visit the Node's children and map their Vars
            List<Node> children = ProcessChildren(n);

            // Get the mapped unnest-var
            Var mappedVar = GetMappedVar(op.Var);

            // Create a new unnestOp
            Table newTable = m_destCmd.CreateTableInstance(op.Table.TableMetadata);
            UnnestOp newUnnest = m_destCmd.CreateUnnestOp(mappedVar, newTable);

            // Map the corresponding tables/columns
            MapTable(newUnnest.Table, op.Table);

            // create the unnest node
            return m_destCmd.CreateNode(newUnnest, children);
        }

        /// <summary>
        /// Copies a ProjectOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(ProjectOp op, Node n)
        {
            // Visit the Node's children and map their Vars
            List<Node> children = ProcessChildren(n);

            // Copy the ProjectOp's VarSet
            VarVec newVarSet = Copy(op.Outputs);

            // Create a new ProjectOp based on the copied VarSet
            ProjectOp newProject = m_destCmd.CreateProjectOp(newVarSet);

            // Return a new Node that references the copied ProjectOp and has the copied child Nodes as its children
            return m_destCmd.CreateNode(newProject, children);
        }

        /// <summary>
        /// Copies a filterOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(FilterOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateFilterOp(), n);
        }

        /// <summary>
        /// Copies a sort node
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(SortOp op, Node n)
        {
            // Visit the Node's children and map their Vars
            List<Node> children = ProcessChildren(n);

            // Copy the SortOp's SortKeys
            List<SortKey> newSortKeys = Copy(op.Keys);

            // Create a new SortOp that uses the copied SortKeys
            SortOp newSortOp = m_destCmd.CreateSortOp(newSortKeys);

            // Return a new Node that references the copied SortOp and has the copied child Nodes as its children
            return m_destCmd.CreateNode(newSortOp, children);
        }

        /// <summary>
        /// Copies a constrained sort node
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(ConstrainedSortOp op, Node n)
        {
            // Visit the Node's children and map their Vars
            List<Node> children = ProcessChildren(n);

            // Copy the ConstrainedSortOp's SortKeys
            List<SortKey> newSortKeys = Copy(op.Keys);

            // Create a new ConstrainedSortOp that uses the copied SortKeys and the original Op's WithTies value
            ConstrainedSortOp newSortOp = m_destCmd.CreateConstrainedSortOp(newSortKeys, op.WithTies);

            // Return a new Node that references the copied SortOp and has the copied child Nodes as its children
            return m_destCmd.CreateNode(newSortOp, children);
        }

        /// <summary>
        /// Copies a group-by node
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(GroupByOp op, Node n)
        {
            // Visit the Node's children and map their Vars
            List<Node> children = ProcessChildren(n);

            // Create a new GroupByOp that uses copies of the Key and Output VarSets of the original GroupByOp
            GroupByOp newGroupOp = m_destCmd.CreateGroupByOp(Copy(op.Keys), Copy(op.Outputs));

            // Return a new Node that references the copied GroupByOp and has the copied child Nodes as its children
            return m_destCmd.CreateNode(newGroupOp, children);
        }

        /// <summary>
        /// Copies a group by into node
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(GroupByIntoOp op, Node n)
        {
            // Visit the Node's children and map their Vars
            List<Node> children = ProcessChildren(n);

            // Create a new GroupByOp that uses copies of the Key and Output VarSets of the original GroupByOp
            GroupByIntoOp newGroupOp = m_destCmd.CreateGroupByIntoOp(Copy(op.Keys), Copy(op.Inputs),  Copy(op.Outputs));

            // Return a new Node that references the copied GroupByOp and has the copied child Nodes as its children
            return m_destCmd.CreateNode(newGroupOp, children);
        }

        /// <summary>
        /// Copies a CrossJoinOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(CrossJoinOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateCrossJoinOp(), n);
        }

        /// <summary>
        /// Copies an InnerJoinOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(InnerJoinOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateInnerJoinOp(), n);
        }

        /// <summary>
        /// Copies a LeftOuterJoinOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(LeftOuterJoinOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateLeftOuterJoinOp(), n);
        }

        /// <summary>
        /// Copies a FullOuterJoinOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(FullOuterJoinOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateFullOuterJoinOp(), n);
        }

        /// <summary>
        /// Copies a crossApplyOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(CrossApplyOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateCrossApplyOp(), n);
        }

        /// <summary>
        /// Clone an OuterApplyOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(OuterApplyOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateOuterApplyOp(), n);
        }

        /// <summary>
        /// Common copy path for all SetOps
        /// </summary>
        /// <param name="op">The SetOp to Copy (must be one of ExceptOp, IntersectOp, UnionAllOp)</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        private Node CopySetOp(SetOp op, Node n)
        {
            // Visit the Node's children and map their Vars
            List<Node> children = ProcessChildren(n);

            VarMap leftMap = new VarMap();
            VarMap rightMap = new VarMap();

            
            foreach (KeyValuePair<Var, Var> kv in op.VarMap[0])
            {
                // Create a new output Var that is a copy of the original output Var
                Var outputVar = m_destCmd.CreateSetOpVar(kv.Key.Type);

                // Add a mapping for the new output var we've just created
                SetMappedVar(kv.Key, outputVar);

                // Add this output var's entries to the new VarMaps
                leftMap.Add(outputVar, GetMappedVar(kv.Value));
                rightMap.Add(outputVar, GetMappedVar((op.VarMap[1])[kv.Key]));
            }

            SetOp newSetOp = null;
            switch(op.OpType)
            {
                case OpType.UnionAll:
                    {
                        Var branchDiscriminator = ((UnionAllOp)op).BranchDiscriminator;
                        if (null != branchDiscriminator) 
                        {
                            branchDiscriminator = GetMappedVar(branchDiscriminator);
                        }
                        newSetOp = m_destCmd.CreateUnionAllOp(leftMap, rightMap, branchDiscriminator);
                    }
                    break;

                case OpType.Intersect:
                    {
                        newSetOp = m_destCmd.CreateIntersectOp(leftMap, rightMap);
                    }
                    break;

                case OpType.Except:
                    {
                        newSetOp = m_destCmd.CreateExceptOp(leftMap, rightMap);
                    }
                    break;

                default:
                    {
                        Debug.Assert(false, "Unexpected SetOpType");
                    }
                    break;
            }

            return m_destCmd.CreateNode(newSetOp, children);
        }

        /// <summary>
        /// Copies a UnionAllOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(UnionAllOp op, Node n)
        {
            return CopySetOp(op, n);
        }

        /// <summary>
        /// Copies an IntersectOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(IntersectOp op, Node n)
        {
            return CopySetOp(op, n);
        }

        /// <summary>
        /// Copies an ExceptOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(ExceptOp op, Node n)
        {
            return CopySetOp(op, n);
        }

        /// <summary>
        /// Copies a DistinctOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(DistinctOp op, Node n)
        {
            // Visit the Node's children and map their Vars
            List<Node> children = ProcessChildren(n);

            // Copy the DistinctOp's Keys
            VarVec newDistinctKeys = Copy(op.Keys);

            // Create a new DistinctOp that uses the copied keys
            DistinctOp newDistinctOp = m_destCmd.CreateDistinctOp(newDistinctKeys);

            // Return a new Node that references the copied DistinctOp and has the copied child Nodes as its children
            return m_destCmd.CreateNode(newDistinctOp, children);
        }

        public override Node Visit(SingleRowOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateSingleRowOp(), n);
        }

        public override Node Visit(SingleRowTableOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateSingleRowTableOp(), n);
        }

        #endregion

        #region AncillaryOps
        /// <summary>
        /// Copies a VarDefOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(VarDefOp op, Node n)
        {
            // First create a new Var
            List<Node> children = ProcessChildren(n);
            Debug.Assert(op.Var.VarType == VarType.Computed, "Unexpected VarType");
            Var newVar = m_destCmd.CreateComputedVar(op.Var.Type);
            SetMappedVar(op.Var, newVar);
            return m_destCmd.CreateNode(m_destCmd.CreateVarDefOp(newVar), children);
        }

        /// <summary>
        /// Copies a VarDefListOp
        /// </summary>
        /// <param name="op">The Op to Copy</param>
        /// <param name="n">The Node that references the Op</param>
        /// <returns>A copy of the original Node that references a copy of the original Op</returns>
        public override Node Visit(VarDefListOp op, Node n)
        {
            return CopyDefault(m_destCmd.CreateVarDefListOp(), n);
        }
        #endregion

        #region RulePatternOps
        #endregion

        #region PhysicalOps
        private ColumnMap Copy(ColumnMap columnMap)
        {
            return ColumnMapCopier.Copy(columnMap, m_varMap);
        }

        /// <summary>
        /// Copies a PhysicalProjectOp
        /// </summary>
        /// <param name="op"></param>
        /// <param name="n"></param>
        /// <returns></returns>
        public override Node Visit(PhysicalProjectOp op, Node n)
        {
            // Visit the Node's children and map their Vars
            List<Node> children = ProcessChildren(n);

            // Copy the ProjectOp's VarSet
            VarList newVarList = Copy(op.Outputs);

            SimpleCollectionColumnMap newColumnMap = Copy(op.ColumnMap) as SimpleCollectionColumnMap;
            Debug.Assert(newColumnMap != null, "Coping of a physical project's columnMap did not return a SimpleCollectionColumnMap" );
            // Create a new ProjectOp based on the copied VarSet
            PhysicalProjectOp newProject = m_destCmd.CreatePhysicalProjectOp(newVarList, newColumnMap);

            // Return a new Node that references the copied ProjectOp and has the copied child Nodes as its children
            return m_destCmd.CreateNode(newProject, children);
        }

        private Node VisitNestOp(Node n)
        {
            NestBaseOp op = n.Op as NestBaseOp;
            SingleStreamNestOp ssnOp = op as SingleStreamNestOp;
            Debug.Assert(op != null);

            // Visit the Node's children and map their Vars
            List<Node> newChildren = ProcessChildren(n);

            Var newDiscriminator = null;
            if (ssnOp != null)
            {
                newDiscriminator = GetMappedVar(ssnOp.Discriminator);
            }
            List<CollectionInfo> newCollectionInfoList = new List<CollectionInfo>();
            foreach (CollectionInfo ci in op.CollectionInfo)
            {
                ColumnMap newColumnMap = Copy(ci.ColumnMap);

                Var newCollectionVar = m_destCmd.CreateComputedVar(ci.CollectionVar.Type);
                SetMappedVar(ci.CollectionVar, newCollectionVar);

                VarList newFlattendElementVars = Copy(ci.FlattenedElementVars);
                VarVec newKeys = Copy(ci.Keys);
                List<SortKey> newSortKeys = Copy(ci.SortKeys);
                CollectionInfo newCollectionInfo = Command.CreateCollectionInfo(newCollectionVar, newColumnMap, newFlattendElementVars, newKeys, newSortKeys, ci.DiscriminatorValue);
                newCollectionInfoList.Add(newCollectionInfo);
            }

            VarVec newOutputs = Copy(op.Outputs);

            NestBaseOp newOp = null;
            List<SortKey> newPrefixSortKeys = Copy(op.PrefixSortKeys);
            if (ssnOp != null)
            {
                VarVec newKeys = Copy(ssnOp.Keys);
                // Copy the SortOp's SortKeys
                List<SortKey> newPostfixSortKeys = Copy(ssnOp.PostfixSortKeys);
                newOp = m_destCmd.CreateSingleStreamNestOp(newKeys, newPrefixSortKeys, newPostfixSortKeys, newOutputs, newCollectionInfoList, newDiscriminator);
            }
            else
            {
                newOp = m_destCmd.CreateMultiStreamNestOp(newPrefixSortKeys, newOutputs, newCollectionInfoList);
            }

            return m_destCmd.CreateNode(newOp, newChildren);
        }

        /// <summary>
        /// Copies a singleStreamNestOp
        /// </summary>
        /// <param name="op"></param>
        /// <param name="n"></param>
        /// <returns></returns>
        public override Node Visit(SingleStreamNestOp op, Node n)
        {
            return VisitNestOp(n);
        }

        /// <summary>
        /// Copies a multiStreamNestOp
        /// </summary>
        /// <param name="op"></param>
        /// <param name="n"></param>
        /// <returns></returns>
        public override Node Visit(MultiStreamNestOp op, Node n)
        {
            return VisitNestOp(n);
        }
        #endregion

        #endregion
    }
}