mcs/class/referencesource/System.Data.Entity/System/Data/Common/EntitySql/StaticContext.cs

   1 //---------------------------------------------------------------------
   2 // <copyright file="StaticContext.cs" company="Microsoft">
   3 //      Copyright (c) Microsoft Corporation.  All rights reserved.
   4 // </copyright>
   5 //
   6 // @owner  Microsoft
   7 // @backupOwner Microsoft
   8 //---------------------------------------------------------------------
   9
  10 namespace System.Data.Common.EntitySql
  11 {
  12     using System.Collections.Generic;
  13     using System.Data.Common.CommandTrees;
  14     using System.Data.Common.CommandTrees.ExpressionBuilder;
  15     using System.Data.Entity;
  16     using System.Diagnostics;
  17
  18     /// <summary>
  19     /// Represents a scope of key-value pairs.
  20     /// </summary>
  21     internal sealed class Scope : IEnumerable<KeyValuePair<string, ScopeEntry>>
  22     {
  23         private readonly Dictionary<string, ScopeEntry> _scopeEntries;
  24
  25         /// <summary>
  26         /// Initialize using a given key comparer.
  27         /// </summary>
  28         /// <param name="keyComparer"></param>
  29         internal Scope(IEqualityComparer<string> keyComparer)
  30         {
  31             _scopeEntries = new Dictionary<string, ScopeEntry>(keyComparer);
  32         }
  33
  34         /// <summary>
  35         /// Add new key to the scope. If key already exists - throw.
  36         /// </summary>
  37         internal Scope Add(string key, ScopeEntry value)
  38         {
  39             _scopeEntries.Add(key, value);
  40             return this;
  41         }
  42
  43         /// <summary>
  44         /// Remove an entry from the scope.
  45         /// </summary>
  46         internal void Remove(string key)
  47         {
  48             Debug.Assert(Contains(key));
  49             _scopeEntries.Remove(key);
  50         }
  51
  52         internal void Replace(string key, ScopeEntry value)
  53         {
  54             Debug.Assert(Contains(key));
  55             _scopeEntries[key] = value;
  56         }
  57
  58         /// <summary>
  59         /// Returns true if the key belongs to the scope.
  60         /// </summary>
  61         internal bool Contains(string key)
  62         {
  63             return _scopeEntries.ContainsKey(key);
  64         }
  65
  66         /// <summary>
  67         /// Search item by key. Returns true in case of success and false otherwise.
  68         /// </summary>
  69         internal bool TryLookup(string key, out ScopeEntry value)
  70         {
  71             return (_scopeEntries.TryGetValue(key, out value));
  72         }
  73
  74         #region GetEnumerator
  75         public Dictionary<string, ScopeEntry>.Enumerator GetEnumerator()
  76         {
  77             return _scopeEntries.GetEnumerator();
  78         }
  79
  80         System.Collections.Generic.IEnumerator<KeyValuePair<string, ScopeEntry>> System.Collections.Generic.IEnumerable<KeyValuePair<string, ScopeEntry>>.GetEnumerator()
  81         {
  82             return _scopeEntries.GetEnumerator();
  83         }
  84
  85         System.Collections.IEnumerator System.Collections.IEnumerable.GetEnumerator()
  86         {
  87             return _scopeEntries.GetEnumerator();
  88         }
  89         #endregion
  90     }
  91
  92     internal enum ScopeEntryKind
  93     {
  94         SourceVar,
  95         GroupKeyDefinition,
  96         ProjectionItemDefinition,
  97         FreeVar,
  98         /// <summary>
  99         /// Represents a group input scope entry that should no longer be referenced.
 100         /// </summary>
 101         InvalidGroupInputRef
 102     }
 103
 104     /// <summary>
 105     /// Represents an entry in the scope.
 106     /// </summary>
 107     internal abstract class ScopeEntry
 108     {
 109         private readonly ScopeEntryKind _scopeEntryKind;
 110
 111         internal ScopeEntry(ScopeEntryKind scopeEntryKind)
 112         {
 113             _scopeEntryKind = scopeEntryKind;
 114         }
 115
 116         internal ScopeEntryKind EntryKind
 117         {
 118             get { return _scopeEntryKind; }
 119         }
 120
 121         /// <summary>
 122         /// Returns CQT expression corresponding to the scope entry.
 123         /// </summary>
 124         internal abstract DbExpression GetExpression(string refName, ErrorContext errCtx);
 125     }
 126
 127     internal interface IGroupExpressionExtendedInfo
 128     {
 129         /// <summary>
 130         /// Returns <see cref="DbGroupExpressionBinding.GroupVariable"/> based expression during the <see cref="DbGroupByExpression"/> construction process, otherwise null.
 131         /// </summary>
 132         DbExpression GroupVarBasedExpression { get; }
 133
 134         /// <summary>
 135         /// Returns <see cref="DbGroupAggregate"/> based expression during the <see cref="DbGroupByExpression"/> construction process, otherwise null.
 136         /// </summary>
 137         DbExpression GroupAggBasedExpression { get; }
 138     }
 139
 140     internal interface IGetAlternativeName
 141     {
 142         /// <summary>
 143         /// If current scope entry reperesents an alternative group key name (see SemanticAnalyzer.ProcessGroupByClause(...) for more info)
 144         /// then this property returns the alternative name, otherwise null.
 145         /// </summary>
 146         string[] AlternativeName { get; }
 147     }
 148
 149     /// <summary>
 150     /// Represents simple source var scope entry.
 151     /// </summary>
 152     internal sealed class SourceScopeEntry : ScopeEntry, IGroupExpressionExtendedInfo, IGetAlternativeName
 153     {
 154         private readonly string[] _alternativeName;
 155         private List<string> _propRefs;
 156         private DbExpression _varBasedExpression;
 157         private DbExpression _groupVarBasedExpression;
 158         private DbExpression _groupAggBasedExpression;
 159         private bool _joinClauseLeftExpr = false;
 160
 161         internal SourceScopeEntry(DbVariableReferenceExpression varRef) : this(varRef, null) { }
 162
 163         internal SourceScopeEntry(DbVariableReferenceExpression varRef, string[] alternativeName)
 164             : base(ScopeEntryKind.SourceVar)
 165         {
 166             _varBasedExpression = varRef;
 167             _alternativeName = alternativeName;
 168         }
 169
 170         internal override DbExpression GetExpression(string refName, ErrorContext errCtx)
 171         {
 172             return _varBasedExpression;
 173         }
 174
 175         DbExpression IGroupExpressionExtendedInfo.GroupVarBasedExpression
 176         {
 177             get { return _groupVarBasedExpression; }
 178         }
 179
 180         DbExpression IGroupExpressionExtendedInfo.GroupAggBasedExpression
 181         {
 182             get { return _groupAggBasedExpression; }
 183         }
 184
 185         internal bool IsJoinClauseLeftExpr
 186         {
 187             get { return _joinClauseLeftExpr; }
 188             set { _joinClauseLeftExpr = value; }
 189         }
 190
 191         string[] IGetAlternativeName.AlternativeName
 192         {
 193             get { return _alternativeName; }
 194         }
 195
 196         /// <summary>
 197         /// Prepend <paramref name="parentVarRef"/> to the property chain.
 198         /// </summary>
 199         internal SourceScopeEntry AddParentVar(DbVariableReferenceExpression parentVarRef)
 200         {
 201             //
 202             // No parent var adjustment is allowed while adjusted to group var (see AdjustToGroupVar(...) for more info).
 203             //
 204             Debug.Assert(_groupVarBasedExpression == null, "_groupVarBasedExpression == null");
 205             Debug.Assert(_groupAggBasedExpression == null, "_groupAggBasedExpression == null");
 206
 207             if (_propRefs == null)
 208             {
 209                 Debug.Assert(_varBasedExpression is DbVariableReferenceExpression, "_varBasedExpression is DbVariableReferenceExpression");
 210                 _propRefs = new List<string>(2);
 211                 _propRefs.Add(((DbVariableReferenceExpression)_varBasedExpression).VariableName);
 212             }
 213
 214             _varBasedExpression = parentVarRef;
 215             for (int i = _propRefs.Count - 1; i >= 0; --i)
 216             {
 217                 _varBasedExpression = _varBasedExpression.Property(_propRefs[i]);
 218             }
 219             _propRefs.Add(parentVarRef.VariableName);
 220
 221             return this;
 222         }
 223
 224         /// <summary>
 225         /// Replace existing var at the head of the property chain with the new <paramref name="parentVarRef"/>.
 226         /// </summary>
 227         internal void ReplaceParentVar(DbVariableReferenceExpression parentVarRef)
 228         {
 229             //
 230             // No parent var adjustment is allowed while adjusted to group var (see AdjustToGroupVar(...) for more info).
 231             //
 232             Debug.Assert(_groupVarBasedExpression == null, "_groupVarBasedExpression == null");
 233             Debug.Assert(_groupAggBasedExpression == null, "_groupAggBasedExpression == null");
 234
 235             if (_propRefs == null)
 236             {
 237                 Debug.Assert(_varBasedExpression is DbVariableReferenceExpression, "_varBasedExpression is DbVariableReferenceExpression");
 238                 _varBasedExpression = parentVarRef;
 239             }
 240             else
 241             {
 242                 Debug.Assert(_propRefs.Count > 0, "_propRefs.Count > 0");
 243                 _propRefs.RemoveAt(_propRefs.Count - 1);
 244                 AddParentVar(parentVarRef);
 245             }
 246         }
 247
 248         /// <summary>
 249         /// Rebuild the current scope entry expression as the property chain off the <paramref name="parentVarRef"/> expression.
 250         /// Also build
 251         ///     - <see cref="IGroupExpressionExtendedInfo.GroupVarBasedExpression"/> off the <paramref name="parentGroupVarRef"/> expression;
 252         ///     - <see cref="IGroupExpressionExtendedInfo.GroupAggBasedExpression"/> off the <paramref name="groupAggRef"/> expression.
 253         /// This adjustment is reversable by <see cref="RollbackAdjustmentToGroupVar"/>(...).
 254         /// </summary>
 255         internal void AdjustToGroupVar(DbVariableReferenceExpression parentVarRef, DbVariableReferenceExpression parentGroupVarRef, DbVariableReferenceExpression groupAggRef)
 256         {
 257             // Adjustment is not reentrant.
 258             Debug.Assert(_groupVarBasedExpression == null, "_groupVarBasedExpression == null");
 259             Debug.Assert(_groupAggBasedExpression == null, "_groupAggBasedExpression == null");
 260
 261             //
 262             // Let's assume this entry represents variable "x" in the following query:
 263             //      select x, y, z from {1, 2} as x join {2, 3} as y on x = y join {3, 4} as z on y = z
 264             // In this case _propRefs contains x._##join0._##join1 and the corresponding input expression looks like this:
 265             //     |_Input : '_##join1'
 266             //     | |_InnerJoin
 267             //     |   |_Left : '_##join0'
 268             //     |   | |_InnerJoin
 269             //     |   |   |_Left : 'x'
 270             //     |   |   |_Right : 'y'
 271             //     |   |_Right : 'z'
 272             // When we start processing a group by, like in this query:
 273             //      select k1, k2, k3 from {1, 2} as x join {2, 3} as y on x = y join {3, 4} as z on y = z group by x as k1, y as k2, z as k3
 274             // we are switching to the following input expression:
 275             //     |_Input : '_##geb2', '_##group3'
 276             //     | |_InnerJoin
 277             //     |   |_Left : '_##join0'
 278             //     |   | |_InnerJoin
 279             //     |   |   |_Left : 'x'
 280             //     |   |   |_Right : 'y'
 281             //     |   |_Right : 'z'
 282             // where _##join1 is replaced by _##geb2 for the regular expression and by _##group3 for the group var based expression.
 283             // So the switch, or the adjustment, is done by
 284             //      a. replacing _##join1 with _##geb2 in _propRefs and rebuilding the regular expression accordingly to get
 285             //         the following property chain: _##geb2._##join1.x
 286             //      b. building a group var based expression using _##group3 instead of _##geb2 to get
 287             //         the following property chain: _##group3._##join1.x
 288             //
 289
 290             //
 291             // Rebuild ScopeEntry.Expression using the new parent var.
 292             //
 293             ReplaceParentVar(parentVarRef);
 294
 295             //
 296             // Build the GroupVarBasedExpression and GroupAggBasedExpression,
 297             // take into account that parentVarRef has already been added to the _propRefs in the AdjustToParentVar(...) call, so ignore it.
 298             //
 299             _groupVarBasedExpression = parentGroupVarRef;
 300             _groupAggBasedExpression = groupAggRef;
 301             if (_propRefs != null)
 302             {
 303                 for (int i = _propRefs.Count - 2/*ignore the parentVarRef*/; i >= 0; --i)
 304                 {
 305                     _groupVarBasedExpression = _groupVarBasedExpression.Property(_propRefs[i]);
 306                     _groupAggBasedExpression = _groupAggBasedExpression.Property(_propRefs[i]);
 307                 }
 308             }
 309         }
 310
 311         /// <summary>
 312         /// Rolls back the <see cref="AdjustToGroupVar"/>(...) adjustment, clears the <see cref="IGroupExpressionExtendedInfo.GroupVarBasedExpression"/>.
 313         /// </summary>
 314         internal void RollbackAdjustmentToGroupVar(DbVariableReferenceExpression pregroupParentVarRef)
 315         {
 316             Debug.Assert(_groupVarBasedExpression != null, "_groupVarBasedExpression != null");
 317
 318             _groupVarBasedExpression = null;
 319             _groupAggBasedExpression = null;
 320             ReplaceParentVar(pregroupParentVarRef);
 321         }
 322     }
 323
 324     /// <summary>
 325     /// Represents a group input scope entry that should no longer be referenced.
 326     /// </summary>
 327     internal sealed class InvalidGroupInputRefScopeEntry : ScopeEntry
 328     {
 329         internal InvalidGroupInputRefScopeEntry()
 330             : base(ScopeEntryKind.InvalidGroupInputRef) { }
 331
 332         internal override DbExpression GetExpression(string refName, ErrorContext errCtx)
 333         {
 334             throw EntityUtil.EntitySqlError(errCtx, Strings.InvalidGroupIdentifierReference(refName));
 335         }
 336     }
 337
 338     /// <summary>
 339     /// Represents group key during GROUP BY clause processing phase, used during group aggregate search mode.
 340     /// This entry will be replaced by the <see cref="SourceScopeEntry"/> when GROUP BY processing is complete.
 341     /// </summary>
 342     internal sealed class GroupKeyDefinitionScopeEntry : ScopeEntry, IGroupExpressionExtendedInfo, IGetAlternativeName
 343     {
 344         private readonly DbExpression _varBasedExpression;
 345         private readonly DbExpression _groupVarBasedExpression;
 346         private readonly DbExpression _groupAggBasedExpression;
 347         private readonly string[] _alternativeName;
 348
 349         internal GroupKeyDefinitionScopeEntry(
 350             DbExpression varBasedExpression,
 351             DbExpression groupVarBasedExpression, DbExpression
 352             groupAggBasedExpression,
 353             string[] alternativeName) : base(ScopeEntryKind.GroupKeyDefinition)
 354         {
 355             _varBasedExpression = varBasedExpression;
 356             _groupVarBasedExpression = groupVarBasedExpression;
 357             _groupAggBasedExpression = groupAggBasedExpression;
 358             _alternativeName = alternativeName;
 359         }
 360
 361         internal override DbExpression GetExpression(string refName, ErrorContext errCtx)
 362         {
 363             return _varBasedExpression;
 364         }
 365
 366         DbExpression IGroupExpressionExtendedInfo.GroupVarBasedExpression
 367         {
 368             get
 369             {
 370                 return _groupVarBasedExpression;
 371             }
 372         }
 373
 374         DbExpression IGroupExpressionExtendedInfo.GroupAggBasedExpression
 375         {
 376             get { return _groupAggBasedExpression; }
 377         }
 378
 379         string[] IGetAlternativeName.AlternativeName
 380         {
 381             get { return _alternativeName; }
 382         }
 383     }
 384
 385     /// <summary>
 386     /// Represents a projection item definition scope entry.
 387     /// </summary>
 388     internal sealed class ProjectionItemDefinitionScopeEntry : ScopeEntry
 389     {
 390         private readonly DbExpression _expression;
 391
 392         internal ProjectionItemDefinitionScopeEntry(DbExpression expression)
 393             : base(ScopeEntryKind.ProjectionItemDefinition)
 394         {
 395             _expression = expression;
 396         }
 397
 398         internal override DbExpression GetExpression(string refName, ErrorContext errCtx)
 399         {
 400             return _expression;
 401         }
 402     }
 403
 404     /// <summary>
 405     /// Represents a free variable scope entry.
 406     /// Example: parameters of an inline function definition are free variables in the scope of the function definition.
 407     /// </summary>
 408     internal sealed class FreeVariableScopeEntry : ScopeEntry
 409     {
 410         private readonly DbVariableReferenceExpression _varRef;
 411
 412         internal FreeVariableScopeEntry(DbVariableReferenceExpression varRef)
 413             : base(ScopeEntryKind.FreeVar)
 414         {
 415             _varRef = varRef;
 416         }
 417
 418         internal override DbExpression GetExpression(string refName, ErrorContext errCtx)
 419         {
 420             return _varRef;
 421         }
 422     }
 423
 424     /// <summary>
 425     /// Represents a generic list of scopes.
 426     /// </summary>
 427     internal sealed class ScopeManager
 428     {
 429         private readonly IEqualityComparer<string> _keyComparer;
 430         private readonly List<Scope> _scopes = new List<Scope>();
 431
 432         /// <summary>
 433         /// Initialize scope manager using given key-string comparer.
 434         /// </summary>
 435         internal ScopeManager(IEqualityComparer<string> keyComparer)
 436         {
 437             _keyComparer = keyComparer;
 438         }
 439
 440         /// <summary>
 441         /// Enter a new scope.
 442         /// </summary>
 443         internal void EnterScope()
 444         {
 445             _scopes.Add(new Scope(_keyComparer));
 446         }
 447
 448         /// <summary>
 449         /// Leave the current scope.
 450         /// </summary>
 451         internal void LeaveScope()
 452         {
 453             Debug.Assert(CurrentScopeIndex >= 0);
 454             _scopes.RemoveAt(CurrentScopeIndex);
 455         }
 456
 457         /// <summary>
 458         /// Return current scope index.
 459         /// Outer scopes have smaller index values than inner scopes.
 460         /// </summary>
 461         internal int CurrentScopeIndex
 462         {
 463             get
 464             {
 465                 return _scopes.Count - 1;
 466             }
 467         }
 468
 469         /// <summary>
 470         /// Return current scope.
 471         /// </summary>
 472         internal Scope CurrentScope
 473         {
 474             get
 475             {
 476                 return _scopes[CurrentScopeIndex];
 477             }
 478         }
 479
 480         /// <summary>
 481         /// Get a scope by the index.
 482         /// </summary>
 483         internal Scope GetScopeByIndex(int scopeIndex)
 484         {
 485             Debug.Assert(scopeIndex >= 0, "scopeIndex >= 0");
 486             Debug.Assert(scopeIndex <= CurrentScopeIndex, "scopeIndex <= CurrentScopeIndex");
 487             if (0 > scopeIndex || scopeIndex > CurrentScopeIndex)
 488             {
 489                 throw EntityUtil.EntitySqlError(Strings.InvalidScopeIndex);
 490             }
 491             return _scopes[scopeIndex];
 492         }
 493
 494         /// <summary>
 495         /// Rollback all scopes to the scope at the index.
 496         /// </summary>
 497         internal void RollbackToScope(int scopeIndex)
 498         {
 499             //
 500             // assert preconditions
 501             //
 502             Debug.Assert(scopeIndex >= 0, "[PRE] savePoint.ScopeIndex >= 0");
 503             Debug.Assert(scopeIndex <= CurrentScopeIndex, "[PRE] savePoint.ScopeIndex <= CurrentScopeIndex");
 504             Debug.Assert(CurrentScopeIndex >= 0, "[PRE] CurrentScopeIndex >= 0");
 505
 506             if (scopeIndex > CurrentScopeIndex || scopeIndex < 0 || CurrentScopeIndex < 0)
 507             {
 508                 throw EntityUtil.EntitySqlError(Strings.InvalidSavePoint);
 509             }
 510
 511             int delta = CurrentScopeIndex - scopeIndex;
 512             if (delta > 0)
 513             {
 514                 _scopes.RemoveRange(scopeIndex + 1, CurrentScopeIndex - scopeIndex);
 515             }
 516
 517             //
 518             // make sure invariants are preserved
 519             //
 520             Debug.Assert(scopeIndex == CurrentScopeIndex, "[POST] savePoint.ScopeIndex == CurrentScopeIndex");
 521             Debug.Assert(CurrentScopeIndex >= 0, "[POST] CurrentScopeIndex >= 0");
 522
 523         }
 524
 525         /// <summary>
 526         /// True if key exists in current scope.
 527         /// </summary>
 528         internal bool IsInCurrentScope(string key)
 529         {
 530             return CurrentScope.Contains(key);
 531         }
 532     }
 533 }