Query compilation performance

src/EntityFramework/Core/Query/InternalTrees/VarMap.cs

@@ -2,40 +2,37 @@
 
 namespace System.Data.Entity.Core.Query.InternalTrees
 {
+ using System.Collections;
  using System.Collections.Generic;
  using System.Globalization;
  using System.Text;
 
  // <summary>
  // Helps map one variable to the next.
  // </summary>
- internal class VarMap : Dictionary<Var, Var>
+ internal class VarMap : IDictionary<Var, Var>
  {
  #region public surfaces
 
+ private Dictionary<Var, Var> map;
+ private Dictionary<Var, Var> reverseMap;
+
  internal VarMap GetReverseMap()
  {
- var reverseMap = new VarMap();
- foreach (var kv in this)
- {
- Var x;
- // On the odd chance that a var is in the varMap more than once, the first one
- // is going to be the one we want to use, because it might be the discriminator
- // var;
- if (!reverseMap.TryGetValue(kv.Value, out x))
- {
- reverseMap[kv.Value] = kv.Key;
- }
- }
- return reverseMap;
+ return new VarMap(reverseMap, map);
+ }
+
+ public bool ContainsValue(Var value)
+ {
+ return reverseMap.ContainsKey(value);
  }
 
  public override string ToString()
  {
  var sb = new StringBuilder();
  var separator = string.Empty;
 
- foreach (var v in Keys)
+ foreach (var v in map.Keys)
  {
  sb.AppendFormat(CultureInfo.InvariantCulture, "{0}({1},{2})", separator, v.Id, this[v].Id);
  separator = ",";
@@ -45,8 +42,134 @@ public override string ToString()
 
  #endregion
 
+ #region IDictionary
+
+ public Var this[Var key]
+ {
+ get
+ {
+ return map[key];
+ }
+ set
+ {
+ map[key] = value;
+ }
+ }
+
+ public ICollection<Var> Keys
+ {
+ get
+ {
+ return map.Keys;
+ }
+ }
+
+ public ICollection<Var> Values
+ {
+ get
+ {
+ return map.Values;
+ }
+ }
+
+ public int Count
+ {
+ get
+ {
+ return map.Count;
+ }
+ }
+
+ public bool IsReadOnly
+ {
+ get
+ {
+ return false;
+ }
+ }
+
+ public void Add(Var key, Var value)
+ {
+ if (!reverseMap.ContainsKey(value))
+ {
+ reverseMap.Add(value, key);
+ }
+ map.Add(key, value);
+ }
+
+ public void Add(KeyValuePair<Var, Var> item)
+ {
+ if (!reverseMap.ContainsKey(item.Value))
+ {
+ ((IDictionary<Var, Var>)reverseMap).Add(new KeyValuePair<Var, Var>(item.Value, item.Key));
+ }
+ ((IDictionary<Var, Var>)map).Add(item);
+ }
+
+ public void Clear()
+ {
+ map.Clear();
+ reverseMap.Clear();
+ }
+
+ public bool Contains(KeyValuePair<Var, Var> item)
+ {
+ return ((IDictionary<Var, Var>)map).Contains(item);
+ }
+
+ public bool ContainsKey(Var key)
+ {
+ return map.ContainsKey(key);
+ }
+
+ public void CopyTo(KeyValuePair<Var, Var>[] array, int arrayIndex)
+ {
+ ((IDictionary<Var, Var>)map).CopyTo(array, arrayIndex);
+ }
+
+ public IEnumerator<KeyValuePair<Var, Var>> GetEnumerator()
+ {
+ return map.GetEnumerator();
+ }
+
+ public bool Remove(Var key)
+ {
+ reverseMap.Remove(map[key]);
+ return map.Remove(key);
+ }
+
+ public bool Remove(KeyValuePair<Var, Var> item)
+ {
+ reverseMap.Remove(map[item.Value]);
+ return ((IDictionary<Var, Var>)map).Remove(item);
+ }
+
+ public bool TryGetValue(Var key, out Var value)
+ {
+ return ((IDictionary<Var, Var>)map).TryGetValue(key, out value);
+ }
+
+ IEnumerator IEnumerable.GetEnumerator()
+ {
+ return map.GetEnumerator();
+ }
+
+ #endregion
+
  #region constructors
 
+ public VarMap()
+ {
+ map = new Dictionary<Var, Var>();
+ reverseMap = new Dictionary<Var, Var>();
+ }
+
+ private VarMap(Dictionary<Var, Var> map, Dictionary<Var, Var> reverseMap)
+ {
+ this.map = map;
+ this.reverseMap = reverseMap;
+ }
+
  #endregion
  }
 }