Q1 2010 (version 2010.1.310)

3/9/2010 11:00:00 PM

Enhancements

• New Visual designer for Telerik OpenAccess ORM
• New database support: VistaDB 4.0
• LINQ: Support for SelectMany - Support for the following:
  
  from p in PersonExtent
  from a in AddressExtent
  select new { p, a }
  
  This causes SelectMany to be called that produces a cartesian product. This is not a join!
• Configuration support for SNAPSHOT isolation - You can now specify <isolationLevel>SNAPSHOT</isolationLevel> in the backend configuration for systems where this is supported (e.g. MSSQL).
• LINQ: Improve transition to in-memory queries so that Concat().Concat().Concat() is possible. - (from cc in Scope.Extent<City>() orderby cc.Name select cc.Name)
  .Concat(from pp in Scope.Extent<Person>() orderby pp.Name select pp.Name)
  .Concat(from gg in Scope.Extent<Group>() orderby gg.Name select gg.Name);
  
  is currently not possible as the transition to in-memory query changes the query provider to in-memory too which falsely tries to execute the gg clause on the pp query instance.
• Concurrency Control: Ability to use backend specific methods - Need to use 'timestamp' (MSSQL) or 'ORA_ROWSCN' (Oracle) mechanisms for concurrency control because other applications (not done with OpenAccess) must be able to cooperate.
• LINQ: OrderBy clause with calculation - LINQ: OrderBy clause with calculation that returns integer in the lambda expression fails.
• ObjectContainer: Added API so that the applied objects of a change set are enumerable - An API that allows the enumeration of all objects that got affected by applying a change set to an ObjectContainer was needed. The ObjectContainer.Apply functions returns an array of IObjectId instances that describes the added objects.
• The Check settings wizard cannot work under source control - The "Update assembly references" validator of the Check settings wizard should automatically check-out files under source control that need to be updated.
• Implement Database creation with standard .NET connection strings - The database creation either as a post-build step during designtime or via the Schema handling API should work if standard .NET connection strings are used.
• Enhancing Web Applications - As Web Application projects are compiled to assemblies, OpenAccess should be able to create and work with persistent objects within such projects. The enable project wizard now allows the complete handling including connection strings, enhancing and database updates.
• LINQ: Support for type tests of pure this (extent iterator) in projections - var result = db.Products.Select(x => x is DiscontinuedProduct ? x : null); is working now.
• Backend concurrency control setting cannot be used in forward mapping dialogs - The forward mapping concurrency control combo box does not contain 'backend' as CC mechanism. This results in broken mapping definitions if the backend setting is already part of the app.config file
• Provide VB.Net version of ObjectNetworkAttacher - Currently only C# version of the ObjectNetworkAttacher is provided, which is not suitable for our Vb.Net customers. Vb.Net version should be added to the product as well. The VB version is avaliable in the src directory now.
• LINQ: Distinct operator now works as defined, erasing a previous ordering - The LINQ operator Distinct() now works as defined so that previous sortings are erased. It must be given at the end of a LINQ query.
• LINQ: Improved support for Queryable.Single - Calls to Queryable.Single() now throw correctly an exception, when more than one element is found.
• LINQ: Improved support for TypeAs cast in projections - When using lambda expression like .Select(c => c as MyInterface), the behavior is more consistent with Linq2Objects.
• Alter the ObjectScopeProvider class so it contains code for obtaining an IObjectScope and stores it in the HttpContext.Items collection - This is a best practices approach that most of the clients use in web scenarios. It is a feature request by a customer for us to generate the code that innitializes an IobjectScope and stores it in the HttpContext.Items collection.
• LINQ: Handling of ToString() in projection now done on client side - In an expression like 'from p in Scope.Extent<Person>() where p.Name = 'Thomas' select p.Age.ToString()' the production of the string value is now done on the client side, allowing for culture specific output.
• LINQ: Implement support for ternary operator (iif) in OrderBy - For example this query was not correctly translated to SQL:
  IQueryable<Customer> customerList = scope.Extent<Customer>().OrderBy(o => o.Region == null ? o.Fax : o.Region);
• Database should expose the backend configuration and connection information - The backend configuration and connection information are available in the app.config files but cannot be accessed via API on an opened database. The database object should be able to expose such information.
• LINQ: Allow anonymous types as structured parameters - It is now possible to use constructs like
  var z = new { Name = "Thomas", LastName = "Krueger" };
  as parameters to LINQ expressions.
• Invalid slot access error for classes with transient fields - If a transient field has a mapping node in the app.config file an "Invalid slot access" excpetion will thrown. Workaround: remove the mapping.
• LINQ: Support for == new Guid("stringconstant") in where clauses - Currently, a NotSupportException is thrown
• OpenAccessDataContext: Limiting the depth of the retrieval for the ResolveResource() call - When a OpenAccess DataContext is used with the method ResolveResource(), the caused retrieve operation performs 3 level deep. This has now been corrected to only include one level for this usage.
• Runtime: Allow new instances to be retrieved with depth > 1 when referencing fields have OID values - When a new instance is to be retrieved, the operation is terminated immediately for level 1. However, when an OID has been set through means of a shared column, a deeper retrieve failed as the OID is not a PersistenceCapable. The fix enables now these deep retrieve operations to succeed.
• Oracle: Support for non-waiting locks implemented - In order to issue a non-waiting lock under Oracle, the SELECT ... FOR UPDATE clause needs a NOWAIT appended. That can be achieved now by specifying <lockSqlSuffix>FOR UPDATE NOWAIT</lockSqlSuffix> in the backend configuration. This setting will override the normally used FOR UPDATE which might cause unwanted blocking.
• High-low key generator should avoid checks during database open operations - The high low key generator checks for the existence of the tables that have the key generator uses during database open. If there are missing tables even if they are not used the application will not work. To avoid this a new setting has been invented to configure the behavior:
  <ext.db-key-generator.ignoreMissingTables>true</ext.db-key-generator.ignoreMissingTables> 
• LINQ: Avoid 'Directly parameterized boolean eq/neq expression found' exceptions - When boolean expressions are used with parameters, an exception with the message like 'Directly parameterized boolean eq/neq expression found' could be thrown. The internal LINQ query tree is now structured in a way that this exception is avoided.
• Support for Visual Studio 2010 profiles - Visual Studio 2010 profiles requieres to reduce the amount of assemblies OpenAccess assembly links to. It is not allowed to reference any UI functionality. This makes it necessary to factor out the OpenAccessDataSource, ObjectView and ObjectProvider. To keep the existing applications running you have to add the references to the Telerik.OpenAccess.Windows.dll or Telerik.OpenAccess.Web.dll.
• Define new Context API - A new API implementing .NET framework workflows like IUpdatable and SaveChanges should help to migrate existing applications to OpenAccess.
• Change pk after scope.Add for new instances - If the pk value is not set before scope.Add has been called it shoulg be possible to change it. Only if the Object Id is used the first time, using transaction.Flush or scope.GetObjectId it is not possible to change the pk anymore.
• LINQ: OrderBy clause with constant lambda expression for column name fails - improve exception message - LINQ: OrderBy clause with lambda expression which returns the column name fails:
  var query = scope.Extent<ClassName>().OrderBy(q => "fieldName");
• LINQ: Support for char.ToUpper/char.ToLower - Included server side implementation for char.ToUpper(char) and char.ToLower(char).
• LINQ: Allowing GroupBy on non-column condition - LINQ statements including a GroupBy() on a non-column are permitted now (they had been rejected before).
• LINQ: Support for Queryable.Contains - Incorporated support for server side execution of Queryable.Contains(source, item).
• LINQ: Support for Queryable.All(source,predicate) - Incorporated support for Queryable.All(source,predicate) calls.
• LINQ: Support for Queryable.Count(condition) - Incorporated support for Queryable.Count(condition)
• LINQ: Support for SubSelect - Added support for non-nesting subqueries in LINQ.
  
  Example queries:
  var result = from c in db.Customers
  select new
  {
  Customer = c,
  HasNewOrders = db.Orders
  .Where(o => o.OrderDate > new DateTime(2001, 1, 1))
  .Select(o => o.Customer)
  .Contains(c)
  };
  
  var products = db.Products;
  var suppliers = db.Suppliers;
  var result = from p in products
  select new
  {
  Product = p,
  Suppliers = suppliers
  .Where(s => s.Id == p.Supplier.Id)
  .Select(s => s.CompanyName)
  };
  
  var result = from o in db.Orders select db.Customers.Where(c => c.Id == o.Customer.Id);
• ObjectContainer: Added API so that the applied objects of a change set are enumerable - An API that allows the enumeration of all objects that got affected by applying a change set to an ObjectContainer was needed. The ObjectContainer.Apply functions returns an array of IObjectId instances that describes the added objects.
• The Check settings wizard cannot work under source control - The "Update assembly references" validator of the Check settings wizard should automatically check-out files under source control that need to be updated.
• Implement Database creation with standard .NET connection strings - The database creation either as a post-build step during designtime or via the Schema handling API should work if standard .NET connection strings are used.
• Enhancing Web Applications - As Web Application projects are compiled to assemblies, OpenAccess should be able to create and work with persistent objects within such projects. The enable project wizard now allows the complete handling including connection strings, enhancing and database updates.
• LINQ: Support for type tests of pure this (extent iterator) in projections - var result = db.Products.Select(x => x is DiscontinuedProduct ? x : null); is working now.
• Provide VB.Net version of ObjectNetworkAttacher - Currently only C# version of the ObjectNetworkAttacher is provided, which is not suitable for our Vb.Net customers. Vb.Net version should be added to the product as well. The VB version is avaliable in the src directory now.
• LINQ: Distinct operator now works as defined, erasing a previous ordering - The LINQ operator Distinct() now works as defined so that previous sortings are erased. It must be given at the end of a LINQ query.
• LINQ: Improved support for Queryable.Single - Calls to Queryable.Single() now throw correctly an exception, when more than one element is found.
• LINQ: Improved support for TypeAs cast in projections - When using lambda expression like .Select(c => c as MyInterface) , the behavior is more consistent with Linq2Objects.
• Alter the ObjectScopeProvider class so it contains code for obtaining an IObjectScope and stores it in the HttpContext.Items collection - This is a best practices approach that most of the clients use in web scenarios. It is a feature request by a customer for us to generate the code that innitializes an IobjectScope and stores it in the HttpContext.Items collection.
• LINQ: Improved support for DateTime constructor expressions - It is possible now to use expressions like
  from p in Scope.Extent<Person>() where p.Birthday = new DateTime(1967,3,29) select p
  The DateTime(int,int,int) and DateTime(int,int,int,int,int,int) methods are supported and will be converted to the corresponding SQL.
• LINQ: Handling of ToString() in projection now done on client side - In an expression like 'from p in Scope.Extent<Person>() where p.Name = 'Thomas' select p.Age.ToString()' the production of the string value is now done on the client side, allowing for culture specific output.
• Enable project wizard does not generate app.config - If the app.config physically exists in the folder where the enabled project resides and the file in not included in the project - enable project wizard just bypasses the addition of app.config to the project. It should expose a message that asks if we want the file replaced and add a new one to the project that is being enabled.
• Display information about assembly visible public persistent fields - If a persistent fiels is public and visible outside the assembly it is possible to bypass our change tracking. To avoid this the referencing assemblies have to be enhanced as well. The enhancer shows warnings about all visible persistent fields now.
• No OptimisticVerification exception is thrown for delete operations performed using stored procedures - A persistent type instance can be deleted using the 'IObjectScope.Remove' method call or by mapping a stored procedure that deletes a row of that type. If a stored procedure is used to delete a row that is already deleted no OptimisticVerification exception is thrown. There is now way to confirm that the operation was successful.
• Transaction.Rollback with shared columns problem - A new object with shared columns where only the simples part is set throws a class cast exception during transaction rollback. It only happens in Rollback.Workaround: Set the reference value as well.

Fixes

• Expert Enable project wizard connection string support:
  1) If you run the expert enable wizard after we the connection string is used the changes made with the expert wizard won’t be persisted.
  2) If you run the Expert enable wizard its properties are always initialized with the default one: Database1, localhost etc, regardless of the settings in the app.config file.
  3) If you click try to generate the objectcontainerproviderproxy class you get non compliable code generated. // research
• LINQ: Expression statements inside the OrderBy clause cannot be executed - Expression statements cannot be used inside the OrderBy clause
• LINQ: Second OrderBy / OrderByDescending not clearing first orderby, but appending ordering - A second orderby or orderbydescending should override the first orderby/orderbydescending. Instead it just appends the second ordering much like an thenby / thenbydescending. This is a difference to Linq2Objects.
• FIX: Forward mapping wizard does not handle nested structs as expected - In cases where there is a reference to a nested struct (struct defined within another struct) the Forward mapping wizard treats the struct type as non-persistent and hence the reference is also invalid.
  Nested structs and references to it are valid and the Forward mapping should display appropriate mapping for such fields.
• OQL Query Browser not loading referencing assemblies - When you have an enchanced project as a reference to your current project the OQL Query Browser would append the referencing project to the output dir this creating invalid path.
• Paths to resource files are not resolved correctly by the Check settings wizard - If the Persistence property of a resource file is set to "Linked at compile time", the Check settings wizard cannot resolve the path to the resource.
• LINQ: Corrected handling of conditions when there was a projection before - When a projection is made before a condition, the current implementation does not track back the projected fields/properties to their original source (fields of a persistence capable type). Therefore conditions (Where clauses) cannot be pushed to the database server.
• Enable project wizard failing with turkish regional settings - Because of the special turkish 'i' some settings were not written in the correct format.
• LINQ: Conditional expressions of boolean result type not handled properly - When a (c ? t : f) conditional expression is given and the result type is boolean (t and f are booleans), the generated SQL was not correct.
• OQL: Keywords containing i (define,in,having,exists,like,min,nil, time) not working properly when used UPPER cased under turkish culture. - When using DEFINE,IN,HAVING,EXISTS,LIKE,MIN,NIL under turkish culture, an OQL parser exception is thrown. In order to avoid the exception, the lower-case versions should be used.
• The Reverse mapping wizard generates wrong column mapping for XML columns - A length of -2 is written in the mapping for XML columns. This could lead to invalid SQL generation if the update schema script is generated.
• The Reverse mapping wizard generates ambiguous mapping while merging a new FK constraint, involving multiple columns - If a FK constraint with multiple columns is added to the database and a ‘Merge’ is performed, a reference field gets added as expected but the column mapping for this field is opposite. Example: FK from Person (adrId1,adrId2)->address (adrId1,adrId2), the column mapping for the field is – address.adrId-> Person.adrId2 and address.adrId2-> Person.adrId
• Oracle NClobs/Clobs not working - Between Q2 and Q3 the oracle nclob and clob support was broken. It has been fixed now.
• Cannot call GetObjectId in the Tracking callbacks - If the tracking events are fired during ObjectContainer.CommitChanges or container.CopyTo inside the event GetObjectId throws an exception with the text "Intentionally not implemented". The GetObjectId function is implemented now.
• Database.Metadata throws exception - If the persistent model contains a horizontal mapped base class with a collection field the Database.Metadata property throw a null reference exception.
• Oracle: Inability to see other schemata than default schema - When Oracle schemata are used, the reverse engineering wizard does not display them.
• Static method to invoke Oracle stored procedures with parameters cannot be generated - The Reverse mapping wizard can be used to generate a static method for a stored procedure in the database. This static method can be used to invoke the stored procedure. A System.ArgumentException is thrown if an attempt to generate a method for an Oracle stored procedure with parameters is made.  This has been fixed now.
• 2nd Level Cache: NPE when evicting from an unopened database - When the database is not opened (any longer), trying to evict from the database level cache fails with a NullReferenceException.
• The Backend Configuration dialog does not store the correct default value for the Logging property - LogLevel - The default LogLevel value is 'none'. The Backend Configuration dialog treats the default as 'normal'. If the user selects 'Normal' nothing gets written to the app.config assuming this is the default.The runtime would treat this as 'none'
• OQL: Horizontally mapped artificial field cannot be found from OQL query - When a horizontally mapped artificial field is used in an OQL query, the field is not found and the query throws an exception.
• Enhancer: generic constraints of type generic parameter not working - The code public interface T<T,U> where U : T { } was not enhanceable.
• In case of vertical inheritance heirarchy that uses stored procedures for CUD operations, the UPDATE operation fails - Consider a vertically mapped inheritance model that uses stored procedures to perform CUD operations. If we try to update an instance from this hierarchy (base class instance or derived class instance), the operation fails while trying to execute the update stored procedure with an error message 'parameter @id is missing'. The update procedure is called without specifying the primary key parameter
• structs with references not working in the ObjectContainer - If a persistent struct has a reference to a persistent class and is used inside the ObjectContainer a class cast exception might be thrown.
• Metadata can not be retireved if the model has a peristent string[] - If a persistent class has a string[] as persistent field the Database.GetMetadata() call fails with a class cast exception.
• Shared Column synchronization not working for slave long, short, char and byte fields - If a column is used both for a simple field and a reference field, the synchronization between the fields is broken in cases of long, short, char and byte fields. (Int, String, Guid fields are not affected.) This means that the value that is set via the simple field is not committed.
• LINQ:Invocation expressions are not correctly processed. - Using the PredicateBuilder class from LinkKit generates invocation expessions which we do not process and throw exceptions. In cases there the InvocationExpression is a wrapper for a regular lambda expressions we should be able to process the query correctly.
• Shared columns are not updated when 'null' is asigned to the foreign key field. - If the foreign key field is of type int?, and we try to assign a 'null' value to it while performing an update operation - the operation is not succesful. There is not an exception, but the record in the database is not updated.
• Configuration: Nullability setting always created when a configuration node for a field exists - When a Xml node for a field is given with no null-value attribute, the column is always created as nullable, disregarding the default type mapping.
• LINQ: Parameter reordering required when using IFF / Coalesce statements - An expression like '
  from p in Scope.Extent<Person>() where p.Name == (name ?? p.Name) select p;'
  caused an exception with the text '
  Please reformulate the query so that the parameter appears on the right side'.
• query.IgnoreUncommitted = false leads to duplicated join table entries - If several queries with IgnoreUncommitted = false are executed in the same running transaction sometimes a primary key violation in a collection join table is thrown.
• Enhancer writes damaged assemblies on 64 bit machines - Sometimes wrong ctor calls are written to the enhanced assembly if the enhancer runs as 64 bit process.
• LINQ: Wrong translation of modulo operator on Oracle - The module operator was translated into not executable sql on oracle.
• Empty blog throw null reference exception - If an empty blob instead of a null reference is stored the commit throws a null reference exception.
• Adding ObjectView and ObjectProvider from the Toolbox leads to not compilable project - If a windows Forms project does not reference the OpenAccess dll you can drag and drop a ObjectView from the Toolbox to the dialog. This works fine but the project is not compilable. Now the necessary references are added.
• OUT parameter values for Firebird stored procedures are not retrieved via the IObjectScope.GetSqlQuery API method - The values of OUT parameters in a Firebird stored procedure are not retrieved via the IObjectScope.GetSqlQuery call. The OUT parameters values should be retrievable via the IQueryResult.OutParameter property, but the values are not populated.
• Sql query out parameter not available before the result set is iterated - Because the query is executed lazy the out paramter collection is not available before the result set is iterated. A workaround is to call count before you access the out parameter.
• LINQ: Casting nullable to base type inside a collection argument .Contains() failed - An expression of type ' from x in Scope.Extent<A>() where collparam.Contains((int)x.nullableValue) select x' failed with an exception.
  Workaround: Rewrite query to 'from x in Scope.Extent<A>() where collparam.Contains(x.nullableValue.Value) select x' .
• Retrieve does not work for types with artificial fields - If a persistent type has an artificial field the Scope.Retrieve call might throw an 'invalid slot access' exception.
• LINQ: Second OrderBy / OrderByDescending not clearing first orderby, but appending ordering - A second orderby or orderbydescending should override the first orderby/orderbydescending. Instead it just appends the second ordering much like an thenby / thenbydescending. This is a difference to Linq2Objects.
• FIX: Forward mapping wizard does not handle nested structs as expected - In cases where there is a reference to a nested struct (struct defined within another struct) the Forward mapping wizard treats the struct type as non-persistent and hence the reference is also invalid.
  Nested structs and references to it are valid and the Forward mapping should display appropriate mapping for such fields.
• OQL Query Browser not loading referencing assemblies - When you have an enchanced project as a reference to your current project the OQL Query Browser would append the referencing project to the output dir this creating invalid path.
• Paths to resource files are not resolved correctly by the Check settings wizard - If the Persistence property of a resource file is set to "Linked at compile time", the Check settings wizard cannot resolve the path to the resource.
• LINQ: Corrected handling of conditions when there was a projection before - When a projection is made before a condition, the current implementation does not track back the projected fields/properties to their original source (fields of a persistence capable type). Therefore conditions (Where clauses) cannot be pushed to the database server.
• Enable project wizard failing with turkish regional settings - Because of the special turkish 'i' some settings were not written in the correct format.
• LINQ: Conditional expressions of boolean result type not handled properly - When a (c ? t : f) conditional expression is given and the result type is boolean (t and f are booleans), the generated SQL was not correct.
• OQL: Keywords containing i (define,in,having,exists,like,min,nil, time) not working properly when used UPPER cased under turkish culture. - When using DEFINE,IN,HAVING,EXISTS,LIKE,MIN,NIL under turkish culture, an OQL parser exception is thrown. In order to avoid the exception, the lower-case versions should be used.
• The Reverse mapping wizard generates wrong column mapping for XML columns - A length of -2 is written in the mapping for XML columns. This could lead to invalid SQL generation if the update schema script is generated.
• The Reverse mapping wizard generates ambiguous mapping while merging a new FK constraint, involving multiple columns - If a FK constraint with multiple columns is added to the database and a ‘Merge’ is performed, a reference field gets added as expected but the column mapping for this field is opposite. Example: FK from Person (adrId1,adrId2)->address (adrId1,adrId2), the column mapping for the field is – address.adrId-> Person.adrId2 and address.adrId2-> Person.adrId
• Oracle NClobs/Clobs not working - Between Q2 and Q3 the oracle nclob and clob support was broken. It has been fixed now.
• Cannot call GetObjectId in the Tracking callbacks - If the tracking events are fired during ObjectContainer.CommitChanges or container.CopyTo inside the event GetObjectId throws an exception with the text "Intentionally not implemented". The GetObjectId function is implemented now.
• Database.Metadata throws exception - If the persistent model contains a horizontal mapped base class with a collection field the Database.Metadata property throw an null reference exception.
• Oracle: Inability to see other schemata than default schema - When Oracle schemata are used, the reverse engineering wizard does not display them.
• Static method to invoke Oracle stored procedures with parameters cannot be generated - The Reverse mapping wizard can be used to generate a static method for a stored procedure in the database. This static method can be used to invoke the stored procedure. A System.ArgumentException is thrown if an attempt to generate a method for an Oracle stored procedure with parameters is made. This has been fixed now.
• 2nd Level Cache: NPE when evicting from an unopened database - When the database is not opened (any longer), trying to evict from the database level cache fails with a NullReferenceException.
• The Backend Configuration dialog does not store the correct default value for the Logging property - LogLevel - The default LogLevel value is 'none'. The Backend Configuration dialog treats the default as 'normal'. If the user selects 'Normal' nothing gets written to the app.config assuming this is the default.The runtime would treat this as 'none'
• OQL: Horizontally mapped artificial field cannot be found from OQL query - When a horizontally mapped artificial field is used in an OQL query, the field is not found and the query throws an exception.
• Forward mapping: 'Reload' clears the contents of the 'projects' combobox - Reload clears the Projects combobox and does not fill it with all enabled projects again.The only way to get all projects in the combobox is to close the dialog and open it again
• MSSQL: if the default schema of the user is something other than 'dbo' ,objects in the 'dbo' schema cannot be reverse mapped - If the default schema of the current user is something other than 'dbo' the Reverse mapping wizard does not list the 'dbo' schema in the list of schemas. Hence it is not possible to reverse map objects from the 'dbo' schema.
• Reverse mapping UI does not update properly when switching mapping between a 'Collection' and 'Map' - In advanced view if you select a join table it is mapped to a collection. There is a check box that creates a Many-to-many association. If the user changes the type to which the join table is mapped from ‘Collection’ to ‘Map’ and then switched back to ‘Collection’ – the ‘many-to-many’ checkbox is disabled. There is no way to have the checkbox back unless you reload the schema.
• OpenAccess xml schema file not installed - If Visual Studio 2005 is not installed the OpenAccess installer is not installing the xml schema file OpenAccess.xsd into the right directory for Visual Studio 2008. Workaround: Use Telerik.OpenAccess.AddinInstaller.exe to install the missing file.
• AddinInstaller registers common package with wrong version number - The Telerik.OpenAccess.AddinInstaller.exe tool uses an old version string for the Telerik.Common_Packed.dll. This results in errors during Visual Studio startup because the package cannot be loaded.
• Access to unloaded field problem - If shared columns are used inside an object and this object is dirty but the fields of the shared columns are not loaded an 'Access to unloaded field' Exception is thrown during transaction.commit.
• Enhancer handles transient fields like persistent fields might throw a null reference exception - If a simple nullable transient field like int? or DataTime? is set null with a static defined value the enhancer throws an null reference exception.
• OQL: MSSQL: Error is reported when a timestamp literal is given with T or t as date and time separator - When a literal timestamp '2009-11-27T11:49:33.123' is used in a query against MSSQL, an error is reported by the MSQQL server. The query was working with the Q2 release.
  Workaround: Use a space instead of T to separate time and date.
• Reverse Engineering does not generate 'nulls' information in the mapping - If the reverse engineered mapping is used for forward engineering the 'nulls' setting of the columns might be changed because this setting is not generated inside the app.config file.
• Reverse Enigieering does not generate 'scale' information in the mapping - If the reverse engineered mapping is used for forward engineering the scale of some columns might be changed because this setting is not generated inside the app.config file.
• Enhancer: Generic method call uses wrong parameter - If in a generic method a generic parameter is used to call another generic method the enhancer might throw an index out of bound exception.
  Example code:
  
  public class TestClass

  {

  public void Test0<T1, T2>()

  {

  Test1<T2>(); //problem, Test1<T1>() works

  }

  private void Test1<T>(){}

  }
• LINQ: Enumerable members of non-persistent classes can not be used as part of linq queries - Enumerable members of non-persistent classes can not be used as part of LINQ queries. They should be passed as parameters to the method that executes the LINQ query or they should be declared as variables inside that method.
• Artificial types not working in medium trust - The artificial types are generated in a dynamic emitted assembly. The assembly is stored in a temporary folder by default. Because this is not possible in medium trust it is switched off now.
• LINQ: Guid can not be used in string functions - Calling ToString() to a Guid field inside LINQ query results with a SQL exception.
• Database get throws an FileNotFoundException - If not all referenced assemblies are available Database.Get might throw an FileNotFoundException for an assembly that is referenced but not needed. This exception will be suppressed now.
• SqlCe support fails with express edition - The express edition executes a wrong statement to obtain the version information, failing the express check. The express edition should support SqlCe.
• Hanging web pages with OpenAccess datasources in a grid view templates - If paging is enabled on all levels of a grid using additional data sources inside of view templates the side may hang. This happens because the datasources are not returning the connections to the connection pool which is empty after 10 inner queries executed. The workaround is to disable paging for the inner datasources.
• VS2010 .NET framework profiles are not supported yet - Visual Studio 2010 comes with profile settings additional to the target framework. Those profiles are not supported at the moment and the enable project wizard should show an error if a profile is selected.
• OQL: Improve exception messages for parsing errors so that the complete query string is incorporated. - The OQL exception that is encountered when a parsing error occurs is not optimal as it does not provide the complete OQL query, only a fragment of it.
• The Enable project wizard crashes when the Web.config file contains comments - If the section inside the Web.config file contains xml comment nodes, the Enable project wizard ends with an error.
• Linq: Server-Side Support for SingleOrDefault(Lambda) - As a user I want to use SingleOrDefault instead / in addition to a Where clause so that the condition is evaluated on server side.
  var ur = os.Extent<userrole>().SingleOrDefault(c => c.UserID == id);
  *Workaround*
  var ur = os.Extent<userrol>().Where(c => c.UserID == id).SingleOrDefault();
• LINQ: Grouping does not work on non-nullable and non-pc key fields - Grouping is not working on string or int fields, but is working on composite group keys and pc as group key and nullable<> fields.
• LINQ: Orderby nodes are not correctly resolved when preceeded by join and where clauses. - The query which has the following construct: from..join..where..orderby..select is not resolved because the orderby node is not resolved properly. The current workaround is to just switch the places of the where and orderby clauses. When orderby is directly preceeded by the join clause it is being handled a little differently.
  ----Example of non-working LINQ statement: ----
  var result = from pr in scope.Extent ()
  join c in scope.Extent<category>() on pr.CategoryID equals c.CategoryID where c.CategoryName.Length < 8
  orderby pr.ProductName
  select new { Product = pr.ProductName, Category = c.CategoryName };
  ---Same statement with the workaround:---
  var result = from pr in scope.Extent () join c in scope.Extent<category>() on pr.CategoryID equals c.CategoryID
  orderby pr.ProductName
  where c.CategoryName.Length < 8
  select new { Product = pr.ProductName, Category = c.CategoryName };
• LINQ: Joins with pre-filtered sources not working - Join expressions on filtered extends were not working. Example: scope.Extent<a>().Where(condition1) join b in scope.Extent<b>().Where(condition2) ....
• LINQ: Ordering on joined expressions not working - An orderby expression on a joined expression was not working.
• OQL: Group By not correctly handled when grouping key is self-reference - The query SELECT x, SUM(y.quantity) FROM OrderExtent x, x.orderDetails y GROUP BY x is not correctly handled.
• MySQL: Lock timeouts not recognized correctly - When a lock is set in MySQL, the locked-out client gets a nearly empty exception from the server, which was not correctly handled as a lock timeout.
• Value logging fails for decimal values, only (NUMERIC) is printed. - When logging includes parameter values (log level all), the values of decimal fields are not shown.
• Truncation of string values in GetSqlQuery() paramters When a SQL query is executed with string parameters, the string values are truncated to 65k. Now, LONGVARCHAR parameters will be handled dynamically in their size.
• Shared columns must be found case-insensitive on backends which are case-insensitive (MSSQL) - When two fields should share the same column, but the given column names are differently capitalized, the column must still be shared. This applies only to backends that are case-insensitive wrt. column names.
• InvalidOperationException when adding an instance to the scope in cases where application identity and artificial fields are used. - When artifical fields and application identity is used together, an InvalidOperationException can occur during scope.Add(pc).
• Shared columns not synchronized for string fields - When a string pk is used and a referencing class uses a string field to access the id as foreign key, the field value synchronization is not working as expected.
• MSSQL: Avoiding language or culture caused DateTime literal conversion problems - The server assumes datetime literals to be in a format associated with the language that he associated with the database connection. To avoid string representation mismatches, an explicit format is given now.
• Shared Columns: Metadata compilation fails when two reference fields share a column - Sharing was not allowed between fields other than reference fields and simple fields. Now, also reference fields can share a column.