linux-packaging-mono/mcs/class/referencesource/System.Data.Entity/System/Data/Query/PlanCompiler/VarInfo.cs

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

using System;
using System.Collections.Generic;
//using System.Diagnostics; // Please use PlanCompiler.Assert instead of Debug.Assert in this class...

// It is fine to use Debug.Assert in cases where you assert an obvious thing that is supposed
// to prevent from simple mistakes during development (e.g. method argument validation 
// in cases where it was you who created the variables or the variables had already been validated or 
// in "else" clauses where due to code changes (e.g. adding a new value to an enum type) the default 
// "else" block is chosen why the new condition should be treated separately). This kind of asserts are 
// (can be) helpful when developing new code to avoid simple mistakes but have no or little value in 
// the shipped product. 
// PlanCompiler.Assert *MUST* be used to verify conditions in the trees. These would be assumptions 
// about how the tree was built etc. - in these cases we probably want to throw an exception (this is
// what PlanCompiler.Assert does when the condition is not met) if either the assumption is not correct 
// or the tree was built/rewritten not the way we thought it was.
// Use your judgment - if you rather remove an assert than ship it use Debug.Assert otherwise use
// PlanCompiler.Assert.

using System.Globalization;

using System.Data.Common;
using md = System.Data.Metadata.Edm;
using System.Data.Query.InternalTrees;
using System.Data.Query.PlanCompiler;

namespace System.Data.Query.PlanCompiler {

    /// <summary>
    /// Kind of VarInfo
    /// </summary>
    internal enum VarInfoKind
    {   
        /// <summary>
        /// The VarInfo is of <see cref="PrimitiveTypeVarInfo"/> type.
        /// </summary>
        PrimitiveTypeVarInfo,

        /// <summary>
        /// The VarInfo is of <see cref="StructuredVarInfo"/> type.
        /// </summary>
        StructuredTypeVarInfo,

        /// <summary>
        /// The VarInfo is of <see cref="CollectionVarInfo"/> type.
        /// </summary>
        CollectionVarInfo 
    }

    /// <summary>
    /// Information about a Var and its replacement
    /// </summary>
    internal abstract class VarInfo {

        /// <summary>
        /// Gets <see cref="VarInfoKind"/> for this <see cref="VarInfo"/>.
        /// </summary>
        internal abstract VarInfoKind Kind { get; }

        /// <summary>
        /// Get the list of new Vars introduced by this VarInfo
        /// </summary>
        internal virtual List<Var> NewVars { get { return null; } }
    }

    /// <summary>
    /// Represents information about a collection typed Var. 
    /// Each such Var is replaced by a Var with a new "mapped" type - the "mapped" type
    /// is simply a collection type where the element type has been "mapped"
    /// </summary>
    internal class CollectionVarInfo : VarInfo {
        private List<Var> m_newVars; // always a singleton list

        /// <summary>
        /// Create a CollectionVarInfo
        /// </summary>
        /// <param name="newVar"></param>
        internal CollectionVarInfo(Var newVar) {
            m_newVars = new List<Var>();
            m_newVars.Add(newVar);
        }

        /// <summary>
        /// Get the newVar
        /// </summary>
        internal Var NewVar { get { return m_newVars[0]; } }

        /// <summary>
        /// Gets <see cref="VarInfoKind"/> for this <see cref="VarInfo"/>. Always <see cref="VarInfoKind.CollectionVarInfo"/>.
        /// </summary>
        internal override VarInfoKind Kind { get { return VarInfoKind.CollectionVarInfo; } }

        /// <summary>
        /// Get the list of all NewVars - just one really
        /// </summary>
        internal override List<Var> NewVars { get { return m_newVars; } }
    }

    /// <summary>
    /// The StructuredVarInfo class contains information about a structured type Var 
    /// and how it can be replaced. This is targeted towards Vars of complex/record/
    /// entity/ref types, and the goal is to replace all such Vars in this module. 
    /// </summary>
    internal class StructuredVarInfo : VarInfo {

        private Dictionary<md.EdmProperty, Var> m_propertyToVarMap;
        List<Var> m_newVars;
        bool m_newVarsIncludeNullSentinelVar;
        List<md.EdmProperty> m_newProperties;
        md.RowType m_newType;
        md.TypeUsage m_newTypeUsage;

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="newType">new "flat" record type corresponding to the Var's datatype</param>
        /// <param name="newVars">List of vars to replace current Var</param>
        /// <param name="newTypeProperties">List of properties in the "flat" record type</param>
        /// <param name="newVarsIncludeNullSentinelVar">Do the new vars include a var that represents a null sentinel either for this type or for any nested type</param>
        internal StructuredVarInfo(md.RowType newType, List<Var> newVars, List<md.EdmProperty> newTypeProperties, bool newVarsIncludeNullSentinelVar)
        {
            PlanCompiler.Assert(newVars.Count == newTypeProperties.Count, "count mismatch");
            // I see a few places where this is legal
            // PlanCompiler.Assert(newVars.Count > 0, "0 vars?");
            m_newVars = newVars;
            m_newProperties = newTypeProperties;
            m_newType = newType;
            m_newVarsIncludeNullSentinelVar = newVarsIncludeNullSentinelVar;
            m_newTypeUsage = md.TypeUsage.Create(newType);
        }

        /// <summary>
        /// Gets <see cref="VarInfoKind"/> for this <see cref="VarInfo"/>. Always <see cref="VarInfoKind.StructuredTypeVarInfo"/>.
        /// </summary>
        internal override VarInfoKind Kind
        {
            get { return VarInfoKind.StructuredTypeVarInfo; }
        }

        /// <summary>
        /// The NewVars property of the VarInfo is a list of the corresponding 
        /// "scalar" Vars that can be used to replace the current Var. This is 
        /// mainly intended for use by other RelOps that maintain lists of Vars
        /// - for example, the "Vars" property of ProjectOp and other similar 
        /// locations.
        /// </summary>
        internal override List<Var> NewVars { get { return m_newVars; } }

        /// <summary>
        /// The Fields property is matched 1-1 with the NewVars property, and
        /// specifies the properties of the record type corresponding to the 
        /// original VarType
        /// </summary>
        internal List<md.EdmProperty> Fields { get { return m_newProperties; } }

        /// <summary>
        /// Indicates whether any of the vars in NewVars 'derives'
        /// from a null sentinel. For example, for a type that is a Record with two
        /// nested records, if any has a null sentinel, it would be set to true. 
        /// It is used when expanding sort keys, to be able to indicate that there is a
        /// sorting operation that includes null sentinels. This indication is later 
        /// used by transformation rules. 
        /// </summary>
        internal bool NewVarsIncludeNullSentinelVar { get { return m_newVarsIncludeNullSentinelVar; } }

        /// <summary>
        /// Get the Var corresponding to a specific property
        /// </summary>
        /// <param name="p">the requested property</param>
        /// <param name="v">the corresponding Var</param>
        /// <returns>true, if the Var was found</returns>
        internal bool TryGetVar(md.EdmProperty p, out Var v) {
            if (m_propertyToVarMap == null) {
                InitPropertyToVarMap();
            }
            return m_propertyToVarMap.TryGetValue(p, out v);
        }

        /// <summary>
        /// The NewType property describes the new "flattened" record type
        /// that is a replacement for the original type of the Var
        /// </summary>
        internal md.RowType NewType { get { return m_newType; } }

        /// <summary>
        /// Returns the NewType wrapped in a TypeUsage
        /// </summary>
        internal md.TypeUsage NewTypeUsage { get { return m_newTypeUsage; } }

        /// <summary>
        /// Initialize mapping from properties to the corresponding Var
        /// </summary>
        private void InitPropertyToVarMap() {
            if (m_propertyToVarMap == null) {
                m_propertyToVarMap = new Dictionary<md.EdmProperty, Var>();
                IEnumerator<Var> newVarEnumerator = m_newVars.GetEnumerator();
                foreach (md.EdmProperty prop in m_newProperties) {
                    newVarEnumerator.MoveNext();
                    m_propertyToVarMap.Add(prop, newVarEnumerator.Current);
                }
                newVarEnumerator.Dispose();
            }
        }
    }

    /// <summary>
    /// Represents information about a primitive typed Var and how it can be replaced. 
    /// </summary>
    internal class PrimitiveTypeVarInfo : VarInfo
    {
        private List<Var> m_newVars; // always a singleton list

        /// <summary>
        /// Initializes a new instance of <see cref="PrimitiveTypeVarInfo"/> class.
        /// </summary>
        /// <param name="newVar">
        /// New <see cref="Var"/> that replaces current <see cref="Var"/>.
        /// </param>
        internal PrimitiveTypeVarInfo(Var newVar)
        {
            System.Diagnostics.Debug.Assert(newVar != null, "newVar != null");
            m_newVars = new List<Var>() { newVar };
        }

        /// <summary>
        /// Gets the newVar.
        /// </summary>
        internal Var NewVar { get { return m_newVars[0]; } }

        /// <summary>
        /// Gets <see cref="VarInfoKind"/> for this <see cref="VarInfo"/>. Always <see cref="VarInfoKind.CollectionVarInfo"/>.
        /// </summary>
        internal override VarInfoKind Kind
        {
            get { return VarInfoKind.PrimitiveTypeVarInfo; }
        }

        /// <summary>
        /// Gets the list of all NewVars. The list contains always just one element.
        /// </summary>
        internal override List<Var> NewVars { get { return m_newVars; } }
    }

    /// <summary>
    /// The VarInfo map maintains a mapping from Vars to their corresponding VarInfo
    /// It is logically a Dictionary
    /// </summary>
    internal class VarInfoMap {
        private Dictionary<Var, VarInfo> m_map;

        /// <summary>
        /// Default constructor
        /// </summary>
        internal VarInfoMap() {
            m_map = new Dictionary<Var, VarInfo>();
        }

        /// <summary>
        /// Create a new VarInfo for a structured type Var
        /// </summary>
        /// <param name="v">The structured type Var</param>
        /// <param name="newType">"Mapped" type for v</param>
        /// <param name="newVars">List of vars corresponding to v</param>
        /// <param name="newProperties">Flattened Properties </param>
        /// <param name="newVarsIncludeNullSentinelVar">Do the new vars include a var that represents a null sentinel either for this type or for any nested type</param>
        /// <returns>the VarInfo</returns>
        internal VarInfo CreateStructuredVarInfo(Var v, md.RowType newType, List<Var> newVars, List<md.EdmProperty> newProperties, bool newVarsIncludeNullSentinelVar)
        {
            VarInfo varInfo = new StructuredVarInfo(newType, newVars, newProperties, newVarsIncludeNullSentinelVar);
            m_map.Add(v, varInfo);
            return varInfo;
        }

        /// <summary>
        /// Create a new VarInfo for a structured type Var where the newVars cannot include a null sentinel
        /// </summary>
        /// <param name="v">The structured type Var</param>
        /// <param name="newType">"Mapped" type for v</param>
        /// <param name="newVars">List of vars corresponding to v</param>
        /// <param name="newProperties">Flattened Properties </param>
        internal VarInfo CreateStructuredVarInfo(Var v, md.RowType newType, List<Var> newVars, List<md.EdmProperty> newProperties)
        {
            return CreateStructuredVarInfo(v, newType, newVars, newProperties, false);
        }

        /// <summary>
        /// Create a VarInfo for a collection typed Var
        /// </summary>
        /// <param name="v">The collection-typed Var</param>
        /// <param name="newVar">the new Var</param>
        /// <returns>the VarInfo</returns>
        internal VarInfo CreateCollectionVarInfo(Var v, Var newVar) {
            VarInfo varInfo = new CollectionVarInfo(newVar);
            m_map.Add(v, varInfo);
            return varInfo;
        }

        /// <summary>
        /// Creates a var info for var variables of primitive or enum type.
        /// </summary>
        /// <param name="v">Current variable of primitive or enum type.</param>
        /// <param name="newVar">The new variable replacing <paramref name="v"/>.</param>
        /// <returns><see cref="PrimitiveTypeVarInfo"/> for <paramref name="v"/>.</returns>
        internal VarInfo CreatePrimitiveTypeVarInfo(Var v, Var newVar)
        {
            System.Diagnostics.Debug.Assert(v != null, "v != null");
            System.Diagnostics.Debug.Assert(newVar != null, "newVar != null");

            PlanCompiler.Assert(md.TypeSemantics.IsScalarType(v.Type), "The current variable should be of primitive or enum type.");
            PlanCompiler.Assert(md.TypeSemantics.IsScalarType(newVar.Type), "The new variable should be of primitive or enum type.");

            VarInfo varInfo = new PrimitiveTypeVarInfo(newVar);
            m_map.Add(v, varInfo);
            return varInfo;
        }

        /// <summary>
        /// Return the VarInfo for the specified var (if one exists, of course)
        /// </summary>
        /// <param name="v">The Var</param>
        /// <param name="varInfo">the corresponding VarInfo</param>
        /// <returns></returns>
        internal bool TryGetVarInfo(Var v, out VarInfo varInfo) {
            return m_map.TryGetValue(v, out varInfo);
        }
    }
}