mcs/class/System.Data.Linq/src/DbLinq/Data/Linq/DataContext.cs

   1 #region MIT license\r
   2 // \r
   3 // MIT license\r
   4 //\r
   5 // Copyright (c) 2007-2008 Jiri Moudry, Pascal Craponne\r
   6 // \r
   7 // Permission is hereby granted, free of charge, to any person obtaining a copy\r
   8 // of this software and associated documentation files (the "Software"), to deal\r
   9 // in the Software without restriction, including without limitation the rights\r
  10 // to use, copy, modify, merge, publish, distribute, sublicense, and/or sell\r
  11 // copies of the Software, and to permit persons to whom the Software is\r
  12 // furnished to do so, subject to the following conditions:\r
  13 // \r
  14 // The above copyright notice and this permission notice shall be included in\r
  15 // all copies or substantial portions of the Software.\r
  16 // \r
  17 // THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\r
  18 // IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\r
  19 // FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\r
  20 // AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\r
  21 // LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\r
  22 // OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\r
  23 // THE SOFTWARE.\r
  24 // \r
  25 #endregion\r
  26 \r
  27 using System;\r
  28 using System.Collections;\r
  29 using System.Data;\r
  30 using System.Data.Common;\r
  31 using System.Data.Linq;\r
  32 using System.Data.Linq.Mapping;\r
  33 using System.Linq.Expressions;\r
  34 using System.Collections.Generic;\r
  35 using System.IO;\r
  36 using System.Linq;\r
  37 using System.Reflection;\r
  38 using System.Reflection.Emit;\r
  39 \r
  40 #if MONO_STRICT\r
  41 using AttributeMappingSource  = System.Data.Linq.Mapping.AttributeMappingSource;\r
  42 #else\r
  43 using AttributeMappingSource  = DbLinq.Data.Linq.Mapping.AttributeMappingSource;\r
  44 #endif\r
  45 \r
  46 using DbLinq;\r
  47 using DbLinq.Data.Linq;\r
  48 using DbLinq.Data.Linq.Database;\r
  49 using DbLinq.Data.Linq.Database.Implementation;\r
  50 using DbLinq.Data.Linq.Identity;\r
  51 using DbLinq.Data.Linq.Implementation;\r
  52 using DbLinq.Data.Linq.Mapping;\r
  53 using DbLinq.Data.Linq.Sugar;\r
  54 using DbLinq.Factory;\r
  55 using DbLinq.Util;\r
  56 using DbLinq.Vendor;\r
  57 \r
  58 #if MONO_STRICT\r
  59 namespace System.Data.Linq\r
  60 #else\r
  61 namespace DbLinq.Data.Linq\r
  62 #endif\r
  63 {\r
  64     public partial class DataContext : IDisposable\r
  65     {\r
  66         //private readonly Dictionary<string, ITable> _tableMap = new Dictionary<string, ITable>();\r
  67         private readonly Dictionary<Type, ITable> _tableMap = new Dictionary<Type, ITable>();\r
  68 \r
  69         public MetaModel Mapping { get; private set; }\r
  70         // PC question: at ctor, we get a IDbConnection and the Connection property exposes a DbConnection\r
  71         //              WTF?\r
  72         public DbConnection Connection { get { return DatabaseContext.Connection as DbConnection; } }\r
  73 \r
  74         // all properties below are set public to optionally be injected\r
  75         internal IVendor Vendor { get; set; }\r
  76         internal IQueryBuilder QueryBuilder { get; set; }\r
  77         internal IQueryRunner QueryRunner { get; set; }\r
  78         internal IMemberModificationHandler MemberModificationHandler { get; set; }\r
  79         internal IDatabaseContext DatabaseContext { get; private set; }\r
  80         // /all properties...\r
  81 \r
  82         private bool objectTrackingEnabled = true;\r
  83         private bool deferredLoadingEnabled = true;\r
  84 \r
  85         private bool queryCacheEnabled = false;\r
  86 \r
  87         /// <summary>\r
  88         /// Disable the QueryCache: this is surely good for rarely used Select, since preparing\r
  89         /// the SelectQuery to be cached could require more time than build the sql from scratch.\r
  90         /// </summary>\r
  91         [DBLinqExtended]\r
  92         public bool QueryCacheEnabled \r
  93         {\r
  94             get { return queryCacheEnabled; }\r
  95             set { queryCacheEnabled = value; }\r
  96         }\r
  97 \r
  98         private IEntityTracker currentTransactionEntities;\r
  99         private IEntityTracker CurrentTransactionEntities\r
 100         {\r
 101             get\r
 102             {\r
 103                 if (this.currentTransactionEntities == null)\r
 104                 {\r
 105                     if (this.ObjectTrackingEnabled)\r
 106                         this.currentTransactionEntities = new EntityTracker();\r
 107                     else\r
 108                         this.currentTransactionEntities = new DisabledEntityTracker();\r
 109                 }\r
 110                 return this.currentTransactionEntities;\r
 111             }\r
 112         }\r
 113 \r
 114         private IEntityTracker allTrackedEntities;\r
 115         private IEntityTracker AllTrackedEntities\r
 116         {\r
 117             get\r
 118             {\r
 119                 if (this.allTrackedEntities == null)\r
 120                 {\r
 121                     allTrackedEntities = ObjectTrackingEnabled\r
 122                         ? (IEntityTracker) new EntityTracker()\r
 123                         : (IEntityTracker) new DisabledEntityTracker();\r
 124                 }\r
 125                 return this.allTrackedEntities;\r
 126             }\r
 127         }\r
 128 \r
 129         private IIdentityReaderFactory identityReaderFactory;\r
 130         private readonly IDictionary<Type, IIdentityReader> identityReaders = new Dictionary<Type, IIdentityReader>();\r
 131 \r
 132         /// <summary>\r
 133         /// The default behavior creates one MappingContext.\r
 134         /// </summary>\r
 135         [DBLinqExtended]\r
 136         internal virtual MappingContext _MappingContext { get; set; }\r
 137 \r
 138         [DBLinqExtended]\r
 139         internal IVendorProvider _VendorProvider { get; set; }\r
 140 \r
 141         public DataContext(IDbConnection connection, MappingSource mapping)\r
 142         {\r
 143             Profiler.At("START DataContext(IDbConnection, MappingSource)");\r
 144             Init(new DatabaseContext(connection), mapping, null);\r
 145             Profiler.At("END DataContext(IDbConnection, MappingSource)");\r
 146         }\r
 147 \r
 148         public DataContext(IDbConnection connection)\r
 149         {\r
 150             Profiler.At("START DataContext(IDbConnection)");\r
 151             if (connection == null)\r
 152                 throw new ArgumentNullException("connection");\r
 153 \r
 154             Init(new DatabaseContext(connection), null, null);\r
 155             Profiler.At("END DataContext(IDbConnection)");\r
 156         }\r
 157 \r
 158         [DbLinqToDo]\r
 159         public DataContext(string fileOrServerOrConnection, MappingSource mapping)\r
 160         {\r
 161             Profiler.At("START DataContext(string, MappingSource)");\r
 162             if (fileOrServerOrConnection == null)\r
 163                 throw new ArgumentNullException("fileOrServerOrConnection");\r
 164             if (mapping == null)\r
 165                 throw new ArgumentNullException("mapping");\r
 166 \r
 167             if (File.Exists(fileOrServerOrConnection))\r
 168                 throw new NotImplementedException("File names not supported.");\r
 169 \r
 170             // Is this a decent server name check?\r
 171             // It assumes that the connection string will have at least 2\r
 172             // parameters (separated by ';')\r
 173             if (!fileOrServerOrConnection.Contains(";"))\r
 174                 throw new NotImplementedException("Server name not supported.");\r
 175 \r
 176             // Assume it's a connection string...\r
 177             IVendor ivendor = GetVendor(ref fileOrServerOrConnection);\r
 178 \r
 179             IDbConnection dbConnection = ivendor.CreateDbConnection(fileOrServerOrConnection);\r
 180             Init(new DatabaseContext(dbConnection), mapping, ivendor);\r
 181             Profiler.At("END DataContext(string, MappingSource)");\r
 182         }\r
 183 \r
 184         /// <summary>\r
 185         /// Construct DataContext, given a connectionString.\r
 186         /// To determine which DB type to go against, we look for 'DbLinqProvider=xxx' substring.\r
 187         /// If not found, we assume that we are dealing with MS Sql Server.\r
 188         /// \r
 189         /// Valid values are names of provider DLLs (or any other DLL containing an IVendor implementation)\r
 190         /// DbLinqProvider=Mysql\r
 191         /// DbLinqProvider=Oracle etc.\r
 192         /// </summary>\r
 193         /// <param name="connectionString">specifies file or server connection</param>\r
 194         [DbLinqToDo]\r
 195         public DataContext(string connectionString)\r
 196         {\r
 197             Profiler.At("START DataContext(string)");\r
 198             IVendor ivendor = GetVendor(ref connectionString);\r
 199 \r
 200             IDbConnection dbConnection = ivendor.CreateDbConnection(connectionString);\r
 201             Init(new DatabaseContext(dbConnection), null, ivendor);\r
 202 \r
 203             Profiler.At("END DataContext(string)");\r
 204         }\r
 205 \r
 206         private IVendor GetVendor(ref string connectionString)\r
 207         {\r
 208             if (connectionString == null)\r
 209                 throw new ArgumentNullException("connectionString");\r
 210 \r
 211             Assembly assy;\r
 212             string vendorClassToLoad;\r
 213             GetVendorInfo(ref connectionString, out assy, out vendorClassToLoad);\r
 214 \r
 215             var types =\r
 216                 from type in assy.GetTypes()\r
 217                 where type.Name.ToLowerInvariant() == vendorClassToLoad.ToLowerInvariant() &&\r
 218                     type.GetInterfaces().Contains(typeof(IVendor)) &&\r
 219                     type.GetConstructor(Type.EmptyTypes) != null\r
 220                 select type;\r
 221             if (!types.Any())\r
 222             {\r
 223                 throw new ArgumentException(string.Format("Found no IVendor class in assembly `{0}' named `{1}' having a default constructor.",\r
 224                     assy.GetName().Name, vendorClassToLoad));\r
 225             }\r
 226             else if (types.Count() > 1)\r
 227             {\r
 228                 throw new ArgumentException(string.Format("Found too many IVendor classes in assembly `{0}' named `{1}' having a default constructor.",\r
 229                     assy.GetName().Name, vendorClassToLoad));\r
 230             }\r
 231             return (IVendor) Activator.CreateInstance(types.First());\r
 232         }\r
 233 \r
 234         private void GetVendorInfo(ref string connectionString, out Assembly assembly, out string typeName)\r
 235         {\r
 236             System.Text.RegularExpressions.Regex reProvider\r
 237                 = new System.Text.RegularExpressions.Regex(@"DbLinqProvider=([\w\.]+);?");\r
 238 \r
 239             string assemblyName = null;\r
 240             string vendor;\r
 241             if (!reProvider.IsMatch(connectionString))\r
 242             {\r
 243                 vendor       = "SqlServer";\r
 244                 assemblyName = "DbLinq.SqlServer";\r
 245             }\r
 246             else\r
 247             {\r
 248                 var match    = reProvider.Match(connectionString);\r
 249                 vendor       = match.Groups[1].Value;\r
 250                 assemblyName = "DbLinq." + vendor;\r
 251 \r
 252                 //plain DbLinq - non MONO: \r
 253                 //IVendor classes are in DLLs such as "DbLinq.MySql.dll"\r
 254                 if (vendor.Contains("."))\r
 255                 {\r
 256                     //already fully qualified DLL name?\r
 257                     throw new ArgumentException("Please provide a short name, such as 'MySql', not '" + vendor + "'");\r
 258                 }\r
 259 \r
 260                 //shorten: "DbLinqProvider=X;Server=Y" -> ";Server=Y"\r
 261                 connectionString = reProvider.Replace(connectionString, "");\r
 262             }\r
 263 \r
 264             typeName = vendor + "Vendor";\r
 265 \r
 266             try\r
 267             {\r
 268 #if MONO_STRICT\r
 269                 assembly = typeof (DataContext).Assembly; // System.Data.Linq.dll\r
 270 #else\r
 271                 assembly = Assembly.Load(assemblyName);\r
 272 #endif\r
 273             }\r
 274             catch (Exception e)\r
 275             {\r
 276                 throw new ArgumentException(\r
 277                         string.Format(\r
 278                             "Unable to load the `{0}' DbLinq vendor within assembly '{1}.dll'.",\r
 279                             assemblyName, vendor),\r
 280                         "connectionString", e);\r
 281             }\r
 282         }\r
 283 \r
 284         private void Init(IDatabaseContext databaseContext, MappingSource mappingSource, IVendor vendor)\r
 285         {\r
 286             if (databaseContext == null)\r
 287                 throw new ArgumentNullException("databaseContext");\r
 288 \r
 289             // Yes, .NET throws an NRE for this.  Why it's not ArgumentNullException, I couldn't tell you.\r
 290             if (databaseContext.Connection.ConnectionString == null)\r
 291                 throw new NullReferenceException();\r
 292 \r
 293             string connectionString = databaseContext.Connection.ConnectionString;\r
 294             _VendorProvider = ObjectFactory.Get<IVendorProvider>();\r
 295             Vendor = vendor ?? \r
 296                 (connectionString != null ? GetVendor(ref connectionString) : null) ??\r
 297                 _VendorProvider.FindVendorByProviderType(typeof(SqlClient.Sql2005Provider));\r
 298             \r
 299             DatabaseContext = databaseContext;\r
 300 \r
 301             MemberModificationHandler = ObjectFactory.Create<IMemberModificationHandler>(); // not a singleton: object is stateful\r
 302             QueryBuilder = ObjectFactory.Get<IQueryBuilder>();\r
 303             QueryRunner = ObjectFactory.Get<IQueryRunner>();\r
 304 \r
 305             //EntityMap = ObjectFactory.Create<IEntityMap>();\r
 306             identityReaderFactory = ObjectFactory.Get<IIdentityReaderFactory>();\r
 307 \r
 308             _MappingContext = new MappingContext();\r
 309 \r
 310             // initialize the mapping information\r
 311             if (mappingSource == null)\r
 312                 mappingSource = new AttributeMappingSource();\r
 313             Mapping = mappingSource.GetModel(GetType());\r
 314         }\r
 315 \r
 316         /// <summary>\r
 317         /// Checks if the table is allready mapped or maps it if not.\r
 318         /// </summary>\r
 319         /// <param name="tableType">Type of the table.</param>\r
 320         /// <exception cref="InvalidOperationException">Thrown if the table is not mappable.</exception>\r
 321         private void CheckTableMapping(Type tableType)\r
 322         {\r
 323             //This will throw an exception if the table is not found\r
 324             if(Mapping.GetTable(tableType) == null)\r
 325             {\r
 326                 throw new InvalidOperationException("The type '" + tableType.Name + "' is not mapped as a Table.");\r
 327             }\r
 328         }\r
 329 \r
 330         /// <summary>\r
 331         /// Returns a Table for the type TEntity.\r
 332         /// </summary>\r
 333         /// <exception cref="InvalidOperationException">If the type TEntity is not mappable as a Table.</exception>\r
 334         /// <typeparam name="TEntity">The table type.</typeparam>\r
 335         public Table<TEntity> GetTable<TEntity>() where TEntity : class\r
 336         {\r
 337             return (Table<TEntity>)GetTable(typeof(TEntity));\r
 338         }\r
 339 \r
 340         /// <summary>\r
 341         /// Returns a Table for the given type.\r
 342         /// </summary>\r
 343         /// <param name="type">The table type.</param>\r
 344         /// <exception cref="InvalidOperationException">If the type is not mappable as a Table.</exception>\r
 345         public ITable GetTable(Type type)\r
 346         {\r
 347             Profiler.At("DataContext.GetTable(typeof({0}))", type != null ? type.Name : null);\r
 348             ITable tableExisting;\r
 349             if (_tableMap.TryGetValue(type, out tableExisting))\r
 350                 return tableExisting;\r
 351 \r
 352             //Check for table mapping\r
 353             CheckTableMapping(type);\r
 354 \r
 355             var tableNew = Activator.CreateInstance(\r
 356                               typeof(Table<>).MakeGenericType(type)\r
 357                               , BindingFlags.NonPublic | BindingFlags.Instance\r
 358                               , null\r
 359                               , new object[] { this }\r
 360                               , System.Globalization.CultureInfo.CurrentCulture) as ITable;\r
 361 \r
 362             _tableMap[type] = tableNew;\r
 363             return tableNew;\r
 364         }\r
 365 \r
 366         public void SubmitChanges()\r
 367         {\r
 368             SubmitChanges(ConflictMode.FailOnFirstConflict);\r
 369         }\r
 370 \r
 371         /// <summary>\r
 372         /// Pings database\r
 373         /// </summary>\r
 374         /// <returns></returns>\r
 375         public bool DatabaseExists()\r
 376         {\r
 377             try\r
 378             {\r
 379                 return Vendor.Ping(this);\r
 380             }\r
 381             catch (Exception)\r
 382             {\r
 383                 return false;\r
 384             }\r
 385         }\r
 386 \r
 387         /// <summary>\r
 388         /// Commits all pending changes to database \r
 389         /// </summary>\r
 390         /// <param name="failureMode"></param>\r
 391         public virtual void SubmitChanges(ConflictMode failureMode)\r
 392         {\r
 393             if (this.objectTrackingEnabled == false)\r
 394                 throw new InvalidOperationException("Object tracking is not enabled for the current data context instance.");\r
 395             using (DatabaseContext.OpenConnection()) //ConnMgr will close connection for us\r
 396             {\r
 397                 if (Transaction != null)\r
 398                     SubmitChangesImpl(failureMode);\r
 399                 else\r
 400                 {\r
 401                     using (IDbTransaction transaction = DatabaseContext.CreateTransaction())\r
 402                     {\r
 403                         try\r
 404                         {\r
 405                             Transaction = (DbTransaction) transaction;\r
 406                             SubmitChangesImpl(failureMode);\r
 407                             // TODO: handle conflicts (which can only occur when concurrency mode is implemented)\r
 408                             transaction.Commit();\r
 409                         }\r
 410                         finally\r
 411                         {\r
 412                             Transaction = null;\r
 413                         }\r
 414                     }\r
 415                 }\r
 416             }\r
 417         }\r
 418 \r
 419         void SubmitChangesImpl(ConflictMode failureMode)\r
 420         {\r
 421             var queryContext = new QueryContext(this);\r
 422 \r
 423             // There's no sense in updating an entity when it's going to \r
 424             // be deleted in the current transaction, so do deletes first.\r
 425             foreach (var entityTrack in CurrentTransactionEntities.EnumerateAll().ToList())\r
 426             {\r
 427                 switch (entityTrack.EntityState)\r
 428                 {\r
 429                     case EntityState.ToDelete:\r
 430                         var deleteQuery = QueryBuilder.GetDeleteQuery(entityTrack.Entity, queryContext);\r
 431                         QueryRunner.Delete(entityTrack.Entity, deleteQuery);\r
 432 \r
 433                         UnregisterDelete(entityTrack.Entity);\r
 434                         AllTrackedEntities.RegisterToDelete(entityTrack.Entity);\r
 435                         AllTrackedEntities.RegisterDeleted(entityTrack.Entity);\r
 436                         break;\r
 437                     default:\r
 438                         // ignore.\r
 439                         break;\r
 440                 }\r
 441             }\r
 442             foreach (var entityTrack in CurrentTransactionEntities.EnumerateAll()\r
 443                     .Concat(AllTrackedEntities.EnumerateAll())\r
 444                     .ToList())\r
 445             {\r
 446                 switch (entityTrack.EntityState)\r
 447                 {\r
 448                     case EntityState.ToInsert:\r
 449                         foreach (var toInsert in GetReferencedObjects(entityTrack.Entity))\r
 450                         {\r
 451                             InsertEntity(toInsert, queryContext);\r
 452                         }\r
 453                         break;\r
 454                     case EntityState.ToWatch:\r
 455                         foreach (var toUpdate in GetReferencedObjects(entityTrack.Entity))\r
 456                         {\r
 457                             UpdateEntity(toUpdate, queryContext);\r
 458                         }\r
 459                         break;\r
 460                     default:\r
 461                         throw new ArgumentOutOfRangeException();\r
 462                 }\r
 463             }\r
 464         }\r
 465 \r
 466         private IEnumerable<object> GetReferencedObjects(object value)\r
 467         {\r
 468             var values = new EntitySet<object>();\r
 469             FillReferencedObjects(value, values);\r
 470             return values;\r
 471         }\r
 472 \r
 473         // Breadth-first traversal of an object graph\r
 474         private void FillReferencedObjects(object parent, EntitySet<object> values)\r
 475         {\r
 476             if (parent == null)\r
 477                 return;\r
 478             var children = new Queue<object>();\r
 479                         children.Enqueue(parent);\r
 480                         while (children.Count > 0)\r
 481                         {\r
 482                 object value = children.Dequeue();\r
 483                 values.Add(value);\r
 484                 IEnumerable<MetaAssociation> associationList = Mapping.GetMetaType(value.GetType()).Associations.Where(a => !a.IsForeignKey);\r
 485                 if (associationList.Any())\r
 486                             {\r
 487                                     foreach (MetaAssociation association in associationList)\r
 488                     {\r
 489                         var memberData = association.ThisMember;\r
 490                         var entitySetValue = memberData.Member.GetMemberValue(value);\r
 491 \r
 492                         if (entitySetValue != null)\r
 493                         {\r
 494                                                     var hasLoadedOrAssignedValues = entitySetValue.GetType().GetProperty("HasLoadedOrAssignedValues");\r
 495                                                     if (!((bool)hasLoadedOrAssignedValues.GetValue(entitySetValue, null)))\r
 496                                                             continue;   // execution deferred; ignore.\r
 497                                                     foreach (var o in ((IEnumerable)entitySetValue))\r
 498                                                             children.Enqueue(o);\r
 499                                             }\r
 500                     }\r
 501                 }\r
 502                         }\r
 503         }\r
 504 \r
 505         private void InsertEntity(object entity, QueryContext queryContext)\r
 506         {\r
 507             var insertQuery = QueryBuilder.GetInsertQuery(entity, queryContext);\r
 508             QueryRunner.Insert(entity, insertQuery);\r
 509             Register(entity);\r
 510             UpdateReferencedObjects(entity);\r
 511             MoveToAllTrackedEntities(entity, true);\r
 512         }\r
 513 \r
 514         private void UpdateEntity(object entity, QueryContext queryContext)\r
 515         {\r
 516             if (!AllTrackedEntities.ContainsReference(entity))\r
 517                 InsertEntity(entity, queryContext);\r
 518             else if (MemberModificationHandler.IsModified(entity, Mapping))\r
 519             {\r
 520                 var modifiedMembers = MemberModificationHandler.GetModifiedProperties(entity, Mapping);\r
 521                 var updateQuery = QueryBuilder.GetUpdateQuery(entity, modifiedMembers, queryContext);\r
 522                 QueryRunner.Update(entity, updateQuery, modifiedMembers);\r
 523 \r
 524                 RegisterUpdateAgain(entity);\r
 525                 UpdateReferencedObjects(entity);\r
 526                 MoveToAllTrackedEntities(entity, false);\r
 527             }\r
 528         }\r
 529 \r
 530         private void UpdateReferencedObjects(object root)\r
 531         {\r
 532             var metaType = Mapping.GetMetaType(root.GetType());\r
 533             foreach (var assoc in metaType.Associations)\r
 534             {\r
 535                 var memberData = assoc.ThisMember;\r
 536                                 //This is not correct - AutoSyncing applies to auto-updating columns, such as a TimeStamp, not to foreign key associations, which is always automatically synched\r
 537                                 //Confirmed against default .NET l2sql - association columns are always set, even if AutoSync==AutoSync.Never\r
 538                                 //if (memberData.Association.ThisKey.Any(m => (m.AutoSync != AutoSync.Always) && (m.AutoSync != sync)))\r
 539                 //    continue;\r
 540                 var oks = memberData.Association.OtherKey.Select(m => m.StorageMember).ToList();\r
 541                 if (oks.Count == 0)\r
 542                     continue;\r
 543                 var pks = memberData.Association.ThisKey\r
 544                     .Select(m => m.StorageMember.GetMemberValue(root))\r
 545                     .ToList();\r
 546                 if (pks.Count != oks.Count)\r
 547                     throw new InvalidOperationException(\r
 548                         string.Format("Count of primary keys ({0}) doesn't match count of other keys ({1}).",\r
 549                             pks.Count, oks.Count));\r
 550                 var members = memberData.Member.GetMemberValue(root) as IEnumerable;\r
 551                 if (members == null)\r
 552                     continue;\r
 553                 foreach (var member in members)\r
 554                 {\r
 555                     for (int i = 0; i < pks.Count; ++i)\r
 556                     {\r
 557                         oks[i].SetMemberValue(member, pks[i]);\r
 558                     }\r
 559                 }\r
 560             }\r
 561         }\r
 562 \r
 563         private void MoveToAllTrackedEntities(object entity, bool insert)\r
 564         {\r
 565             if (!ObjectTrackingEnabled)\r
 566                 return;\r
 567             if (CurrentTransactionEntities.ContainsReference(entity))\r
 568             {\r
 569                 CurrentTransactionEntities.RegisterToDelete(entity);\r
 570                 if (!insert)\r
 571                     CurrentTransactionEntities.RegisterDeleted(entity);\r
 572             }\r
 573             if (!AllTrackedEntities.ContainsReference(entity))\r
 574             {\r
 575                 var identityReader = _GetIdentityReader(entity.GetType());\r
 576                 AllTrackedEntities.RegisterToWatch(entity, identityReader.GetIdentityKey(entity));\r
 577             }\r
 578         }\r
 579 \r
 580         /// <summary>\r
 581         /// TODO - allow generated methods to call into stored procedures\r
 582         /// </summary>\r
 583         [DBLinqExtended]\r
 584         internal IExecuteResult _ExecuteMethodCall(DataContext context, System.Reflection.MethodInfo method, params object[] sqlParams)\r
 585         {\r
 586             using (DatabaseContext.OpenConnection())\r
 587             {\r
 588                 System.Data.Linq.IExecuteResult result = Vendor.ExecuteMethodCall(context, method, sqlParams);\r
 589                 return result;\r
 590             }\r
 591         }\r
 592 \r
 593         [DbLinqToDo]\r
 594         protected IExecuteResult ExecuteMethodCall(object instance, System.Reflection.MethodInfo methodInfo, params object[] parameters)\r
 595         {\r
 596             throw new NotImplementedException();\r
 597         }\r
 598 \r
 599         #region Identity management\r
 600 \r
 601         [DBLinqExtended]\r
 602         internal IIdentityReader _GetIdentityReader(Type t)\r
 603         {\r
 604             IIdentityReader identityReader;\r
 605             if (!identityReaders.TryGetValue(t, out identityReader))\r
 606             {\r
 607                 identityReader = identityReaderFactory.GetReader(t, this);\r
 608                 identityReaders[t] = identityReader;\r
 609             }\r
 610             return identityReader;\r
 611         }\r
 612 \r
 613         [DBLinqExtended]\r
 614         internal object _GetRegisteredEntity(object entity)\r
 615         {\r
 616             // TODO: check what is faster: by identity or by ref\r
 617             var identityReader = _GetIdentityReader(entity.GetType());\r
 618             var identityKey = identityReader.GetIdentityKey(entity);\r
 619             if (identityKey == null) // if we don't have an entitykey here, it means that the entity has no PK\r
 620                 return entity;\r
 621             // even \r
 622             var registeredEntityTrack = \r
 623                 CurrentTransactionEntities.FindByIdentity(identityKey) ??\r
 624                 AllTrackedEntities.FindByIdentity(identityKey);\r
 625             if (registeredEntityTrack != null)\r
 626                 return registeredEntityTrack.Entity;\r
 627             return null;\r
 628         }\r
 629 \r
 630         //internal object GetRegisteredEntityByKey(IdentityKey identityKey)\r
 631         //{\r
 632         //    return EntityMap[identityKey];\r
 633         //}\r
 634 \r
 635         /// <summary>\r
 636         /// Registers an entity in a watch state\r
 637         /// </summary>\r
 638         /// <param name="entity"></param>\r
 639         /// <returns></returns>\r
 640         [DBLinqExtended]\r
 641         internal object _GetOrRegisterEntity(object entity)\r
 642         {\r
 643             var identityReader = _GetIdentityReader(entity.GetType());\r
 644             var identityKey = identityReader.GetIdentityKey(entity);\r
 645             SetEntitySetsQueries(entity);\r
 646             SetEntityRefQueries(entity);\r
 647 \r
 648             // if we have no identity, we can't track it\r
 649             if (identityKey == null)\r
 650                 return entity;\r
 651 \r
 652             // try to find an already registered entity and return it\r
 653             var registeredEntityTrack = \r
 654                 CurrentTransactionEntities.FindByIdentity(identityKey) ??\r
 655                 AllTrackedEntities.FindByIdentity(identityKey);\r
 656             if (registeredEntityTrack != null)\r
 657                 return registeredEntityTrack.Entity;\r
 658 \r
 659             // otherwise, register and return\r
 660             AllTrackedEntities.RegisterToWatch(entity, identityKey);\r
 661             return entity;\r
 662         }\r
 663 \r
 664         readonly IDataMapper DataMapper = ObjectFactory.Get<IDataMapper>();\r
 665                 private void SetEntityRefQueries(object entity)\r
 666                 {\r
 667             if (!this.deferredLoadingEnabled)\r
 668                 return;\r
 669 \r
 670             // BUG: This is ignoring External Mappings from XmlMappingSource.\r
 671 \r
 672                         Type thisType = entity.GetType();\r
 673                         IEnumerable<MetaAssociation> associationList = Mapping.GetMetaType(entity.GetType()).Associations.Where(a => a.IsForeignKey);\r
 674                         foreach (MetaAssociation association in associationList)\r
 675                         {\r
 676                                 //example of entityRef:Order.Employee\r
 677                                 var memberData = association.ThisMember;\r
 678                                 Type otherTableType = association.OtherType.Type;\r
 679                                 ParameterExpression p = Expression.Parameter(otherTableType, "other");\r
 680 \r
 681                                 var otherTable = GetTable(otherTableType);\r
 682 \r
 683                                 //ie:EmployeeTerritories.EmployeeID\r
 684                                 var foreignKeys = memberData.Association.ThisKey;\r
 685                                 BinaryExpression predicate = null;\r
 686                                 var otherPKs = memberData.Association.OtherKey;\r
 687                                 IEnumerator<MetaDataMember> otherPKEnumerator = otherPKs.GetEnumerator();\r
 688 \r
 689                                 if (otherPKs.Count != foreignKeys.Count)\r
 690                                         throw new InvalidOperationException("Foreign keys don't match ThisKey");\r
 691                                 foreach (MetaDataMember key in foreignKeys)\r
 692                                 {\r
 693                                         otherPKEnumerator.MoveNext();\r
 694 \r
 695                                         var thisForeignKeyProperty = (PropertyInfo)key.Member;\r
 696                                         object thisForeignKeyValue = thisForeignKeyProperty.GetValue(entity, null);\r
 697 \r
 698                                         if (thisForeignKeyValue != null)\r
 699                                         {\r
 700                                                 BinaryExpression keyPredicate;\r
 701                                                 if (!(thisForeignKeyProperty.PropertyType.IsNullable()))\r
 702                                                 {\r
 703                                                         keyPredicate = Expression.Equal(Expression.MakeMemberAccess(p, otherPKEnumerator.Current.Member),\r
 704                                                                                                                                                 Expression.Constant(thisForeignKeyValue));\r
 705                                                 }\r
 706                                                 else\r
 707                                                 {\r
 708                                                         var ValueProperty = thisForeignKeyProperty.PropertyType.GetProperty("Value");\r
 709                                                         keyPredicate = Expression.Equal(Expression.MakeMemberAccess(p, otherPKEnumerator.Current.Member),\r
 710                                                                                                                                          Expression.Constant(ValueProperty.GetValue(thisForeignKeyValue, null)));\r
 711                                                 }\r
 712 \r
 713                                                 if (predicate == null)\r
 714                                                         predicate = keyPredicate;\r
 715                                                 else\r
 716                                                         predicate = Expression.And(predicate, keyPredicate);\r
 717                                         }\r
 718                                 }\r
 719                                 IEnumerable query = null;\r
 720                                 if (predicate != null)\r
 721                                 {\r
 722                                         query = GetOtherTableQuery(predicate, p, otherTableType, otherTable) as IEnumerable;\r
 723                                         //it would be interesting surround the above query with a .Take(1) expression for performance.\r
 724                                 }\r
 725 \r
 726                                 // If no separate Storage is specified, use the member directly\r
 727                                 MemberInfo storage = memberData.StorageMember;\r
 728                                 if (storage == null)\r
 729                                         storage = memberData.Member;\r
 730 \r
 731                                  // Check that the storage is a field or a writable property\r
 732                                 if (!(storage is FieldInfo) && !(storage is PropertyInfo && ((PropertyInfo)storage).CanWrite)) {\r
 733                                         throw new InvalidOperationException(String.Format(\r
 734                                                 "Member {0}.{1} is not a field nor a writable property",\r
 735                                                 storage.DeclaringType, storage.Name));\r
 736                                 }\r
 737 \r
 738                                 Type storageType = storage.GetMemberType();\r
 739 \r
 740                                 object entityRefValue = null;\r
 741                                 if (query != null)\r
 742                                         entityRefValue = Activator.CreateInstance(storageType, query);\r
 743                                 else\r
 744                                         entityRefValue = Activator.CreateInstance(storageType);\r
 745 \r
 746                                 storage.SetMemberValue(entity, entityRefValue);\r
 747                         }\r
 748                 }\r
 749 \r
 750         /// <summary>\r
 751         /// This method is executed when the entity is being registered. Each EntitySet property has a internal query that can be set using the EntitySet.SetSource method.\r
 752         /// Here we set the query source of each EntitySetProperty\r
 753         /// </summary>\r
 754         /// <param name="entity"></param>\r
 755         private void SetEntitySetsQueries(object entity)\r
 756         {\r
 757             if (!this.deferredLoadingEnabled)\r
 758                 return;\r
 759 \r
 760             // BUG: This is ignoring External Mappings from XmlMappingSource.\r
 761 \r
 762                         IEnumerable<MetaAssociation> associationList = Mapping.GetMetaType(entity.GetType()).Associations.Where(a => !a.IsForeignKey);\r
 763 \r
 764                         if (associationList.Any())\r
 765                         {\r
 766                                 foreach (MetaAssociation association in associationList)\r
 767                 {\r
 768                                         //example of entitySet: Employee.EmployeeTerritories\r
 769                                         var memberData = association.ThisMember;\r
 770                                         Type otherTableType = association.OtherType.Type;\r
 771                     ParameterExpression p = Expression.Parameter(otherTableType, "other");\r
 772 \r
 773                     //other table:EmployeeTerritories\r
 774                     var otherTable = GetTable(otherTableType);\r
 775 \r
 776                                         var otherKeys = memberData.Association.OtherKey;\r
 777                                         var thisKeys = memberData.Association.ThisKey;\r
 778                     if (otherKeys.Count != thisKeys.Count)\r
 779                         throw new InvalidOperationException("This keys don't match OtherKey");\r
 780                     BinaryExpression predicate = null;\r
 781                     IEnumerator<MetaDataMember> thisKeyEnumerator = thisKeys.GetEnumerator();\r
 782                                         foreach (MetaDataMember otherKey in otherKeys)\r
 783                     {\r
 784                         thisKeyEnumerator.MoveNext();\r
 785                         //other table member:EmployeeTerritories.EmployeeID\r
 786                                                 var otherTableMember = (PropertyInfo)otherKey.Member;\r
 787 \r
 788                         BinaryExpression keyPredicate;\r
 789                         if (!(otherTableMember.PropertyType.IsNullable()))\r
 790                         {\r
 791                             keyPredicate = Expression.Equal(Expression.MakeMemberAccess(p, otherTableMember),\r
 792                                                                         Expression.Constant(thisKeyEnumerator.Current.Member.GetMemberValue(entity)));\r
 793                         }\r
 794                         else\r
 795                         {\r
 796                             var ValueProperty = otherTableMember.PropertyType.GetProperty("Value");\r
 797                             keyPredicate = Expression.Equal(Expression.MakeMemberAccess(\r
 798                                                                         Expression.MakeMemberAccess(p, otherTableMember),\r
 799                                                                         ValueProperty),\r
 800                                                                      Expression.Constant(thisKeyEnumerator.Current.Member.GetMemberValue(entity)));\r
 801                         }\r
 802                         if (predicate == null)\r
 803                             predicate = keyPredicate;\r
 804                         else\r
 805                             predicate = Expression.And(predicate, keyPredicate);\r
 806                     }\r
 807 \r
 808                     var query = GetOtherTableQuery(predicate, p, otherTableType, otherTable);\r
 809 \r
 810                                         var entitySetValue = memberData.Member.GetMemberValue(entity);\r
 811 \r
 812                     if (entitySetValue == null)\r
 813                     {\r
 814                                                 entitySetValue = Activator.CreateInstance(memberData.Member.GetMemberType());\r
 815                                                 memberData.Member.SetMemberValue(entity, entitySetValue);\r
 816                     }\r
 817 \r
 818                     var hasLoadedOrAssignedValues = entitySetValue.GetType().GetProperty("HasLoadedOrAssignedValues");\r
 819                     if ((bool)hasLoadedOrAssignedValues.GetValue(entitySetValue, null))\r
 820                         continue;\r
 821 \r
 822                     var setSourceMethod = entitySetValue.GetType().GetMethod("SetSource");\r
 823                     setSourceMethod.Invoke(entitySetValue, new[] { query });\r
 824                     //employee.EmployeeTerritories.SetSource(Table[EmployeesTerritories].Where(other=>other.employeeID="WARTH"))\r
 825                 }\r
 826             }\r
 827         }\r
 828 \r
 829                 private static MethodInfo _WhereMethod = typeof(Queryable).GetMethods().First(m => m.Name == "Where");\r
 830         internal object GetOtherTableQuery(Expression predicate, ParameterExpression parameter, Type otherTableType, IQueryable otherTable)\r
 831         {\r
 832             //predicate: other.EmployeeID== "WARTH"\r
 833             Expression lambdaPredicate = Expression.Lambda(predicate, parameter);\r
 834             //lambdaPredicate: other=>other.EmployeeID== "WARTH"\r
 835 \r
 836                         Expression call = Expression.Call(_WhereMethod.MakeGenericMethod(otherTableType), otherTable.Expression, lambdaPredicate);\r
 837             //Table[EmployeesTerritories].Where(other=>other.employeeID="WARTH")\r
 838 \r
 839             return otherTable.Provider.CreateQuery(call);\r
 840         }\r
 841 \r
 842         #endregion\r
 843 \r
 844         #region Insert/Update/Delete management\r
 845 \r
 846         /// <summary>\r
 847         /// Registers an entity for insert\r
 848         /// </summary>\r
 849         /// <param name="entity"></param>\r
 850         internal void RegisterInsert(object entity)\r
 851         {\r
 852             CurrentTransactionEntities.RegisterToInsert(entity);\r
 853         }\r
 854 \r
 855         private void DoRegisterUpdate(object entity)\r
 856         {\r
 857             if (entity == null)\r
 858                 throw new ArgumentNullException("entity");\r
 859 \r
 860             if (!this.objectTrackingEnabled)\r
 861                 return;\r
 862 \r
 863             var identityReader = _GetIdentityReader(entity.GetType());\r
 864             var identityKey = identityReader.GetIdentityKey(entity);\r
 865             // if we have no key, we can not watch\r
 866             if (identityKey == null || identityKey.Keys.Count == 0)\r
 867                 return;\r
 868             // register entity\r
 869             AllTrackedEntities.RegisterToWatch(entity, identityKey);\r
 870         }\r
 871 \r
 872         /// <summary>\r
 873         /// Registers an entity for update\r
 874         /// The entity will be updated only if some of its members have changed after the registration\r
 875         /// </summary>\r
 876         /// <param name="entity"></param>\r
 877         internal void RegisterUpdate(object entity)\r
 878         {\r
 879             DoRegisterUpdate(entity);\r
 880                         MemberModificationHandler.Register(entity, Mapping);\r
 881         }\r
 882 \r
 883         /// <summary>\r
 884         /// Registers or re-registers an entity and clears its state\r
 885         /// </summary>\r
 886         /// <param name="entity"></param>\r
 887         /// <returns></returns>\r
 888         internal object Register(object entity)\r
 889         {\r
 890             if (! this.objectTrackingEnabled)\r
 891                 return entity;\r
 892             var registeredEntity = _GetOrRegisterEntity(entity);\r
 893             // the fact of registering again clears the modified state, so we're... clear with that\r
 894             MemberModificationHandler.Register(registeredEntity, Mapping);\r
 895             return registeredEntity;\r
 896         }\r
 897 \r
 898         /// <summary>\r
 899         /// Registers an entity for update\r
 900         /// The entity will be updated only if some of its members have changed after the registration\r
 901         /// </summary>\r
 902         /// <param name="entity"></param>\r
 903         /// <param name="entityOriginalState"></param>\r
 904         internal void RegisterUpdate(object entity, object entityOriginalState)\r
 905         {\r
 906             if (!this.objectTrackingEnabled)\r
 907                 return;\r
 908             DoRegisterUpdate(entity);\r
 909             MemberModificationHandler.Register(entity, entityOriginalState, Mapping);\r
 910         }\r
 911 \r
 912         /// <summary>\r
 913         /// Clears the current state, and marks the object as clean\r
 914         /// </summary>\r
 915         /// <param name="entity"></param>\r
 916         internal void RegisterUpdateAgain(object entity)\r
 917         {\r
 918             if (!this.objectTrackingEnabled)\r
 919                 return;\r
 920             MemberModificationHandler.ClearModified(entity, Mapping);\r
 921         }\r
 922 \r
 923         /// <summary>\r
 924         /// Registers an entity for delete\r
 925         /// </summary>\r
 926         /// <param name="entity"></param>\r
 927         internal void RegisterDelete(object entity)\r
 928         {\r
 929             if (!this.objectTrackingEnabled)\r
 930                 return;\r
 931             CurrentTransactionEntities.RegisterToDelete(entity);\r
 932         }\r
 933 \r
 934         /// <summary>\r
 935         /// Unregisters entity after deletion\r
 936         /// </summary>\r
 937         /// <param name="entity"></param>\r
 938         internal void UnregisterDelete(object entity)\r
 939         {\r
 940             if (!this.objectTrackingEnabled)\r
 941                 return;\r
 942             CurrentTransactionEntities.RegisterDeleted(entity);\r
 943         }\r
 944 \r
 945         #endregion\r
 946 \r
 947         /// <summary>\r
 948         /// Changed object determine \r
 949         /// </summary>\r
 950         /// <returns>Lists of inserted, updated, deleted objects</returns>\r
 951         public ChangeSet GetChangeSet()\r
 952         {\r
 953             var inserts = new List<object>();\r
 954             var updates = new List<object>();\r
 955             var deletes = new List<object>();\r
 956             foreach (var entityTrack in CurrentTransactionEntities.EnumerateAll()\r
 957                     .Concat(AllTrackedEntities.EnumerateAll()))\r
 958             {\r
 959                 switch (entityTrack.EntityState)\r
 960                 {\r
 961                     case EntityState.ToInsert:\r
 962                         inserts.Add(entityTrack.Entity);\r
 963                         break;\r
 964                     case EntityState.ToWatch:\r
 965                         if (MemberModificationHandler.IsModified(entityTrack.Entity, Mapping))\r
 966                             updates.Add(entityTrack.Entity);\r
 967                         break;\r
 968                     case EntityState.ToDelete:\r
 969                         deletes.Add(entityTrack.Entity);\r
 970                         break;\r
 971                     default:\r
 972                         throw new ArgumentOutOfRangeException();\r
 973                 }\r
 974             }\r
 975             return new ChangeSet(inserts, updates, deletes);\r
 976         }\r
 977 \r
 978         /// <summary>\r
 979         /// use ExecuteCommand to call raw SQL\r
 980         /// </summary>\r
 981         public int ExecuteCommand(string command, params object[] parameters)\r
 982         {\r
 983             var directQuery = QueryBuilder.GetDirectQuery(command, new QueryContext(this));\r
 984             return QueryRunner.Execute(directQuery, parameters);\r
 985         }\r
 986 \r
 987         /// <summary>\r
 988         /// Execute raw SQL query and return object\r
 989         /// </summary>\r
 990         public IEnumerable<TResult> ExecuteQuery<TResult>(string query, params object[] parameters) where TResult : new()\r
 991         {\r
 992             if (query == null)\r
 993                 throw new ArgumentNullException("query");\r
 994 \r
 995             return CreateExecuteQueryEnumerable<TResult>(query, parameters);\r
 996         }\r
 997 \r
 998         private IEnumerable<TResult> CreateExecuteQueryEnumerable<TResult>(string query, object[] parameters)\r
 999             where TResult : new()\r
1000         {\r
1001             foreach (TResult result in ExecuteQuery(typeof(TResult), query, parameters))\r
1002                 yield return result;\r
1003         }\r
1004 \r
1005         public IEnumerable ExecuteQuery(Type elementType, string query, params object[] parameters)\r
1006         {\r
1007             if (elementType == null)\r
1008                 throw new ArgumentNullException("elementType");\r
1009             if (query == null)\r
1010                 throw new ArgumentNullException("query");\r
1011 \r
1012             var queryContext = new QueryContext(this);\r
1013             var directQuery = QueryBuilder.GetDirectQuery(query, queryContext);\r
1014             return QueryRunner.ExecuteSelect(elementType, directQuery, parameters);\r
1015         }\r
1016 \r
1017         /// <summary>\r
1018         /// Gets or sets the load options\r
1019         /// </summary>\r
1020         [DbLinqToDo]\r
1021                 public DataLoadOptions LoadOptions\r
1022                 {\r
1023                         get { throw new NotImplementedException(); }\r
1024                         set { throw new NotImplementedException(); }\r
1025                 }\r
1026 \r
1027         public DbTransaction Transaction {\r
1028             get { return (DbTransaction) DatabaseContext.CurrentTransaction; }\r
1029             set { DatabaseContext.CurrentTransaction = value; }\r
1030         }\r
1031 \r
1032         /// <summary>\r
1033         /// Runs the given reader and returns columns.\r
1034         /// </summary>\r
1035         /// <typeparam name="TResult">The type of the result.</typeparam>\r
1036         /// <param name="reader">The reader.</param>\r
1037         /// <returns></returns>\r
1038         public IEnumerable<TResult> Translate<TResult>(DbDataReader reader)\r
1039         {\r
1040             if (reader == null)\r
1041                 throw new ArgumentNullException("reader");\r
1042             return CreateTranslateIterator<TResult>(reader);\r
1043         }\r
1044 \r
1045         IEnumerable<TResult> CreateTranslateIterator<TResult>(DbDataReader reader)\r
1046         {\r
1047             foreach (TResult result in Translate(typeof(TResult), reader))\r
1048                 yield return result;\r
1049         }\r
1050 \r
1051         public IMultipleResults Translate(DbDataReader reader)\r
1052         {\r
1053             throw new NotImplementedException();\r
1054         }\r
1055 \r
1056         public IEnumerable Translate(Type elementType, DbDataReader reader)\r
1057         {\r
1058             if (elementType == null)\r
1059                 throw new ArgumentNullException("elementType");\r
1060             if (reader == null)\r
1061                 throw new ArgumentNullException("reader");\r
1062 \r
1063             return QueryRunner.EnumerateResult(elementType, reader, this);\r
1064         }\r
1065 \r
1066         public void Dispose()\r
1067         {\r
1068             //connection closing should not be done here.\r
1069             //read: http://msdn2.microsoft.com/en-us/library/bb292288.aspx\r
1070 \r
1071                         //We own the instance of MemberModificationHandler - we must unregister listeners of entities we attached to\r
1072                         MemberModificationHandler.UnregisterAll();\r
1073         }\r
1074 \r
1075         [DbLinqToDo]\r
1076         protected virtual void Dispose(bool disposing)\r
1077         {\r
1078             throw new NotImplementedException();\r
1079         }\r
1080 \r
1081         /// <summary>\r
1082         /// Creates a IDbDataAdapter. Used internally by Vendors\r
1083         /// </summary>\r
1084         /// <returns></returns>\r
1085         internal IDbDataAdapter CreateDataAdapter()\r
1086         {\r
1087             return DatabaseContext.CreateDataAdapter();\r
1088         }\r
1089 \r
1090         /// <summary>\r
1091         /// Sets a TextWriter where generated SQL commands are written\r
1092         /// </summary>\r
1093         public TextWriter Log { get; set; }\r
1094 \r
1095         /// <summary>\r
1096         /// Writes text on Log (if not null)\r
1097         /// Internal helper\r
1098         /// </summary>\r
1099         /// <param name="text"></param>\r
1100         internal void WriteLog(string text)\r
1101         {\r
1102             if (Log != null)\r
1103                 Log.WriteLine(text);\r
1104         }\r
1105 \r
1106         /// <summary>\r
1107         /// Write an IDbCommand to Log (if non null)\r
1108         /// </summary>\r
1109         /// <param name="command"></param>\r
1110         internal void WriteLog(IDbCommand command)\r
1111         {\r
1112             if (Log != null)\r
1113             {\r
1114                 Log.WriteLine(command.CommandText);\r
1115                 foreach (IDbDataParameter parameter in command.Parameters)\r
1116                     WriteLog(parameter);\r
1117                 Log.Write("--");\r
1118                 Log.Write(" Context: {0}", Vendor.VendorName);\r
1119                 Log.Write(" Model: {0}", Mapping.GetType().Name);\r
1120                 Log.Write(" Build: {0}", Assembly.GetExecutingAssembly().GetName().Version);\r
1121                 Log.WriteLine();\r
1122             }\r
1123         }\r
1124 \r
1125         /// <summary>\r
1126         /// Writes and IDbDataParameter to Log (if non null)\r
1127         /// </summary>\r
1128         /// <param name="parameter"></param>\r
1129         internal void WriteLog(IDbDataParameter parameter)\r
1130         {\r
1131             if (Log != null)\r
1132             {\r
1133                 // -- @p0: Input Int (Size = 0; Prec = 0; Scale = 0) [2]\r
1134                 // -- <name>: <direction> <type> (...) [<value>]\r
1135                 Log.WriteLine("-- {0}: {1} {2} (Size = {3}; Prec = {4}; Scale = {5}) [{6}]",\r
1136                     parameter.ParameterName, parameter.Direction, parameter.DbType,\r
1137                     parameter.Size, parameter.Precision, parameter.Scale, parameter.Value);\r
1138             }\r
1139         }\r
1140 \r
1141         public bool ObjectTrackingEnabled\r
1142         {\r
1143             get { return this.objectTrackingEnabled; }\r
1144             set \r
1145             {\r
1146                 if (this.currentTransactionEntities != null && value != this.objectTrackingEnabled)\r
1147                     throw new InvalidOperationException("Data context options cannot be modified after results have been returned from a query.");\r
1148                 this.objectTrackingEnabled = value;\r
1149             }\r
1150         }\r
1151 \r
1152         [DbLinqToDo]\r
1153         public int CommandTimeout\r
1154         {\r
1155             get { throw new NotImplementedException(); }\r
1156             set { throw new NotImplementedException(); }\r
1157         }\r
1158 \r
1159         public bool DeferredLoadingEnabled\r
1160         {\r
1161             get { return this.deferredLoadingEnabled; }\r
1162             set\r
1163             {\r
1164                 if (this.currentTransactionEntities != null && value != this.deferredLoadingEnabled)\r
1165                     throw new InvalidOperationException("Data context options cannot be modified after results have been returned from a query.");\r
1166                 this.deferredLoadingEnabled = value;\r
1167             }\r
1168         }\r
1169 \r
1170         [DbLinqToDo]\r
1171         public ChangeConflictCollection ChangeConflicts\r
1172         {\r
1173             get { throw new NotImplementedException(); }\r
1174         }\r
1175 \r
1176         [DbLinqToDo]\r
1177         public DbCommand GetCommand(IQueryable query)\r
1178         {\r
1179             DbCommand dbCommand = GetIDbCommand(query) as DbCommand;\r
1180             if (dbCommand == null)\r
1181                 throw new InvalidOperationException();\r
1182 \r
1183             return dbCommand;\r
1184         }\r
1185 \r
1186         [DBLinqExtended]\r
1187         public IDbCommand GetIDbCommand(IQueryable query)\r
1188         {\r
1189             if (query == null)\r
1190                 throw new ArgumentNullException("query");\r
1191 \r
1192             var qp = query.Provider as QueryProvider;\r
1193             if (qp == null)\r
1194                 throw new InvalidOperationException();\r
1195 \r
1196             if (qp.ExpressionChain.Expressions.Count == 0)\r
1197                 qp.ExpressionChain.Expressions.Add(CreateDefaultQuery(query));\r
1198 \r
1199             return qp.GetQuery(null).GetCommand().Command;\r
1200         }\r
1201 \r
1202         private Expression CreateDefaultQuery(IQueryable query)\r
1203         {\r
1204             // Manually create the expression tree for: IQueryable<TableType>.Select(e => e)\r
1205             var identityParameter = Expression.Parameter(query.ElementType, "e");\r
1206             var identityBody = Expression.Lambda(\r
1207                 typeof(Func<,>).MakeGenericType(query.ElementType, query.ElementType),\r
1208                 identityParameter,\r
1209                 new[] { identityParameter }\r
1210             );\r
1211 \r
1212             return Expression.Call(\r
1213                 typeof(Queryable),\r
1214                 "Select",\r
1215                 new[] { query.ElementType, query.ElementType },\r
1216                 query.Expression,\r
1217                 Expression.Quote(identityBody)\r
1218             );\r
1219         }\r
1220 \r
1221         [DbLinqToDo]\r
1222         public void Refresh(RefreshMode mode, IEnumerable entities)\r
1223         {\r
1224             throw new NotImplementedException();\r
1225         }\r
1226 \r
1227         [DbLinqToDo]\r
1228         public void Refresh(RefreshMode mode, params object[] entities)\r
1229         {\r
1230             throw new NotImplementedException();\r
1231         }\r
1232 \r
1233         [DbLinqToDo]\r
1234         public void Refresh(RefreshMode mode, object entity)\r
1235         {\r
1236             throw new NotImplementedException();\r
1237         }\r
1238 \r
1239         [DbLinqToDo]\r
1240         public void DeleteDatabase()\r
1241         {\r
1242             throw new NotImplementedException();\r
1243         }\r
1244 \r
1245         [DbLinqToDo]\r
1246         public void CreateDatabase()\r
1247         {\r
1248             throw new NotImplementedException();\r
1249         }\r
1250 \r
1251         [DbLinqToDo]\r
1252         protected internal IQueryable<TResult> CreateMethodCallQuery<TResult>(object instance, MethodInfo methodInfo, params object[] parameters)\r
1253         {\r
1254             throw new NotImplementedException();\r
1255         }\r
1256 \r
1257         [DbLinqToDo]\r
1258         protected internal void ExecuteDynamicDelete(object entity)\r
1259         {\r
1260             throw new NotImplementedException();\r
1261         }\r
1262 \r
1263         [DbLinqToDo]\r
1264         protected internal void ExecuteDynamicInsert(object entity)\r
1265         {\r
1266             throw new NotImplementedException();\r
1267         }\r
1268 \r
1269         [DbLinqToDo]\r
1270         protected internal void ExecuteDynamicUpdate(object entity)\r
1271         {\r
1272             throw new NotImplementedException();\r
1273         }\r
1274     }\r
1275 }\r