What's New in Telerik OpenAccess ORM Q2 2010 (v2010.2.714)

• Schema Update Wizard - This wizard (part of the round-trip support of the designer) allows creation and generation of database update scripts. You can also manage whether the script files are added to the project.
• Round tripping designer - The Visual Designer for OpenAccess is now capable of handling forward mapping. It supports adding new entities and and creating new counterparts for them in the relational layer of the model.
• Fluent Mapping API (Beta) - The new fluent mapping API allows for quick and strongly typed configuration of metadata model mappings that can be used for both forward and reverse mapping scenarios. It is really useful in code-only scenarios when no visual designer is required or available.
• New Fetch Optimization API - New way of setting fetch optimizations on the OpenAccess data context. It incorporates a root class named FetchStrategy that supports fluent mapping style of defining the fetch dependencies. The fetch strategy can be produced during runtime and stored in a different place. It is calculated and used after it is assigned to a OpenAccess data context instance.
• SQLite support - . Because it is a free database both the full and express versions of OpenAccess support it.
• Mapping migration tool (Beta) - A conversion tool that can translate previous project versions to the new visual designer / rlinq infrastructure. The tool can also convert reveresemapping.config files to a new visual designer files.
• Reverse Mapping wizard is now able to read Stored Procedures defined within an Oracle package - It is now possible to read stored procedures within a package and Reverse map them similar to other SPs
• Use delimiters for sqlanywhere backend - The sybase sql anywhere backend is now putting delimiters around column and tables names by default.
• Extended schema API - The schema API now exposes the complete schema creation functionality.
• New OpenAccess menu - The OpenAccess menu in Visual Studio has been changed to better expose the new visual designer. If the old wizards should be used the old menu can be activated from the OpenAccess Options Dialog.
• VSchema is now working with .Net 4.0 assemblies - VSchema.exe now has a config file that allows it to handle .Net 4.0 assemblies even if not running in a .Net 4.0 VM.
• Design-time support for Wcf Ria Services Provider (Beta) - Provides wizard that adds a T4 template to a project. The transformation of the T4 template generates a DomainService class that can be used in the project.
• Changed the Update from database wizard to not show unnecessary change set entries for view columns - Change set entries for the IsPrimaryKey, Shared, TargetClass and TargetField view column properties are no longer shown in the the Update from database wizard.
• Backend Specific concurrency columns were not recognized as version columns by the default mapping in the DSL - The backend specific version columns and the fields mapped to them(Timestamp) are now tagged with the right concurrency control facets by the default mapping functionality.
• 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.
• Renaming a class in the designer does not rename the assciated OID class if such exists. - If a class that has been renamed has an OID inner class, the OID class is now renamed along with its parent class.
• MySql autoinc columns are now recognized automatically - Autoinc columns of MySql tables are now recognized automatically while reverse mapping a database.
• New UI for the BackendConfiguration in the ModelSettings dialog - A comprehensive UI for the Backend Configurations has been added in the Model Settings Dialog.
• Codegeneration: Generate to Project Folder - Now the files can be generated to a selectable project folder.
• Codegeneration: Generate to sub-namespaces - Now the files can be generated to different folders automatically, based on their namespace.
• Full support for Visual Studio 2010 - the visual designer is now working in Visual Studio 2010
• Ria Services Provider (Beta) - supports all basic operations (query, insert, update, delete) in WCF Ria Services for .NET 4.0
• New Enhancer - The enhancer has been replaced by a new implementation based on Mono.Cecil. This fixes all known enhancer bugs and speeds up the enhancing process as well.
• Data Services Wizard integration - The Data Services Wizard is now integrated into the OpenAccess product. You can start it by using the DSL context menu.
• Strings containing * or ? can now be used with Linq or OQL matches - An expression of the kind "X like ***" or "X like ???" was translated in SQL to "X like %%%" or "X like ___", therefore returning wrong results.
  This has been changed so that a single backslash in front of the * and ? wildcard will escape the wildcard substitution.
• L2 cache eviction fix for managed inverse collection and referenced instances - When an instance is removed from the database that is referenced by a managed inverse collection, the referencing instance was not evicted from the L2 cache.
• L2 cache eviction fix for managed inverse collections and new owner - When an OrderLine gets a new Order set, the Order (old/new) instances were not evicted from the L2 cache if the collection is inverse and managed.
• Added MakeDirty to the OpenAccessContext - The context now exposes the MakeDirty functionality to the end user.
• LINQ: Added support for pc.collection.Count(lambda) - Added support for expressions like where pc.collection.Count(x => x.field == param).
• OpenAccessDataSource is now working with OpenAccessContext implementations - The OpenAccessDataSource is now working with the new OpenAccess version.
• DSW - Auto generation of Silverlight application with Telerik Silverlight controls that consumes generated services. - works with Astoria v1, Astoria v2 and Silverlight-enabled WCF Services.
• DSW - Added generic search method for WCF Web Services
• DSW - Improved generated code for services.

What's Fixed

• OpenAccessDataSource throws InvalidCastException - OpenAccessDataSource throws InvalidCastException when trying to set persistent properties of type Nullable<Guid>, it is working for the not nullable Guid type.
• Initialize transient is not called during reference navigation - If an object is loaded by navigating over a reference the InitializeTransients function is not called.
• The DSL does not handle nullable types correctly. - The nullable types are handled only with their names which for a nullable type is: "Nullable`1".
• The CheckSettings wizard crashes if there are two projects with the same name in the solution - The CheckSettings wizard throws an ArgumentException: "An entry with the same key already exists" if the solution contains two or more projects with the same name.
• Changing the model name through the model settings dialog was not reflected in the metadatamodel - Changing the model name is now working and the new model name is stored inside the xml rlinq file.
• Fixed generation of non-CLS compliant field / property names - When a column is named _id, the resulting field _id was generated which immediately generated a warning for a non-CLS compliant identifier.
• LINQ: Projection into known type from a joined expression fails - When projecting joined expressions into a known type (not an anonymous type), the generated SQL is wrong.
• The UpdateFromDatabase wizard does not resolve the |DataDirectory| directive - When the connection string of the domain model contains a |DataDirectory| directive, the database path is not resolved correctly and the database cannot be found.
• Enhancer does not intercept field access in class constructor - If a persistent field is accessed inside a constructor of another class the call is not intercepted and the value might not be loaded from the database.
• Silverlight Paging: OpenAccessDomainService throws an exception when total count is to be included in query - An 'not a method' exception is thrown when the Silverlight application uses paging, which includes the total count information.
• Configuration fails with a cast exception - A cast exception can be thrown when an integer backend configuration value was modified.
• Query: Exception thrown that a scalar variable must be declared when certain methods (like String.IsNullOrEmpty(parameter) ) are used - When certain methods (like string.IsNullOrEmpty(x)) translate to a SQL text like (x IS NULL OR x = ''), the duplicate use of x when it is actually a ? parameter causes an internal error that leads to a missing SQL parameter value.
• LINQ: Testing the type of a reference with 'IS' produces incorrect SQL - The LINQ expression "pc.refField is pctype" produces wrong SQL.
• LINQ: Support for LongCount() added - Support for Queryable.LongCount() was added.
• LINQ: Support for expressions generated by the DataService request processor - Support for LINQ queries as generated by the DataServices request processor was improved (String.Contains(), multiple orderings)
• Enhancer damages generic function call with reference parameter - If a generic function or a function of a generic type with a ref parameter is called and the ref parameter is a persistent field, the resulting assembly is damaged..
• Enhancer cannot handle resources without binary content - If an assembly has an embedded resource that only contains string data, the enhancer throws a null reference exception.
• If an assembly with a strong name is enhanced without passing in the key file the assembly is not readable - If an assembly with a strong name is enhanced and no key file or key container is passed to the enhancer, the resulting assembly is not readable because it still says that it has a strong name but the strong name is not present. Now it removes the strong name completely and can be signed by using the sn.exe tool.
• LINQ: When ordering is two times on the same field, the generated SQL is wrong - When a LINQ expression tree like x.OrderBy(u => u.Id).ThenBy(c => c.Id) is encountered, the generated SQL was wrong.
• LINQ: Enable handling of parameter.ToString() method calls in LINQ expressions - When an expression fragment like 'pc.stringfield == parameter.ToString()' is encountered, an exception was thrown.
• OQL: NullReferenceException when query was already available from compiled query cache - When a query was cached, a null reference exception occured while reusing the query.
• Visual Studio 2010: Assembly signing with .pfx file not working with enhancer - Assembly signing with key containers (generated by using .pfx files) did not sign the enhanced assembly.
• Using VARBINARY as parameter type for GetSqlQuery() throws an exception - When using GetSqlQuery("[AStoredProc] ?",null,"VARBINARY val").Execute(new byte[5]), the execution failed as there was an exception thrown (Type not supported for setObject).
• Persistent objects not serializable - The new enhancer does not add the nonserialize settings to the internal OpenAccess fields. This leads to an exception that the OpenAccess PCStateMan is not serializable.
• The use schema name as a prefix setting does not work - The use schema name as a prefix setting does not work. Regardless of the status of this setting classes are generated without a prefix.
• Dependency to VistaDB assembly prevents deployment of OpenAccess projects - The Telerik.OpenAccess.Adonet2 assembly has a dependency on the VistaDB.4 assembly. When deploying web applications, this dependency is the reason for a FileNotFoundException.
• LINQ: Enumerable.Any() generates wrong SQL when used on a fk inverse collection - When a query like "var q = (from p in Scope.Extent<Northwind.Customer>() where p.Orders.Any() select p)" is made where the collection is an inverse collection (fk collection), the resulting SQL is wrong.
  Workaround: Use "var q = (from p in Scope.Extent<Northwind.Customer>() where p.Orders.Count() > 0 select p)"
• Using ConnectionStrings with ODP not possible - The runtime will always use the MS Oracle ADO driver, not the ODP ADO driver.
• LINQ: Comparing a persistent field against an empty collection throws exception. - When a persistent field is compared against a collection, it was required that the collection is not empty. This restriction has now been lifted.
• Null reference exception during database update - If a class hierarchy is mapped horizontal and a collection mapping is specified at the base class the vschema.exe or the Visual Studio build process stops with a null reference exception. It is not allowed to specify a mapping on the horizontal mapped base class. All mapping nodes have to be moved to the derived classes and the fieldname has to be prefixed by the base class name.
• OpenAccess expects the VistaDB design-time license to be registered during runtime - VistaDB has a separate design-time license to be used during development and a runtime license that needs to be embedded in the application. OpenAccess access the VistaDB API/engine for various design time tools (Visual Studio integration and VSchema.exe) as well as via the OpenAccess API during runtime. During runtime OpenAccess API expects the VistaDB designtime license to be registered.
  The OpenAccess designtime tools should use the VistaDB designtime license and the runtime API should rely on the VistaDB runtime license to be available.
• OQL: NVARCHAR comparisons are not handled correctly. - When filtering is done against a NVARCHAR field, the resulting SQL should place an 'N' before the string that is compared against.
  Example: SELECT...WHERE p.Name = 'Александър'. This should be N'Aлександър'.
• DSL: OpenAccess generates un-compilable code when the tables reside in multiple schemas. - The attributes generation has some glitches that are only visible when generating models that contain multiple schemas. We generate something like:
  Table("Address"SchemaName = "Person", )] and it should be: Table("Address", SchemaName = "Person")]
• Null reference exception in the MetadataConverter while reading Oracle schemas. - The ParameterDefinitionsOld collection of the relational procedure is null.
• ObjectContainer.CopyTo throws null reference exception - If an existing object in the container has a collection of other persistent objects and this collection is set to null instead of referencing an empty collection, a null reference exception is thrown in CopyTo or CommitChanges.
• Attributes metadata source does not filter out the events from the persistent classes. - During metadata collection, event members are read as normal fields of persistent classes. We must filter out every delegate member of the persistent classes.
• OpenAccess throws exceptions when we try to persist an object that contains a decimal property. - The reason for the behavior is that the schema reader returns "money" columns with 0 Length. That is different from the default value but we must avoid serializing it nevertheless.
• DefaultMapping maps a 'nullable' column to a property of 'non-nullable' CLR Type. - The TypeResolver returns the value based on the underlying type, disregarding the nullability of the column.
• One-to-many relations are not always correctly resolved when attributes mapping is used. - The creation of the inverse collections depends on the existence of the master members. They should always be read after we are sure all master members are resolved.
• LINQ: Accessing the Value property of a query parameter leads to an exception - When accessing the Value property of a Nullable<X> instance that is used a as query parameter, an exception is thrown.
  Workaround: Avoid using nullable query arguments.
• Error with OpenAccessDataSource and RadGrid when filtering on decimal field is being performed - In case of filtering in RadGrid binded to OpenAccessDataSource on decimal field a Telerik.OpenAccess.Exceptions.QueryException is being thrown.
• VistaDB assembly requiered in .NET 4.0 asp application - If you are using OpenAccess with .NET 4.0 and the ajax script manager the VistaDB assembly is necessary. This dependency has to be removed.
• L2 Cache Synchronization failure - The L2 cache synchronization using MSMQ fails immediately due to a timeout exception.
• Many-to-many colections are not handling CUD operations on the slave end - In an m:n association, if one adds a new persistent object in the collection of the slave member, the objects is persisted, but no entry in the join table is being written.
• LINQ: InvalidCastException when anonymous types are used coming from multiple dynamically created sources - When LINQ queries are generated by tools that themselves compile the linq expressions, anonymous types are created in a duplicate fashion (same structured type can exist multiple times in the process). This can generate invalid cast exceptions when reading the LINQ result set.
• Inability to pass Unicode strings to SQL queries and stored procedure invocations - When using SQL queries or stored procedures through the IObjectScope.GetSqlQuery() method, there was no way to specify that a passed string (or an out parameter) should be handled correctly for non-latin character sets. The strings were passed as VARCHAR instead of a Unicode capable type like NVARCHAR/VARCHAR2.
  In order to use unicode string parameters, one must specify "NVARCHAR p1" for an input parameter with name p1 and "OUT.NVARCHAR p2" for an output parameter p2 in the type declaration of the GetSqlQuery() method.
• OpenAccessDataSource is not using the Insert or Update parameters when those operations are being executed. - The OpenAccessDataSource exposes the Insert and Update parameters as well as the Where and Order By, but it only uses the later two for SELECT operations. The Insert and Update parameters are not taken into account when the corresponding operations are being executed.
• LINQ: Using ternary operator (x ? t : f) fails when t and f compare for equality - When using the ternary operator with an equality operation in the true or false part, the generated SQL is wrong.
• LINQ: Runtime support for DateTime.Date property; Throwing an exception when DateTime property is not supported. - When the property DateTime.Date is accessed, the correct SQL code for extracting the date part is not generated and no exception message appears.
• DSL: Potential difference between enhancement and runtime settings leading to unloaded primitive fields - When the new designer is used, there is a potential difference in the way default fetch group fields are calculated during runtime and design time. This can lead to incorrect values (nulls) showing up as the field content.
• MSDE not detected as free database - The Microsoft Desktop Engine (MSDE) is a free database and the OpenAccess express edition should support it.
• Serialize to blob not working with new metadata - If a field is marked as SerializeToBlob in the new metadata definition the enhancer throws a type not supported exception if the referenced type is not persistent.
• Persistent Types are not always correctly resolved in Visual Basic projects - The problem comes from the fact that the full name of the clr types in Visual basic is different then the one in C#. In visual basic, the namespace is different then the one in the VB .NET code, the difference is that in the runtime the default project namespace is added to as prefix to the class namespace as well.
• The namespace of the OpenAccess classes is not changed when the user changes the namespace of the model from the model settings dialog - The namespace of the classes remains the same even if they have been in the default namespace and the user has changed that namespace.
• Null reference exception while reading Oracle schemas - It is not possible to read Oracle schemas with the default driver when adding a Domain Model item to a project - the SchemaReader throws an exception. Workaround: the ODP driver should be used instead.
• The Add new item wizard does not allow to select Oracle ODP connections - When a connection using the ODP driver is selected on page one, advancing to page two is not possible.
• DSL: Adding self-reference associations to a class is not possible - When a class is not associated with a self-reference constraint, adding such relation is not possible in the designer.
• Details editor: The list view in the relationships page should not allow sorting - The listview items are not ordered properly when sorting by column is applied.
• DSW - Second screen will be shown only if you have more than one RLINQ model in the DAL
• DSW - Fixed setting of Astoria v2 required environment variables

Telerik OpenAccess ORM Q3 2010 Release Notes (v2010.03.1110)

Enhancements

• PostgreSql database support. - Support for PostgreSql: http://www.postgresql.org/.
• Interfaces support in Visual Designer. - The interfaces are part of the Domain Model, the domain classes should be able to implement them and use them as 'Domain Roles'.
• Linq To Sql converter. - New converter tool that allows conversion of Linq To Sql models (.dbml files) to Telerik OpenAccess ORM .rlinq model.
• Added support for primitive properties of types Short and GUID in the Visual Designer. - Allow properties of type GUID and Short to be usable as identities in the designer.
• Display default mapping (provided by our Schema tool) in Visual Designer - The default mapping is calculated by the runtime system, but it included and displayed in the Visual Designer.
• IntelliTrace integration - Telerik OpenAccess ORM provides support for the IntelliTrace feature of Visual Studio 2010.
• Visual Designer Table Editor - A table editor control that allows the user to fine tune the forward mapping process for each of the mapped tables. The control is invoked from the schema explorer and the details editor.
• Full inheritance support in the Visual Designer. - Horizontal inheritance added to the DSL designer. Complex inheritance hierarchies should also be handled correctly. Interfaces should be able to participate in complex inheritance hierarchies.
• Delimiter support in ADS Sql - The ADS sql is generated without delimiters. This leads to exceptions if the table or column name contains spaces or reserved words. Now the [ and ] is used to surround all names.
• Named associations in the Visual Designer and OpenAccess ORM metadata - Until now the association types had no name associated with them. This was inconvenient for the users.
• Individual 'Update From Database'command for each persistent type in the Visual Designer. - Increases usability and gives fine-grain control over the model updates.
• Support for Many-to-Many relations in the Visual Designer This feature is available in the core but was not presented in the Visual Designer. The user should be able to create a default-mapped many-to-many association by changing the multiplicity of the two association ends to OneMany or ZeroMany.
• Stored procedure calls that are generated in the context do not contain the schema of the stored procedure. - Stored procedure calls that are generated in the context do not contain the schema of the stored procedure. That does not allow the use of stored procedures that reside in different schemas during runtime.
• Performance optimization: schema selection option in the Add new item wizard. - The wizard should allow to select which schemas are used instead of reading all of them.
• Performance optimization: Update From Database is up to 80 times faster than before. - The diff/merge layer was optimized significantly in order to provide better results.
• Ria Services Wizard: Ability to generate the RIa service directly from .rlinq file. - Instead of compiling the model project, we support direct metadata extraction from an .rlinq file.
• Enhance attributes tagging so that it covers horizontal inheritance. - Base abstract classes that have horizontal inheritance strategy are not getting tagged with the corresponding attribute.
• Provide mechanism for dynamically making properties in the dsl read only - Provide mechanism for making properties in the dsl read only through the property pane.
• Horizontal mapped base class cannot be referenced from a different assembly - If a horizontal mapped base class contains the id or version field for derived classes, the base class must be in the same assembly as the derived classes. If not, the id or version field is not found during the schema update or database open operation.
• Collections in 1:n and m:n associations should not be managed by default - The managed setting sometimes brings loading the whole collection in memory as a side effect in cases when this is not necessary. When the collection is really big, this causes severe problems, so 'managed' should be an option for the users that want the collections consistent at each moment. This step should be taken for collection containing not more than 100-200 objects.
• Details editor: Remove the quotes from the table names on the table mappings page of the details editor. - Currently the Fullname of the tables is used, which contains quotes like 'Schema'.'TableName'. The right way of doing it is: Schema.TableName.
• Provide an option to choose the database schemas used in the 'Update From Database' wizard - Currently all database schemas are read when the Update From Database wizard is invoked. This process could be quite slow when working with large databases. There should be an option in the wizard where the schemas used for the metadata comparison can be filtered by the user.
• Allow the user to explicitly set which table is a join table - Currently join tables are recognized automatically and this cannot be changed by the user. It should be possible to manually define whether a table acts as a join table by specifying a IsJoinTable property of the MetaTable class.
• Backend Specific concurrency columns are not recognized as version columns by the default mapping in the DSL - The backend specific version columns and the fields mapped to them(Timestamp) must be tagged with the right concurrency control facets by the default mapping.
• Support for reading UTC DateTime values - When DateTime values are stored, their Kind property is lost (when not stored into a column that allows to keep this value). Reading back such values will produce instances with Kind=Unspecified. Code has been added to convert the Kind to Utc during read operations.
  You can turn on this feature by specifying <useUTCForReads>true</useUTCForReads> in the backend configuration. You can also specify this with the runtime configuration property UseUTCForReadValues.
• Name generator should use automatic property names - The name generator generates the column name based on field names. If the field is compiler generated like below automatic properties the generated column name contains '<backing field>'. To make the generated column names more useful the property name should be used as input.
• The Update Database From Model wizard populates classes to upgrade based on the Update Schema property (MetaPersistentType) - If a class has no table mapped it should by default be in the 'items to update' panel of the Update From Database wizard. This should not have priority over the manually set "should update schema" attribute of a class. Newly created classes without a table(dragged from the toolbox) should have update schema set to true.
• Fluent Metadata Source should pick up configuration per class. - The fluent metadata source should be able to pick up configurations that are defined in the classes that are mapped. Should only pick up if the class contains an static method that return a MappingConfiguration object.
• Support for mapping fields in the Fluent Mapping API. - The fluent mapping should provide support for fields. Should only be available if the mapping is defined in a static method in the class as they will pop up in the intellisense.
• The FluentMetadataSource now validates the field names. - The FluentMetadataSource should check if the field names we have calculated with the fluent mapping actually exist in the clr types.
• Fluent Mapping should support artificial types and fields. - The fluent mapping should support artificial types and fields. One can create an artificial type using the MappingConfiguration(string namespace, string name) overload of the constructor. Artificial fields can be added using the HasArtificialProperty, HasArtificialPrimitiveProperty, HasArtificialStringProperty. Artificial navigational members can be configured using HasArtificialAssociation, HasArtificialCollectionAssociation.
• Support for extending containers using the Fluent Mapping API - The second FluentMetadataSource(MetadataContainer container) constructor allow to put in a existing container that can be modified and extended using the Fluent Mapping.
• Implement a source that can automatically default map all fields defined in a mapping. - The new DefaultMappingSource (that inherits from the FluentMetadataSource) can be used to automatically create mapping for all fields defined and classes, opposed to only the ones exposed through properties as the FluentMetadataSource does.
• The Fluent Mapping should be able to merge mapping from multiple projects. - The new AggregateMetadataSource can merge configuration from other mapping source and will try to resolving any not resolved item such as references or base types from the other sources.
• Improvements to the association handling in the Fluent Mapping. - Association can now only be defined on one side of the relation. Introduced support for mapping relationship that only have one end, be it a collection or a reference.
• Associations should allow to be directly mapped to columns. - Associations should allow to be directly mapped to columns. The ToColumn api is now available with the association. Using this api one can effectively use shared columns.
• Improvements to the default mapping with the Fluent Mapping API. - Introduced the new IsTransient API for marking fields that should be left unmapped. Also introducing the HasFieldName for explicitly specifying the field name of a property rather than relying on the name generation.
• New Type Handling system: Handling User Defined Types. - We are able to handle currently a great variety of types provided by the database backends - UDTs, XML, Spatial Data.
• New Type Handling system: Handling Spatial Data. - We are able to handle currently a great variety of types provided by the database backends - UDTs, XML, Spatial Data.
• Spatial data support in the Visual Designer. - We can import and process Spatial Data from MS Sql Server in Visual Designer.
• New Sdk Presentation framework. - A new way of distributing examples and relevant content for the Telerik OpenAccess ORM product (downloadable version).
• N-Tier examples. - New set of N-Tier examples based on WCF, Ria and Data Services for Telerik OpenAccess ORM. Currently the supported clients are WPF and Silverlight.

Fixes

• Setting the model name does not update the domain context name. - Setting the model name through the model settings dialog should update the domain context name.
• Schema migration for Oracle might fail with an SQLException - 'name is already used by an existing object', if the current user has access to other users. - While building a project, OpenAccess tries to migrate the existing database based on the current persistent model. If the current user has access to other users the tables defined by the current user are not detected. This causes 'CREATE TABLE' statements to be executed for each table of the current user even though these tables do exist on the database.
• Using vertical inheritance strategy with no discriminator column is not possible with a domain model - Using vertical inheritance strategy leads to runtime errors due to a missing discriminator column in the table of the base class.
• It is not possible to remove associations in the visual designer once they have been created. - When an association between two entities is added, it cannot be removed from the visual designer. This happens because the AssociationDeleteRule class attempts to remove a property as a part of the association before the association is removed. An exception is thrown - "Navigational members can be removed only by removing the respective relationship." - which does not apply in this case.
• Migration to new domain model fails with NullReferenceException when reversemapping.config does not contain stored procedures - When used on the examples-persistentclasses35 project, the migration fails with an exception because there is unconditional access to certain, possibly non-existing xml nodes.
• Extra fields in partial classes are not detected as transient - If a database is reverse engineered via domain model, adding an extra field leads to wrong queries or 'slot access' exceptions during runtime. The extra field should be used as transient field and should not extend the database table by a new column. Workaround is to mark this field as [Transient] by adding the attribute.
• MSSQL: Wrong column length conflict detected when string field is mapped to NTEXT or TEXT - When a string field column is mapped to NTEXT or TEXT, the implicit length of 255 (from the original mapping to varchar) leads to a useless column change conflict; the DB column (ntext/text) has already a length of zero.
• Artificial Types not usable under Medium Trust - When running under medium trust (IIS high or medium trust settings), the runtime is unable to use artificial types.
• Failure to execute statement can lead to invalid pooled prepared statements - When the database server throws an exception, the used prepared statement was not removed from the prepared statement pool, causing later usages to fail with an 'invalid prepared statement handle -1' (Mssql) failure.
• Medium Trust Environments: Unable to work with the DSL generated context classes - Under an altered medium trust environment, an InheritanceDemand was not met, resulting in security exceptions.
• SqlAnywhere schema migration - The Sql schema migration is not working if columns are added step by step. An create column statement might be created for already existing columns.
• Enhancer problem if a persistent simple type field calls methods like GetHashCode - If an method is called on a simple type like m_decimal.GetHashCode() and the method is inside a references assembly, the enhancer reports a null reference exception.
• The metadata is not correctly translated for hierarchical domain models which use attribute mapping. - When a domain model contains classes in an inheritance hierarchy and attribute mapping is used, an exception is thrown at runtime: "There are more than one db-column extensions used, only one is allowed."
• Enhancer problem with nested classes - If a persistent field is set or read inside a method of an inner class, the call is not intercepted and lazy loading and change tracking is not working.
• Enhancer does not load referenced assemblies - If an assembly is required by a type in an already referenced assembly the enhancer is not able to load this assembly. An exception that states the assembly that cannot be found is thrown.
• LINQ: Single() does not throw an exception when more than one element is found - As per specification (http://msdn.microsoft.com/en-us/library/bb155325.aspx) required, the Single() / Single(condition) methods must throw an InvalidOperationException when more than one element is found. Currently, the behavior is like First(), not throwing an exception.
• Creating artificial types with cyclic references can fail with type load exceptions. - When the type of a field on an artificial type uses another artificial type, TypeLoad exceptions can occur.
• RIA service does not work if id field is not a value type - If the primary key field is not a value type, but a string or int, the validation during submit changes fails.
• Reporting designer does not work after recompile - The Telerik Reporting designer shows an exception after rebuild and preview generation. It happens because a new assembly is generated and used but the OpenAccess runtime caches are working with singletons and cannot be refreshed.
• MSSQL: Mapping nullable timestamp column fails, requiring non-nullable timestamp column - When a timestamp NULL column is reverse engineered from the database, the generated CLR field type of long? leads to a runtime exception. The exception has been removed. The CLR field type should always be non-nullable.
• ObjectProvider drag-and-drop error with a Spanish VS2010 - Failed to create component 'ObjectProvider', drag and drop creates a SerializationException.
• Concurrency Control: Failure to detect already deleted objects when using IN statements - When the runtime uses IN clauses during delete (DELETE FROM TableName WHERE Id IN (a,b,c)), the check for non-deletable rows was not performed, leading potentially to incorrect concurrency control behavior.
• Connection already closed blocks scope - If a scope or context operation returns an connection already closed exception once, the scope or context cannot be used anymore. The connection should be replaced by a new one and it should be possible to continue with the same scope or context.
• Exception 'No metadata has been registered for class ...' can be thrown when database is physically not opened yet but an object id is to be parsed. - When an stringfield object id is to be parsed before the database is opened and all meta data is processed, an exception could be raised.
• LINQ: Not-nullable floats not respected in LINQ aggregation with SUM - When a sum over a float column is calculated the linq implementation returns an integer value.
• The schema API generates tables for reverse mapped views. - The update database from model, tries to create a table with the name of the view.
• Wrong insert statement generation when a zero value is passed to a smallint column which is part of FK constraint - When 0 is passed to a field of type Int16 which is part of FK constraint later when the insert statement is being generated NULL is passed instead of 0.
  If the corresponding reference is set everything works correctly.
• OpenAccessDataSource cannot find contexts which are located in assemblies from a different solution. - If you have a compiled assembly with persistent classes and a context (a domain model functionally set up) and the domain model project is in a different solution than the one of the main application, the main application references the assembly of the compiled project but the OpenAccessDataSource doesn't show the context located in the assembly under question.
• Addin not loaded if user has no admin rights - If OpenAccess is installed under an admin account and is used with a different account without admin rights the addin cannot be loaded.

Telerik Data Services Wizard Q3 2010 Release Notes (v2010.03.1110)

Enhancements

• Changed path to code generation templates. - Changed templates path. Now the paths are more descriptive.
• Warning the user if he/she missed the required environment variables for Astoria 2.

Features

• Silverlight validation controls. - Using standard Silverlight validation.
• Enable CRUD operations for each entity.
• Service name validation against language specific keywords.

Fixes

• Wrong Temp folder location.
• Missing entities in the wizard grid.
• Fixes when installing to a non-default installation path.
• Filtering views for Object scope.
• Problems when using Website and the generation service already exists in the Website project.
• Silverlight prerequisites check now work with Visual Studio 2010.
• Fixed bug when using schema names as namespace for the generated entities.

Telerik OpenAccess ORM Q3 2010 SP1 Release Notes (v2010.3.1125)

Enhancements

• Support for Foreign key constraints with same name in PostgreSql - Foreign Key constraints with the same name (in different tables) can now be correctly mapped using OpenAccess.
• A new menu item has been added for the Linq2SQL converter - It is no longer necessary to have a rlinq item in the project in order to run the converter.
• Backend type and connection string settings have been added to the Model Settings dialog - The backend type and connection string are now displayed under the Model Settings tab of the Model Settings dialog.
• Validation rule for invalid type mappings has been added - Added a validation rule that verifies that the CLR property type is compatible with the sql type.
• Validation rule for non synced backends has been added - Added a validation rule that verifies if the backend of the model is correctly defined.
• Improved connection settings handling - The Add New Item wizard can now skip the connection string when starting from an empty model, however the backend is still required.
• New create and edit table commands in the visual designer - Added Create Table and Edit Table commands to the context menu of classes in the diagram.
• DSW: Introduced validation for types not supported by WCF Data Services - A warning for unsupported property types is introduced.
• OpenAccess SDK: Introduced an ASP.NET version of the Sofia Car Rental application - This sample shows how to integrate the Telerik ASP.NET Ajax controls with OpenAccess. A recommended approach for handling database interaction logic is on the spotlight.
• OpenAccess SDK: Introduced the LINQ 101 examples - This application demonstrates how easy it is to use Telerik OpenAccess ORM when combined with the capabilities of LINQ.
• OpenAccess SDK: The send feedback button now opens the site feedback page - The send feedback button now opens the telerik.com feedback page instead of the default mail client.
• LINQ: Casting parameter values in queries is now possible - Expressions containing casts are now correctly handled and do not cause exceptions.

Fixes

• The help menu entries in the OpenAccess menu are now working - In the Q3 release the menu links were broken. They are now fixed and point to the correct URLs.
• Setting the inheritance modifier to final for a class is now working. - When the inheritance modifier is set to final the properties of the persistent class are generated without the virtual modifier.
• Improved the exception handling in the RIA wizard. - The "Exception has been thrown by the target of invocation" has been replaced with more specific text.
• The OpenAccessDataSource works with composite identities - An exception was thrown when using the OpenAccessDataSource with a type that has a composite identity.
• TypeConverters are now correctly initialized. - In order to read values from columns, TypeConverter instances are used. These instances must be created and initialized, which failed under certain circumstances.
• The Update From Database wizard is now reading length property correctly - The wizard picked up changes in the column length when there were no changes made.
• The Update From Database wizard now resolves references correctly. - In some cases the wizard would set references between model items to null.
• Map to Persistent Type is now displaying all the properties corresponding to association ends in the diagram. - When an entity is involved in associations with other entities which are already mapped and “Map to Persistent Type” is chosen for the table of the entity, all properties shaping the association ends are displayed in the diagram for the participating entities.
• An issue was fixed concerning AUTOINC BIGINT column on MSSQL - The type converter associated with this type was throwing an exception and a decimal type was incorrectly resolved.
• PostgreSQL schema read issue resolved - Sequences that have mixed-case names are now resolved.
• An issue with the default mapping has been fixed - The default mapping is now not crashing when a connection string is missing in the model.
• Oracle varchar2(40) type is now correctly resolved - The varchar2(40) type is now correctly resolved to string and not to GUID.
• Invalid foreign key constraint issue has been resolved - Foreign keys that refer to non primary key columns are now not detected as valid references.
• Fixed assembly load failure under medium trust - The OpenAccess assembly is now validated by peverify and is now correctly loaded under medium trust.
• LINQ: Resolved issue with projections to dynamically created types - When projecting to a dynamically created type and the same query is executed again from a different assembly an invalid cast occurred.

Telerik OpenAccess ORM Q1 2011 Release Notes (v2011.1.316)

Enhancements

• Added: Metrics API: Provide Metrics about internal resources used by OpenAccess. - OpenAccess used in application or web server scenarios has to provide information about the performance and scalability of the system. The amounts of database connection, parallel context instances, and transaction have to be available. When used, an example web page will show the usage and how to interpret the numbers.
• Added: Entity Framework project converter - A wizard that converts an Entity Framework file into Telerik OpenAccess model (.rlinq) file.
• Added: The Association Editor has been redesigned with UI and functional upgrades. It now works with Forward mapping.
• Added: The Update from Database Wizard has been updated with a hierarchical treeview which shows ALL database changes that can be applied to the model right away.
• Added: The Model Settings Dialog and the Add New Domain Model Wizard et better input validation and improved user experience.
• Added: DSW: Generation of Astoria data service without an identity field. - A warning should be shown when a generation of Astoria 1/2 data service is performed and there is an entity without identity field.
• Added: Fluent: Should not allow for navigational properties to be mapped trough MapType - This will result in BasicPropertyConfiguration being created for Navigational members which is not meant.
• Added: Fluent: Ability to configure enum fields/props. - Provide an API for props/fields of enum type to be made persistent and also become (part of) primary key.
• Added: Fluent: Provide the basic property API for all objects - We provided basic .HasProperty api for all types, not only the predefined ones. This means that one is able to perform the non- specific calls to AsTransient, HasColumnType etc. for all defined properties.
• Added: Fluent: Introduced API for setting the kind of a meta member - whether the member is read-only, write-only or calculated.
• Added: Fluent: Mark the join table's columns as primary keys.
• Added: Fluent: Provide API for specifying the concurrency mechanism and concurrency member of persistent types..
• Added: Fluent: Populate the MetaColumn's IsShared property whenever such a column exists.
• Added: Fluent: Provide API for mapping a sequence column of a join table.
• Added: Fluent: CLR type nullability is now taken into account when defining the meta column's nullability.
• Added: Fluent: Added API for specifying the discriminator column type.
• Added: Fluent: Provided API for setting the DataAccessKind of a persistent type and of properties.
• Added: Fluent: Provided API for setting the CacheStrategy of a persistent type - Available after MapType();
• Added: Fluent: Provided API for setting LoadingBehavior on MetaNavigationalMembers.
• Added: Fluent: Provided string based API for persisting fields - Provided a HasField(string) method of the mapping configuration used for mapping fields. This will allow for persisting field with no properties using OpenAccess, as well as provide string based API for handling associations. All of this is under the Telerik.OpenAccess.Metadata.Fluent.Advanced namespace.
• Added: Fluent: Provided API for creating one-to-many association with a join table - One-to-many association can now successfully be created with a join table in-between using HasAssocation(...).MapJoinTable(...).
• Added: Fluent: Associations were not correctly resolved when they were defined in two different Mapping Sources - Aggregating of two fluent mapping source from different assemblies - collection properties with a type in the referenced assembly did not produce a meta navigational member in the output container. Now they do.
• Added: Fluent: All MetaMembers should have the type of the underlying field. - All of the generated by the Fluent Mapping API MetaNavigationMembers and MetaPrimitiveMembers should have the type of the underlying field rather than the one of the property. This will allow for exposing entities with interfaces and similar operations.
• Added: Fluent: ordered associations - Provided OrderBy API for the HasAssocition call that allows for ordered association to be defined. Under the Telerik.OpenAccess.Metadata.Fluent.Advanced namespace.
• Added: Fluent: Provided API for mapping dictionary associations - Implemented HasProperty (for dictionaries based on primitive types) and HasAssociation (for dictionaries that are based on persistent types) API for working with IDictionary<,> properties. Also, you are able to define specifics for the join or lookup table. The specific is part of the Telerik.OpenAccess.Metadata.Fluent.Advanced namespace.
• Added: Fluent: internal identity field. - The API for specifying the internal identity field is now placed on Mapping configuration level.
  customerMapping.HasIdentity(). HasColumnLenght(25).ToColumn("internal_id");
  The field name should be a constant matching the name that the runtime expects to find:
  public static read-only string INTERNAL_ID = "<identity>";  
• Added: Fluent: internal version field. - The API for specifying the internal version field should be placed on Mapping configuration level.
  customerMapping.HasVersion(). HasColumnLenght(25).ToColumn("internal_id");
  The field name should be a constant matching the name that the runtime expects to find:
  public static read-only string INTERNAL_VERSION = "<version>"; 
• Added: Fluent: class-id field. - The API for specifying the internal class-id field should be placed on Mapping configuration level:
  customerMapping.HasDiscriminator(). HasColumnLenght(25).ToColumn("internal_id");
  The field name should be a constant matching the name that the runtime expects to find:
  public static read-only string INTERNAL_CLASSID = "<class-id>";  
• Added: Fluent: value type collections and arrays - Implemented HasProperty overloads for dealing with value type array properties such as string[]. Should also be able to define specifics for the lookuptable. The specific should be part of the Telerik.OpenAccess.Metadata.Fluent.Advanced namespace.
• Added: Fluent: Implement inheritance functionality for the artificial API - Implement HasBaseType API for the artificial types functionality under the *.Fluent.Advanced namaspace.
• Added: Fluent: Adding flat mapping configurations prior to base configuration results in invalid data - Whenever we add a derived configuration prior to adding a base configuration to the configurations list we do not produce valid container.
• Added: LINQ: stringBuilder.ToString() is not handled - a query like query = query.Where(pitsIssue => pitsIssue.Title == sb.ToString()); is failing.
• Added: 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.
• Added: LINQ: Inability to use outer query grouping in projections sub-query condition - When references to outer query projections are done from the nested query in a projection (example: recursive grouping from the WpfGrid), the calculation and handling of outer query references needs to be improved.
• Added: LINQ: Support for user-defined types as parameters - When user-defined types (or types that are not directly known to the runtime system like SqlDouble, SqlGeography) are encountered, the runtime fails to accept parameters of such type.
• Added: LINQ: Support for user-defined types as projection results - When user-defined types are projected from LINQ queries, the projection failed.
• Added: Postgres: Enable Paging Queries - Support for LIMIT and OFFSET has been added so that LINQ Skip and Take expressions are translated efficiently.
• Added: MySQL: Enable Parallel Fetching - Parallel Fetching has historically been turned off for MySQL.
• Added: Sqlite: Enable Paging Queries - Sqlite supports paging queries through LIMIT and OFFSET now.
• Added: Runtime: Make AdoTypeConvertes more robust - There seems to be non-reproducible conditions in which reading a 32 bit value from an OracleReader fails even though the .GetFieldType() was returning a Int32 indication.
• Added: Faster OpenAccessContext handling - Improve context creation and allow pooling of context implementation instances when no system.transaction had used the context. Two performance enhancements lead to faster generation of contexts, and to pooling of internal resources when possible.
• Added: OpenAccess Free Edition - The free edition adds complete support for SQL Server (both express and commercial editions) except Sql Azure. Also the support for Visual Studio 2005 and 2008 is removed, Level2 cache and artificial fields and types are disabled by default.
• Added: Fluent: (BREAKING CHANGE) All artificial based API is moved to the Telerik.OpenAccess.Metadata.Fluent.Advanced namespace. - All of the artificial based API is now moved into extension methods in the Telerik.OpenAccess.Metadata.Fluent.Advanced.

Fixes

• Fixed: RIA Services: The total count of items returned by a query with sorting is not correct. - The transported objects count is returned, not the amount of objects in the database in case of Skip and Take.
• Fixed: The L2 cache does not work correctly with Linq queries returning more than 50 objects - If a query which returns more than fifty objects is executed for a second time, a query to the database is made instead of using the data already loaded in the L2 cache.
• Fixed: Reference to Telerik.OpenAccess.40 assembly added - After Add new item wizard has finished OpenAccess add a reference to Telerik.OpenAccess.40 assembly even if it is not necessary
• Fixed: Cannot set collection fields to internal - If I select a collection or reference field in the dsl and set the visibility property to 'Assembly' the dsl file cannot be saved any more. A xml serialization exception is shown in the Visual Studio error window.
• Fixed: Execution of a stored procedure with an output parameter leads to an exception - Using the OpenAccessContext.ExecuteStoredProcedure to execute a stored procedure with an output parameter throws System.ObjectDisposedException("query") if the SP does not return anything.
• Fixed: The code generation fails when the solution contains an Integration Services Project - If the solution contains an Integration Services Project and a domain model is added, the following error is reported:
  System.Runtime.Serialization.SerializationException: Type 'Microsoft.DataWarehouse.VsIntegration.Shell.Project.Extensibility.ProjectExt' in Assembly 'Microsoft.DataWarehouse.VsIntegration, Version=10.0.0.0, Culture=neutral, PublicKeyToken=89845dcd8080cc91' is not marked as serializable.
  This can be avoided if the Integration Services Project is unloaded while working with the domain model.
• Fixed: Wrong documentation/UI for maxConAge - maxConAge is the number of logical close requests before the connection gets physically closed (no longer pooled).
• Fixed: Indexes are not updated in forward scenarios - If a model is generated by the OpenAccess DSL and forward mapped to the same or a new database, the indexes are not generated and if exists they are deleted.
• Fixed: LINQ: string.IsNullOrEmpty() not handled correctly against an Oracle server - The following query
  var query = context.EMPLOYEEs.Where(e => string.IsNullOrEmpty(e.TITLE)).ToList();
  does not return employees with a Null or empty-string name
• Fixed: Obtaining default mapping without a connection string rises exceptions. - When you choose Create table or check Use Default Mapping checkbox an exception is raised when there is no connection string.
• Fixed: DSW: The DSW add-in not removed - The DSW add-in is not removed when the add-in is unloaded from the visual studio add-in manager
• Fixed: Association editor loses information about columns when change of the target columns is being performed. - It is mostly visible with composite foreign key associations and the uses tries to switch the foreign key columns.
• Fixed: Fluent: HasConstraint breaks the model generation if a column is not defined - Whenever we map types with .MapType() and then use HasConstraint on a association a null reference exception is thrown when the constraint is being generated.
• Fixed: Classes marked with [DescriptionAttribute] are enhanced - The attribute mapping detects all classes as persistent that are tagged with an attribute derived from the [Description] attribute. A damaged assembly can be the result.
• Fixed: Enhancer is slow with embedded resources - If the assembly to enhance has a lot of embedded resources the enhancer becomes very slow. OpenAccess analyzed all resources if they are possibly rlinq files.
• Fixed: Linq: String array access not allowed as parameter - If an array access is used as query parameter, an unsupported exception is thrown:
  string[] strs = new string[]{"bla"};
  var result = from c in Scope.Extent<Customer>() where c.City == strs[0] select c;
• Fixed: Generic Data Access API: Unable to set value to identity member for new objects - In an insert scenario, we are not able to set a value to the identity member. This is a side-effect from the fact that we cannot change/update the identity of a persistent object. However we should allow setting it for new objects.
• Fixed: Fluent: Artificial association should not have to be defined on both ends. - Artificial associations should also be able to be defined on only one end.
  Most probably there is an issue with the mechanism handling poorly defined associations.
• Fixed: DSW: DSW add-in generates an exception when closing an entity diagram in Visual Studio 2008 - When we open an entity diagram and then we try to close it in Visual Studio 2008 the Data Services Wizard add-in generates an error report.
• Fixed: SDK : View in browser command throwing file not found even though the file exists - The html file is opened in the browser however the exception is still thrown and the sdk crashes.
• Fixed: Update from database: Constraints, Indexes and Schemas are not visible in the changeset listbox - The constraints, indexes and schemas nodes are included but not visible in the changeset listbox in the update from database wizard therefore they can only be applied with the Apply all function of the wizard. Single changes from those nodes cannot be applied.
• Fixed: LINQ: Ordering given before GroupBy expression must be cleared and only pushed to the server during group resolution - When an order expression is followed by an group by expression, the ordering must not be pushed to the server. However, the order must be present when the group is resolved. When ordering is required for the grouped result, the ordering must be explicitly given after the grouping.
  scope.Extent<Person>().Where(p => p.Weight > 83).OrderBy(p => p.FirstName).GroupBy(p => p.LastName);
  The ordering on FirstName is not significant if the result is grouped, but when each group is resolved, the ordering needs to be present.
• Fixed: Fluent: Cannot handle nullables in the HasConstraint method - When a nullable property is used for a shared field an exception is thrown. HasConstraint is not accounting for nullable properties.
• Fixed: Choosing Map to property on a column that is part of a join table rises an exception - The context menu for columns that are part of a join table allows mapping it to property. However since the master table of that column is not mapped to a class that would rise an exception.
• Fixed: DSW: NullReferenceException when the DAL project's output folder is relative. For example '..\bin' - NullReferenceException when the DAL project's output folder is relative. For example '..\bin'
• Fixed: LINQ: Failure to evaluate parameter value completely, leading to exceptions. - When an expression is given like ... where c.Name.ToUpper().Contains(param.ToUpper()) || param == String.Empty ..., an exception can occur.
• Fixed: DSW: Closes without reason. - DSW Closes without reason when we have only a class library, we check Separate checkbox and select <Add New Project> item from the combobox.
• Fixed: DSW: Textbox is enabled - Textbox for Separated project name is enabled when 'Separate' checkbox is unchecked.
• Fixed: SDK: WPF – when you filter by Complexity of examples you will see that C# and VB for the same example will not show with the same Complexity. - WPF – when you filter by Complexity of examples you will see that C# and VB for the same example will not show with the same Complexity. For example: Select WPF. Filter by Complexity with value 400 and you will see that VB for ‘Sofia Car Rental – WCF Data Services’ will not show. Another example is: if you filter by 300 Complexity you will not see the VB for ‘WPF MVVM with OpenAccess’s example.
• Fixed: Paged query results are not cached - If the second level query result cache is used and a paged oql or linq statement is executed, the query result is not cached.
• Fixed: DSW: Generated WCF EndPoint service throws an exception - Generated WCF EndPoint service throws an exception when the host is a VB Website and Separate files is checked.
• Fixed: DSW: WCF EndPoint with non-capital letter has syntax error. - When a WCF EndPoint service is generated with name beginning with non-capital letter and a SL App is generated, the SL App has syntax error.
• Fixed: DSW: "Cannot extract domain models." - "Cannot extract domain models." is shown when there is a type in the DAL that inherits from a type in a reference assembly.
• Fixed: DSW: Cannot build the project when we have a long service name - The generated project will fail when we type a long service name at the 'Select Data Service' step
• Fixed: ObjectContainer.CopyFrom fires to many queries - If a class contains structs and is copied via CopyFrom into the ObjectContainer, even if the object is already retrieved completely, additional queries are executed. This only happens if structs are used.
• Fixed: Fluent: Threading issue solved for FluentMetadataSource's MappingConfigurations property - When calling the GetModel() (and thus MappingConfigurations) in two different threads the MappingConfigurations collection is populated twice.
• Fixed: Enable Intellitrace not working - The enable Intellitrace from the OpenAccess options dialog does not change the right configuration file.
• Fixed: LINQ: Support for DataServiceProviderMethods class (WCF data service code) - The WCF data service generates LINQ queries that refer to the DataServiceProviderMethods methods. These methods have not been detected and were not handled properly.
• Fixed: Fluent: Should handle convert expressions from lambdas - When .HasProperty() is called with a custom valued type a Convert expression is created instead of a MemberExpression. In that case we should preprocess the expression and take only the MemberExpression.
• Fixed: Runtime: Loading content of a persistent dictionary can throw an exception - When a persisted field of type Dictionary<string,PC> contains a <"X",null> pair, the loading of such a field can throw a null reference exception.
• Fixed: MSSQL/Azure: Image type - Image type seems not to be associated with a byte[] producing converter
• Fixed: Connection string dialog closes when invalid connection string is available from the system - When an invalid connection string is encountered, the connection string dialog terminates and no new .rlinq file can be set up.
  Workaround: Must delete connection in server explorer.
• Fixed: Linq: Bug in the LINQ projection when using enums - When doing a projection into a new class that has an enum field we are generating wrong SQL. Example:
  var result = from p in db.Categories
  where p.CategoryID == 1
  select new SampleClass
  {
  Id = p.CategoryID,
  SampleEnumField = SampleEnum.Option2
  };
  The error behavior is that we are searching for the Option2 column that is actually an Enum value.
• Fixed: Azure: Schema reading fails because view sys.parameter_type_usages is missing - Schema read fails on Azure because the sys.parameter_type_usages view is not available. This view is used when stored procedures are read to translate UDTs.
• Fixed: Runtime: VariableLengthAnsiStringConverter fails when String.Empty is to be written - When the VariableLengthAnsiStringConverter is configured to be used, the write operation fails when String.Empty is the value to be written.
• Fixed: MySql: Create table statement uses 'TYPE=InnoDB' instead of 'ENGINE=InnoDB' - With MySql 5.5 the 'Create table' statement uses the keyword 'ENGINE' to specify the storage engine for tables. Earlier versions allowed the synonym 'TYPE' also.
• Fixed: Composite App-Id: Query conditions on references can fail if the components of the app-id have different type - A query with 'select * from OrderExtent as o where o.product = $1' can fail when the product uses a composite app-id where the components are of different type (like int and string).
• Fixed: Artificial Fields: Handling of artificial collection fields invalid when FieldValue(z, "name").Contains(param) is used - When an artificial field of collection type is queried with .Contains(value), invalid SQL is attempted to be generated.
• Fixed: Runtime: Failure during handling of classes that map to tables without non-pk columns - When a class contains only a pk field and it's concurrency mode is set to changed, the resulting table contains just the pk column. Such a class is not handled correctly when it's (non-existing) state is tried to be loaded.

Breaking changes

• Enhancer: OpenAccess had problems that produced cryptographical exception on user machines. To avoid this error in the future the enhancer was changed. Additional we have added code that makes the metadata calculation faster. However this leads to change for Enhancer contracts.
• ObjectKey API: The ObjectKey implementation was not completely OpenAcces and context independent. It was complicated to send those key instances to processes that do not use OpenAccess. Now they are completely independent of OpenAccess and can be used even in Silverlight applications to store key information. To achieve the independence, changes on the context API where necessary as well. The old API is marked as obsolete.
• Generated IObjectId classes: The generated object id classes for composite primary key tables are no longer necessary. The code generation, by purpose, does not generate them anymore.
• Fluent: The artificial functionality of the Fluent Mapping API is relocated. The Fluent Mapping Artificial API is now a set of extension methods that exist under the Telerik.OpenAccess.Metadata.Fluent.Artificial.
• Fluent: MappingConfiguration.HasIdentity(KeyGen) now returns an InternalPropertyConfiguration. The HasIdentity(KeyGen) return type is modified in order to match the return type of the new HasIdentity() api that handles the configuration of internal identities with OpenAccess.
• Fluent: MappingConfiguration.MapType().HasDiscriminatorColumn(...) now marked as Obsolete. This method is now marked as obsolete and non browsable as a new method(HasDiscriminator()) on the MappingConfiguration has been added that handles.
• Fluent: MappingConfiguration.MapType().HasDiscriminatorValue(string) now marked as Obsolete. This method is now marked as obsolete and non browsable as a new method (HasDiscriminatorValue(string)) on the MappingConfiguration has been added that handles this.
• Fluent: The DefaultMappingSource has been completely removed from the Fluent Mapping API

Telerik OpenAccess ORM Q1 2011 SP 1 Release Notes (v2011.1.411)

Enhancements

• Runtime: Introduced read after delete setting - Read after delete is a feature that allows you to access the values of a deleted but not committed object. Until now this had to be set via the transaction properties. Now it is usable via the backend configuration object bc.Runtime.ReadAfterDelete.
• Runtime: Introduced concurrency control setting - The backend configuration has properties to set the concurrency mode, but those proved too complicated to use. A new Concurrency property has replaced the Optimistic and DatabaseTransactionMode properties.
• Runtime: Implemented ability to cancel tracking events - Until now, in order to cancel OpenAccess tracking events it was necessary to throw an exception. There is now a Cancel property in the event arguments.
• LINQ: Improved support for SqlDouble and SqlGeography property accessors - When a SqlDouble.Value property is accessed, the returned double value is now retrievable. Same applies for SqlGeography.IsNull etc.
• Fluent: Implemented handling of internal fields for version, discriminator and identity columns - A new API has been introduced for setting and configuring the following internal columns to be used with OpenAccess.
  * internal identity
  * internal version
  * internal class id
• Fluent: Introduced a parameterless HasConstraint API for associations - Implemented API that allows for association to be created with a constraint without specifying its specifics.
• Fluent: Implemented mapping two properties to the same column using Flat inheritance - It is now possible to map properties in derived classes to the same column in the case of Flat inheritance.
• Fluent: Index Support - Implemented support for managing indexes with the Fluent Mapping API.
• Fluent: Define indexes over properties of base type in case of Flat inheritance - It is now possible to define an index over properties that are defined in the base class in the case of Flat inheritance.
• Fluent: Provide API for setting LoadingBehavior on MetaNavigationalMembers - It is now possible to specify the LoadingBehaviour of navigational members.
• Fluent: Provide API for setting LoadingBehavior on primitive members - It is now possible to specify the LoadingBehaviour for primitive members.
• Fluent: Aggregate metadata source now retrieves the explicit value, no matter which side it is on. - The aggregate metadata source is now able to get the explicit value from the extending source if the other source has a default value specified.
• Fluent: Provide API for defining indexes - Implemented API for creating MetaIndex objects. This API is located under the Telerik.OpenAccess.Metadata.Fluent.Advanced namespace.
• Fluent: Implement string based API that allows for defining both field and property names - A new string based branch of the Fluent Mapping API that allows for both property and field names to be defined. Using syntax similar to the already existing API for mapping fields. This API is located under the Telerik.OpenAccess.Metadata.Fluent.Advanced namespace.
• Runtime: Made read operations after context.Dispose() configurable - Many use cases require that the values of persistent fields are accessible after the managing context is disposed. A property named 'AllowReadAfterDispose' was added to the runtime configuration to make the behavior controllable.
• LINQ: Better usage of first level cache when only simple primary key field queries are detected - Users can now use LINQ expressions of form OrderItemExtent.Single(o => o.OrderId == orderParam && o.ProductId == productParam) to shortcut the query execution through the transparent use of the first level cache. Such expressions will be detected and will be transformed into the corresponding Context.GetObjectByKey(...) methods, leading to much better usage of the first level cache and also allowing better usage of the second level cache.
• Visual Designer: The following dialogs are now resizable - Association Editor, Model Settings dialog, Validation dialog.
• Visual Designer: Add new domain model wizard and Update from database wizard are now resizable.
• Visual Designer: Improved the Select changes page in the Update from database wizard - added a "Select all" button, improved searching, tree node state is now preserved during navigation between pages.

Fixes

• DSL: Fixed: Loading old model does not deserialize inheritance relationships. - Inheritance relations are now deserialized when reading old rlinq files.
• Fixed: SqlAnywhere generates duplicate keys occasionally - The high low key generator grap mechanism did not update the keygen table in some occasions. The prepared statement cache from sql anywhere client did not seem to work in all cases. The prepared statement cache is now disabled.
• SQL CE/LINQ: Fixed: translation of String.Contains(x) fails for non-constant x values. - When MS SQL CE is used, the LINQ expression translation of x.Contains(y) (x,y strings) produced SQL that looks good, but produces errors (arithmetic operation not supported for this type). This could happen when the string field x is mapped to a NTEXT column and y is a parameter, not a constant value.
• Fixed: SqLite db with " delimiters not readable - If the SqLite database schema is generated with "as delimiters around column or table names, the OpenAccess schema read process reported errors about invalid primary key constraints.
• Fixed: locking setting not accepted - Setting the transaction locking in the visual designer or directly at the BackendConfiguration is now working.
• Fixed: shared columns and managed collections problem - If a new object is added to the context and this object has a managed collection and a new reference is added to this managed connection, a NoSuchObjectException was thrown.
• Postgres/Oracle: Fixed invalid 'FOR UPDATE' statements generated under certain circumstances - When pessimistic locking is used in one ObjectScope, following ObjectScopes could fail with locking requests where no locking should be done at all.
• Fixed: Cache strategy 'All' not working - Using cache strategy 'All' no longer throws a null reference exception.
• Postgres: Fixed database schema migration not working properly for char(x) columns - When a char(x) column is modified into a char(y) column (x != y), wrong DDL code was generated leading to char(1) columns.
• LINQ: Fixed using the FieldValue method in a LINQ query leads to inconsistent results - The FieldValue field name was not part of the key for the compiled query cache, in some occasions resulting in a wrong query found in the cache.
• Fluent: Fixed aggregate creates a duplicate table when flat mapping is used. - Aggregating multiple sources no longer creates duplicate tables when flat mapping is used.
• Fluent: Fixed losing default values after aggregating sources - The default values of MetaItemAttributes are now preserved after aggregating multiple sources.
• Fluent: VB anonymous expressions produced an extra convert statement - VB anonymous types are now handled correctly by stripping off the extra convert statement.
• Fluent: Fixed changes to MetaPersistentType.BaseType not handled as primitive - Changes to the meta persistent type's base type property are now handled as primitive.
• Fluent: Fixed FluentMappingSource throws 'Late bound' exception - The FluentMetadataSource is no longer throwing a 'Late bound' exception if it finds a static method returning a MetadataConfiguration that takes a parameter.
• Fluent: Fixed columns in horizontal mapped classes not cloned to the derived classes - Whenever horizontal inheritance is used, columns from the table mapped to the base class are now copied.
• Fluent: Fixed "{no}" constraints not added to the underlying table - Constraints generated when it is not desired the runtime to generate (MetaConstraints with the name "{no}") a column are now added to the underlying table.
• Fluent: Fixed MapJoinTable(string) not adding the table into the Tables collection of the container - The MapJoinTable(string) method now correctly creates a join table and adds it to the Tables collection of the metadata container.
• Runtime: Fixed context.Metadata not working with Azure - If a connection to Microsoft’s Sql Azure database has been opened, the context.Metadata call produced an invalid value exception.
• Visual Designer: Fixed glitch in type presentation - Under certain circumstances, the types of the properties in the Visual Designer were displayed as Nullable` and not with their actual names (for example : Int32, DateTime etc.)
• Code generation: Fixed VB .NET Root namespace handling - A namespace was always generated for classes whether or not their namespace matched the root namespace of the project.
• DSW: Fixed crash when using DSW with a Free Edition license - When the Data Service Wizard is used with the Free Edition of OpenAccess, the discovery of persistent entity types failed with a NullReferenceException.

Enhancements

• OpenAccess Profiler - The OpenAccess Profiler is a standalone application exposing the behavior of the lower layers of OpenAccess by displaying log data in an appropriate visual manner. The information can be loaded from log files or directly read from a running OpenAccess-based application. The OpenAccess Profiler has an analysis engine, able to detect problematic or low-performing areas in the application related to the way OpenAccess is used. Various metrics can be used to derive the health of a running application by analyzing the database throughput as well as the scalability.
• Domain Context Wizard and Visual Studio templates - Implemented a new wizard which allows the user to generate a standalone domain context class based on a domain model (in a different VS project). The domain model could be present in the project where the new context is added or in any other referenced project. The user should be able to choose which endpoints are generated in the context class, depending on the domain classes available in the model.
• RIA Domain Service Wizard The domain service wizard has been completely reworked. It now allows adding domain services from fluent metadata sources (no context required). It also allows adding services from .rlinq xml file (VS project) or an OpenAccess context. The wizard has been redone using WPF.
• LINQ (Firebird): Use ColumnAlias for GroupBy - Support for using the ColumnAlias for GroupBy has been added to the runtime.
• LINQ: Improved support for Min/Max/Sum/Avg/Count aggregates in filter conditions - LINQ expressions like
  var rows = from vp1 in Scope.Extent<Northwind.OrderDetail>()
  from v in Scope.Extent<Northwind.Order>()
  where vp1.OrderID == v.Id && vp1.ProductID != Scope.Extent<Northwind.OrderDetail>().Where(x => x.OrderID == v.Id).Max(x => x.ProductID)
  select vp1;
  are now handled correctly.
• Server side paging support for Postgres and SqlAnywhere - Postgres and SqlAnywhere both support server side support for paging queries now.
• Using ODP.net as only driver for Oracle - The default ADO driver to be used for Oracle databases has been changed to ODP.NET (the Oracle provided driver). The reason for this is that the .NET framework built-in Oracle driver (the managed parts of it) are marked as obsolete by Microsoft, and in order to use it customers have to install an Oracle client anyway.
• LINQ: Handling for ordering on constants - Handling for ordering on constants has been added to the LINQ implementation.
• Sql Server Compact Edition 4.0 support - Microsoft has a new version of Sql Server Compact Edition. This version is pure managed and xcopy deployable. OpenAccess has to support this better engine.
• Sql Server Compact Edition 4.0 support: Added Support for Paging in Sql Server Compact Edition 4.0 - Support for Paging in Sql Server Compact Edition 4.0 has been added to the runtime.
• L2S Converter: Make the converter available for Visual Studio 2008 - Make the Linq to Sql converter available for Visual Studio 2008.
• LINQ: Added Support for DateTime.DayOfWeek - Support for using the DateTime.DayOfWeek property has been added to the runtime and LINQ implementation.
• MSSQL: Support for sql_variant - Support for the sql_variant SQL type has been added; the mapped fields CLR type is object.
• Attributes Mapping: Add Cache Strategy Attribute - There is missing functionality in the area of the attributes mapping source: Specifying the cache strategy for a class with an attribute is not possible. We should include a new attribute and add the proper logic for its applying.
• Developing ADO-style API for OpenAccess/RLINQ - This item channels all efforts required to implement Ado.Net compatible API similar to what other O/R tools have.
  It includes Connection, Reader, Command, ConnectionStringBuilder implementations.
• LINQ: Support for == new Guid("stringconstant") in where clauses - Support for expressions like new Guid("stringconstant") was added for LINQ.
• SDK: Add requirement checking whether SQL Server has been installed. - Add requirement checking whether sql server 2005 or greater has been installed.
• Oracle: Using NCLOB with Unicode data fails - When Unicode strings are stored in an NCLOB, the data was passed as CLOB.
• Deployment: Removed Adonet2 assembly. - The Adonet2 assembly has been removed from the product and the functionality is merged into the runtime assembly. You do not need to deploy the assembly any longer.
• Deployment: Added the Common.UI assembly. - The base code of all UI-related components used by the visual designer has been moved to a separate assembly - Telerik.OpenAccess.Common.UI . It is required by the installed product.
• LINQ: Improve projections for better performance and completeness - Projections are now using compiled code instead of relying on reflection.
• Runtime: ADO.NET driver loading uses standard .NET mechanisms now. - The ADO.NET drivers for the various database backends now uses the standard .NET mechanisms for drivers.
• Oracle: Equality comparison of blob/clob columns now uses dbms.lob_compare(column,param) = 0 instead of simple = - When a clob/blob column is to be compared for equality, the lob_compare() method is now used.
• Oracle: Connection Strings using the System.Data.OracleClient are redirected to the Oracle.DataAccess.OracleClient (ODP.NET) - When the deprecated .NET Oracle Client from Microsoft is referenced in the connection string attribute providerName, the value is replaced silently to Oracle.DataAccess.OracleClient, which is the provider name for the Oracle ODP.NET client.
• Added CacheStraetgyAttribute - Until now it was not possible to specify the cache strategy for a class if attribute mapping is used. The CacheStrategy attribute was introduced in order to allow specifying the 2nd level cache options for classes mapped with attributes.
• MySql: Implemented preliminary support for LONGTEXT with additional settings (codeset, collation) - Preliminary support for LONGTEXT column modifications is now included, so that sql type specifications like "
  LONGTEXT CHARACTER SET utf8 COLLATE utf8_general_ci" are possible.
  What remains to be done: Detection and handling of changes in the character sets, collations, etc. (whatever is specified after the LONGTEXT).

Fixes

• Fluent: Fixed field name generation when using multiple levels of Horizontal inheritance - The algorithm used for calculating the field names of the most derived members is a greedy one and does not cover all scenarios. We should add one using recursion to make sure that all of the field names are generated correctly.
• Fluent: Fixed AsTransiend() for properties with no field behind them - When a property that has no field behind it is marked it as transient a FieldNotFound exception is thrown.
• Fluent: We are now able to resolve columns for navigational members with the same name if the table is not specified - The fullname/key of a meta column is derived from the property that is mapped to, however in the case of association this cannot be easily resolved. Then the full name should be just the name (as one will be specified) prefixed with the table name. However if there is no name we should use a moniker for the table and thus get a real name.
• Fluent: Mapping on subclasses in a horizontal inheritance hierarchy is ignored and the default mapping is used. - Table/column mapping can be specified for a subclass ,in a horizontally mapped inheritance hierarchy, via the Fluent API. This mapping, however, is not reflected in the generated SQL for creating the tables/columns. The tables/columns are created using the default generated values for column name, column type, etc.
• Fluent: Fixed Globalization problems with the Turkish letter "I" - If the current culture is set to Turkish, and a property's name contains a capital "I" the field name is calculated to have a lower "i" with a small Turkish 'i' that is not available in the actual class.
• Fluent: Fixed merging when concurrency control has been specified - The default for optimistic concurrency control in the metadata container is specified as Changed and it should be Default as it is in the FluentMetadataSource; this leads to an exception in the merging algorithm as this is found out to be merging two attributes with explicit values.
• Artificial Types: Duplicate generation of an id property should be avoided - When an id property is declared through the fluent mapping for an artificial type, this id is only denoting the base type to be used and should not be generated again as this would lead to an id property in the artificial base type and in the artificial type.
• SDK: Improved error message when an examples is ran on a machines without SQL server - When the SDK is installed on a machine without SQL server and an example is ran the following error is seen: Value cannot be null. Parameter name: source
• SDK: Fixed database selection when the server name has been changed - Whenever we change the Server name the Database is cleared and there is no way to change it back.
• SDK: Fixed crash where the SDK is closed after the Blogs section has been opened. - If the blogs section of the SDK has been opened and the SDK is closed you see an error: This program requires a missing Windows Component. This program requires flash.ocx, which is no longer included in this version of windows. (This happens on orm-win7 - 32b virtual pc).
• SDK: In the Database Management Tool the default shown path to the database contains incorrect symbol. It will contain this '/' instead of this '\' - SDK - install SDK on a folder different from the default one. Select one example and click Run Example. Database Management Tool will show. The shown path to the database will not be correct. It will contain this '/' instead of this '\'. For example: it will show this "C:\SDK\ProductSdk\Content/DatabaseData" instead of this"C:\SDK\ProductSdk\Content\DatabaseData".
• SDK: Fixed path in the Database Tool Management Tool the default shown path to the database contains incorrect symbol. It will contain this '/' instead of this '\' - SDK - install SDK on a folder different from the default one. Select one example and click Run Example. Database Management Tool will show. The shown path to the database will not be correct. It will contain this '/' instead of this '\'. For example: it will show this"C:\SDK\ProductSdk\Content/DatabaseData" instead of this"C:\SDK\ProductSdk\Content\DatabaseData".
• Postgres: SERIAL/BIGSERIAL columns are now handled as AUTOINC per default if they are used by a non-default schema - When a non-default schema defines a table with a serial/bigserial column, this column is not detected as autoinc per default.
• Postgres: Fixed VARCHAR column length migration - When the length of a VARCHAR columns is modified, the resulting update DDL statement does not write the length information correctly.
• Postgres: Schema change is wrongly detected for char(x) columns - When a character(12) column is written to the database, the same column was returned as bpchar(12), which causes a false column difference to be detected. This could lead to an incorrect ALTER COLUMN DDL statement.
• Postgres: New instances can now be added to tables in a non-default schema with a 'serial' primary key column. - Committing a new instance of a class mapped to a table in the non-default schema failed with an exception.
• Postgres: The default schema for a PostgreSQL database is now properly detected in case a search_path is specified - The schema reader was not able to detect the default schema if the 'search_path' variable has a schema other than 'public' as first in the list.
• Postgres/Oracle: When using pessimistic locking, invalid FOR UPDATE statement can be generated when GROUP BY is present - When group by is present in a query that is executed against an Oracle or Postgres server and pessimistic locking is used, the generated SQL includes a FOR UPDATE clause that is not permitted.
• Oracle: When NLS_COMP=LINGUISTIC is used, database schema retrieval can fail - When linguistic comparison is turned on for a particular database (or session), the schema retrieval process can fail with a Oracle message similar to ORA-9004: "O"."NAME" identifier not found.
• Oracle: Unicode characters are now correctly inserted in nchar columns - The store call to a char(1) column does not insert Unicode character.
• Oracle: Support for NCLOB inequality comparison - When using NCLOB columns, such columns must be compared with the dbms_lob package compare function.
• Oracle: Fixed inability to store Unicode string data - When Unicode values are to be stored into NVARCHAR2 columns, the values were not stored correctly.
• MySQL: Failure to read stored procedure parameters when user defined function is present in another database - Due to an issue with the MySQL ADO driver, the first stored procedure parameter is not obtainable from the ADO driver when a user defined function exists on another database on the same server.
• MSSQL: Avoiding potential runtime issues where the database server cannot find a prepared statement handle. - At seemingly random intervals the MSSQL server can return a 'cannot find prepared statement handle -1' error. In addition to verifying that the connection is still active, OpenAccess empties now the prepared statement cache on that connection to avoid such problems.
• MSSQL: When multiple indexes with the same name exist within a MS SQL server database, the schema read module does not read the indexes correctly - In MS SQL Server, if a database has more than one index with the same name (in different tables) the schema reader does not read the index information correctly. This resulted in the wrong number of indexes being created with ambiguous information.
• MSSQL: SqlGeometry and SqlGeography columns cannot be compared with = operator and therefore are now excluded from concurrency control - A geometry/geography column cannot be compared with = and such columns are no longer used for concurrency control.
• OData: WCF Data Services - LINQ expression fails when $expand is used with collection property - An OData request of form Orders(10248)?$expand=OrderDetails translated into LINQ is not properly processed by OpenAccess.
• OData: WCF Data Services - LINQ expression fails when $expand with deep references are used - An OData request of form Orders(10248)?$expand=Employee/ReportsTo translated into LINQ is not properly processed by OpenAccess.
• OData: WCF Data Services - LINQ expression fails when $select with simple field is used - An OData request of form Categories(1)?$select=CategoryName translated into LINQ is not properly processed by OpenAccess.
• Object container copy to throws cast exception - If an object with shared fields gets a new base type assigned to the shared field, the CommitChanges or CopyTo can throw an class cast exception. If the container is used, setting both the id and reference field is recommended.
• LINQ: Using constants of user defined base types (SqlGeography) leads to invalid cast exceptions - When constants of SqlGeography are used in LINQ expressions, the translation needs to treat them as parameters, otherwise invalid cast exceptions are thrown.
• WCF RIA Services: Failure to handle concurrency modes ALL and DEFAULT properly - When the All or Default mode are used for Concurrency Control, the required round trip attributes are not generated, leading to missing values that generate false concurrency control conflicts.
• WCF RIA Services: Updating a byte[] fails with index exception - When updating a byte[] field, an index exception can be thrown while checking for changes.
• A self-referencing association with a shared field is not inserted correctly. - Whenever we try and add a chain of self-referencing objects by only adding the first one to the context we get incorrect data inserted.
• LINQ: Incorrect handling of collection projections - Collection field projection could lead to IQueryable<X> where a IQueryable<IList<X>> should have been returned.
• LINQ: Using a property of interface type not possible even when the property backing field is of persistent type that just implements the non-persistent interface - When using something like
  class Product {
  public IVendor TheVendor { get { return vendor; } }
  }
  class Vendor : IVendor {
  }
  and setting up the meta data correctly, LINQ expressions similar to 'from p in ctx.Products where p.TheVendor.Id == param' fail as the returned interface type of the property is not handled correctly.
• LINQ: When the SQL extension method is used, included parameters are now handled correctly - When the SQL extension method is used, the parameters that are passed (and referenced symbolically) are not handled correctly, this affects situations where more than one parameter is present in the query.
• LINQ: Fixed translation of String.Length under certain circumstances - When an expression like 'from x in db.Persons where x.Name.Length > paramInt select x' is made, the translation of the String.Length property fails with an exception produced by the type converter for the parameter expression.
• LINQ: Handling of queries that involves nullable bool fields can lead to incorrect SQL - When a nullable bool field is compared with a boolean value, the resulting SQL can be incorrect.
• LINQ: Handling of string.StartsWith/EndsWith/Contains for fixed size char(x) and nchar(x) columns is now correct for non-constant arguments - When fixed size char(x) and nchar(y) columns are used for LINQ expressions string.EndsWith, string.Contains and string.StartsWith, the returned results were not correct as the passed string parameter (not a constant) was appended with spaces.
• Execute SQL Select statement with disabled ForwardsOnly setting leads to an exception - Executing an SQL statement via IObjectScope.GetSqlQuery(string,Type,string) and setting ForwardsOnly=false on the result lead to an exception.
• BackendConfigurationSettings: Parsing the IsolationLevel setting leads to InvalidCastException
• Fixed ADS data migration - Migrating the data to a varchar column is now possible. The upgrade ddl script contained a convert to varchar instead of SQL_VARCHAR function.
• Firebird: Blob subtype 1 is now correctly mapped to string - When a column with blob subtype 1 or with a domain using this type is mapped, it was mapped to byte[], when it should have been mapped to string.
• Runtime: When the database server is temporarily down, a stale connection can be used for longer than it should be - When the database server connection gets broken, the storage manager and the connection pool could still hold and give out stale connections. This could lead to more exceptions even when the server is available again.
• Runtime: Attempting to delete items from a managed collection throws an exception when the collection is maintained by an inverse reference field and the inverse field shares a PK column with another field. - When an item from a managed collection is deleted (via scope.Remove), the runtime attempts to reset the inverse reference field of this item (if the collection is maintained via an inverse field and not a join table). If this inverse reference field is mapped to a PK column an exception was thrown with the message - Change of identity is not supported.
• The Add Domain Model wizard now correctly filters the ODP.NET connections. - The wizard no longer filters connections created with the Oracle Data Provider. Connections created with the standard Microsoft Oracle client or the Oracle Data provider are now shown in the Setup Database Connection page of the wizard together.

Breaking Changes

• Generated methods for stored procedures calls on the context now have changed signatures - Method signatures for stored procedures calls are changed, the old behavior can be switched back by modifying the T4 templates. More information on the matter will be provided in a dedicated knowledge base article.
• Metadata changes - Due to a few concerns that we addressed (improved memory footprint, better handling for Associations, improved API by introducing generics and generic interface) we refactored the Metadata class hierarchy which led to some changes to the API surface as well that will affect users that manipulate the MetadataContainer and related API directly (in-memory). Does not apply to Fluent Mapping API.

Enhancements

• Introducing the new OpenAccessLinqDataSource for ASP.NET (.NET 4.0)- The new data source uses LINQ expressions for querying data. Supported features:
  • Custom selects
  • Handles concurrency automatically
  • Server-side paging, filtering, sorting and grouping
  • Provides full ASP.NET design time support
  • Integrates with DynamicData
  • Grouping and Aggregating Data
• Code scaffolding for WCF Services based on OpenAccess model - Introduced a new wizard (started through the "Generate OpenAccess Domain Service.." context command) that can generate WCF Plain Services, WCF Data Services, WCF RESTful and AtomPub Services.
• Integrated WCF Service generation based on OpenAcess domain models - We now allow generation of WCF Plain Services, WCF Data Services, WCF RESTful and AtomPub Services that can be started through the solution explorer context menu command "Generate OpenAccess Domain Service...", that generates services using our new provider for DataServices and a newly implemented DTO infrastructure for the rest.
• Solution explorer context menu commands for the DSW are now removed - The context menu commands for the Domain Services Wizard are now removed and it can now only be started through the main Telerik menu. Currently this functionality is substituted by the "Generate OpenAccess Domain Service..." command.
• Data Transfer Object Infrastructure (currently available only via the "Generate OpenAccess Domain Service..." command) - We have implemented code generation based DTO scaffolding that implements best practices based and various abstractions including Assemblers that can convert back end forth from OpenAccess entities to DTOs, Repositories that can retrieve OpenAccess entities and Services that combine everything. This allows decoupling the OpenAccess DAL implementation from the application layers above. Such a separation introduces better testability.
• Introduce common OpenAccess Project templates - Introduced templates for both Visual Basic and C# that allow for easy setup of Web application, Class Libraries, Fluent Libraries and MVC2 Applications.
• Fluent: Implement a NuGet package for the Free Version of OpenAccess - Introduce a set of NuGet packages that can include OpenAccess in a solution, and set up the enhancer correctly and provide some sample code to get people started with the Fluent Mapping API.
• Stored Procedure Editor - A new editor that allows specifying the result shape of a stored procedure and handles procedures with multiple result sets. The editor also allows custom return shapes to be generated based on the result of the stored procedure. The editor can be started from the schema explorer by right clicking on an already imported stored procedure.
• Profiler: Improved application performance - The OpenAccess Profiler now uses the new Telerik RadChart for WPF, which significantly improves the performance of the application when working with large amounts of log data.
• Profiler: Implemented new extended Metrics page - The OpenAccess Profiler now has an additional page where only metrics are shown in greater detail.
• LINQ: Support for pushing .Distinct(...) statements to the server improved - The detection for server side push-able Queryable.Distinct(IQueryable<T>) has been improved and corrected.
• SDK: Introduce Sofia Car Rental example using ASP.NET MVC - A new Sofia Car Rental MVC example has been added to the SDK, including a model mapped using the Fluent Mapping API and a full blown ASP.NET MVC2 application developed using best practices.
• SDK: Provided "Open tests solution" functionality for samples - Implemented "Open tests solution" command in the SDK so that customers can easily navigate to the test solution.
• Connection Pool enhancements - The OpenAccess connection pools replaces the ADO driver dependent pooling. This is sometimes not necessary or useful. It is now possible to disable the OpenAccess connection pool or to use it's management functionality together with the ADO driver implementation.
• Introduced the new OpenAccess DynamicData wizard - Provided code scaffolding wizard based on an OpenAccess model for DynamicData projects that can be used to generate custom pages for CRUD operations.
• Fluent: Naming rules should use invariant string operations - The naming rules class and functionality should only use invariant string operations. This will prevent globalization related problems such as the Turkish I problem that we have faced often in the Fluent Mapping API.
• Runtime: Provide ability to flush in-memory changes to the database when using System Transactions - When using System Transactions, the ability to perform a flush of the in-memory changes to the database is required.
• MSMQ: Provide better error logging so that deployment issues can be detected more quickly - When using MSMQ, the ability to create and access message queues must be logged, so that problems in the deployment can be more easily detected.
• Fluent: Specifying indexes over columns in a base horizontally mapped class - An index can be defined over all properties in a horizontally mapped class as they are all stored in a single table, currently this is not possible through the HasIndex API.
• BackendConfiguration Logging API has been improved - All logging settings are now available under BackendConfiguration.Logging. The old properties have been made obsolete.
• LINQ: Support for ICollection.Contains(function(persistentField)) added - When using a List<string> that holds the string representation of some values, support for using this list instance in expressions of the type
  'listInstance.Contains(persistentField.ToString())' has been added. It is now possible to use methods and functions on the persistent field argument
  to the Contains method which is translated into the corresponding SQL IN statement.
• Model Settings Dialog improvements - The Model Settings Dialog has its captions updated, tooltips added and has the Logging, Second Level Cache and Connection pool pages updated.
• Tracking: Changed and Changing event arguments now contain old values. - The changing and changed callbacks of the tracking implementation now contain the old values.
  The ChangeEventArgs class now has a WasLoaded property that indicates whether the OldValue property contains real data.
• WCF Data Services: Introducing the new OpenAccess implementation for OData services. - Introducing current implementation for WCF Data Services based on the following base classes and interface:  DataService<T>, IDataServiceMetadataProvider, DataServiceMetadataProvider, IDataServiceQueryProvider, IDataServiceUpdateProvider. This implementation is now available through the new "Generate OpenAccess Domain Service..." command in Visual Studio.
• SDK: Data Services examples should use the new OpenAccessDataService implementation - The implementation of the examples that uses the DataServices should be updated so that they use the new OpenAccessDataService instead of the reflection provider they used to.
• MSBuild Integration: Allowing the EnhancerAssembly property to be set from caller, permitting the enhancer to be in a non-default location - The EnhancerAssembly property cannot be specified by the user of the OpenAccess.targets file and a non-default location is therefore possible.
• LINQ: Ability to push Count queries on entity.CollectionProperty.SelectMany(x => x.collectionField) to the server. - Support for sub collection count queries has been improved, and LINQ expressions like
  var q = from x in ctx.Customers select new DTO() { x.Orders.SelectMany(x => x.OrderItems).Count() };
  are possible now.
• Profiler now shows parameter values and RowCount with logging mode 'verbose' - It should not be necessary to set logging to 'all' to see the parameter values and the rows fetched values. The overhead of 'all' can be avoided. The communication version between application and profiles has to be changed and it is not possible to attach the new profiler to an older application and vice versa.
• Oracle: The ‘order by’ expression appear in the select clause and are referenced by the column’s alias name. - Oracle expressions that appear in order clauses will now appear in the select clause and will be referenced by their alias names.
• LINQ: Filtering by Boolean value in collection will lead to "Query too complex for mssql" exception. - If you filter by Boolean value in collection you will get "Query too complex for mssql" exception. The generated SQL script will be less complex now.
• Profiler web service enhancements. - The profiler web service needs to support different OpenAccess versions on client and server side. The definition should have a version number and a mechanism to check if client and server part can work together.
• DSL: Table editor crashes with mysql unsigned types. - If you open the Table Editor for a table which column is mapped to unsigned number type you will see that the Table Editor will crash.
• Telerik.OpenAccess.Config assembly is no longer necessary. - The Telerik.OpenAccess.Config assembly was necessary to read the OpenAccess node from the app or web.config file. This is no longer necessary. The entry can be kept as it is but to make it clearer which assembly is really used, the section handler entry can be changed.
  Existing entry:
  <section name="openaccess" type="Telerik.OpenAccess.Config.ConfigSectionHandler, Telerik.OpenAccess.Config, Version=1.0.0.0, Culture=neutral, PublicKeyToken=7ce17eeaf1d59342" requirePermission="false" />
  New Entry:
  <section name="openaccess" type="Telerik.OpenAccess.Config.ConfigSectionHandler, Telerik.OpenAccess" requirePermission="false" />
• Test SQL Server Denali - OpenAccess has stopped working with Azure when using Denali code due to the new Sql Server version.

Fixes

• Update Database from Model - will now not drop constraints that you have selected for dropping. - SQL Script for dropping constraint that are not selected for dropping will now not be created.
• CodeGeneration: Usings are not generated when generating into a single file without a context. - The usings generation is skipped when generating into a single file when a context is explicitly set to not generate.
• VistDB: Migrating a column to a TEXT or NTEXT column fails with an error - Invalid or missing data type specification - VistDB: Migrating a column to a TEXT or NTEXT column fails with an error - Invalid or missing data type specification. Expected to find DataType and Length. The generated script appends a lenght for the text and ntext columns, which is not required.
• Profiler - The event grids are now not scrolled to the top when new data arrives. - The grids should keep their scroll position and selection, when new data is added.
• Profiler - An error occurs on the Grouped SQL Events tab when the details grid is updated with new data. - If the Grouped SQL Events tab is active and the details grid is expanded for a SQL statement, an error will occur if a new statement is added to the details collection.
• SQLite : Schema migration where a Foreign key constraint is added or removed from a table generates wrong SQL - SQLite does not support adding/removing a constraint via the 'ALTER TABLE' statement. In order to add/remove a constraint a temporary table needs to be created with the appropriate constraints, the data needs to be copied over, the original table needs to be deleted and then the temporary table needs to be renamed.
• MSSQL : A decimal or numeric identity column is wrongly default mapped to a System.Object type instead of the appropriate CLR type based on the precision. - A decimal or numeric identity column is wrongly default mapped to a System.Object type instead of the appropriate CLR type based on the precision. For example a decimal(18,0) should be mapped to a 'System.Int64' CLR type.
• RIA DomainService: You are now able to set null values when ConcurrencyControl is None - When the ConcurrencyControl mode is set to None, changes to null values are now reflected in the database.
• Update Database from Model: Fixed error that is shown when connecting to Oracle and navigating to the Summary page. - When connecting to an Oracle backend and going to the Summary page of the wizard an error was thrown that is now fixed.
• LINQ: Aggregate Sum/Min/Max/Average on nullable fields can throw NullReferenceException when no rows are found. - When an aggregate delivers a null value (because there have been no rows in the database so aggregate), the process of generating the result can fail with a NullReferenceException.
• LINQ: Conditions over Nullable not working. GetValueOrDefault() not implemented. - When expressions like ... x.PriorityFlags.GetValueOrDefault(false) == false are used, invalid SQL is generated.
  Workaround:  Use (x.PriorityFlag.HasValue ? x.PriorityFlag.Value ? 1 : 0 : 0) == 0
• LINQ: Detection of pure boolean conditions is insufficient, leading to wrong GetObjectById usages. - When a LINQ tree uses a condition like
  bool z = false;
  var id = ...
  var q = from p in source where z && p.Id ==id select p;
  the query translation does not detect that the query must not use the GetObjectById shortcut. This can lead to wrong query results.
• LINQ: Handling of TrackedList.Contains(T) method throws exception - When a TrackedList<Guid> is used as a field type, the Contains(Guid) method is not properly detected when the LINQ query is translated; this used to work in previous versions.
• Association Editor: Fixed error when an association is added between two classes with identities mapped to varchar(40) columns. - An error was thrown in the Association Editor while defining an association between classes with Guid identities that are mapped to varchar(40) columns.
• Fixed issue with specifying Horizontal Inheritance on a class that is the target end of an association. - Specifying the inheritance setting on any class should not lead to an exception or an error. You are now able to do that regardless of specified associations.
• VistaDB: stored procedure byte and ulong parameter not working - If a stored procedure is called with a byte or ulong parameter, a class cast exception occurs. It looks like the parameter handling is different for tables and procedures. OpenAccess handles this now.
• Runtime: Parallel Fetches on original queries that have an SQL 'Exists' statement will fail to resolve the sub query by id - When a Enumerable.Any(lambda) expression is transformed into an SQL EXISTS expression, the translation requires a sub query id to be present but will fail with an exception. This happens only for the collections that get fetched in parallel.
• Unsigned Types: Properties with unsigned types can now be used for primary and foreign keys. - Unsigned types can already be used for non-pk/non-fk purposes (pure value fields/columns), but support for primary and foreign keys of unsigned types is required.
• MySql: Support for UNIX based MySql versions - UNIX versions of MySql seem to report a version string that is incorrectly parsed, leading to 'not supported' exceptions.
• LINQ: Composite key comparisons for GroupJoins not working - When a GroupJoin is made involving a composite key, an exception is thrown with a message similar to 'flow of parameters cannot be detected'.
• ProjectTemplate: Fluent Library templates produce un-compatible code when project name contains special characters - Special characters should be escaped in content code for the MVC and Fluent Library project templates.
• Indexes with same members not read correctly - If there are 2 indexes defined on one class and they share some fields, the index is not read correctly.
• Runtime: Fetching instances using a wrong typed ObjectKey(X) can lead to wrong typed instances - When a model with inheritance chain B:A and C:A is given, using an ObjectKey with type B can lead to generation of a B instance for a database row that actually represents a C instance.
• Oracle: DDL script with CREATE PACKAGE statement is now working - If a DDL script that contains CREATE PACKAGE or CREATE OR REPLACE PACKAGE is executed via SchemaHandler.ExecuteDDLScript, the statement is truncated.
• Retrieving objects through the context should not go to the server for newly created objects - Calling retrieve on a new object should not try to load any data from the database, independent of which FetchPlans is set.
• Transaction flush cleans the second level cache too early - The Flush call removes the flushed instances immediately from the second level cache. The following commit does not remove them. This can lead to old data in the second level cache.
• Runtime: NullReferenceException when first component of composite foreign key is set to null - When a composite foreign key reference is initialized with null, and later the components are updated to a real value, a NRE can be thrown.
• LINQ: Using non-anonymous types for grouping key expressions throws exception - When a LINQ expression is given similar to context.Orders.GroupBy(g => new Bla() { X = g.ShipCountry}), the usage of a non-anonymous type created an exception.
• LINQ: Using group result in subsequent projection clause can lead to an exception. - When an projection expression of type .GroupBy(x => x.MyField).Select(g => new { A = g.Key, B = g } is given and where g is the grouping, an exception can be thrown.
• Oracle: When number is specified as column type, the converter initialization can throw exceptions - When number(1) is specified as column type for a bool field, the initialization of the type converter can fail.
• LINQ: Exception thrown when sub-query aggregate is compared with a parameter or literal and where the sub-query is on the left side - When a LINQ expression similar to
  from city in context.Ctities where city.Zips.Count() == 3 select city
  is made, an exception is thrown.
  Workaround: Put the parameter or literal on the left side of the comparison.
• Sql2008: DateTime2, DateTimeOffset and Time are now read correctly - Sql Server 2008 has the new types time(0-7), datetimeoffset(0-7) and datetime2(0-7), the precision defines the number of millisecond digits. The precision is not read and is always defaulting to 7.
• LINQ: Using .Take(Int32.MaxValue) throws an exception - Grids often use .Take(Int32.MaxValue) to express that no paging is to be done. This led to an exception because a parameter was missing.
• VistaDB: Money and UniqueIdentifier typed column must not generate column differences on user set length differences - When the user specifies a length or scale for Money or UniqueIdentifier columns, a column change was attempted even though columns of such types do not have settable length/scale, leading to invalid schema migration/creation DDL. This applies to VistaDB.
• Fluent: Fixed SecurityException while generating field names under Medium trust - Whenever the calculate field name functionality is used (in the case of fully defined properties) an exception is thrown due to the Inflector trying to access the local registry.
• VistaDB: Length information passed to DDL for column types that do not allow length to be specified - Certain VistaDB types like MONEY, VARBINARY, DATETIME etc do not allow length specification in DDL. A filter was missing for this.
• VistaDB: The 'DROP INDEX' statement generated to drop an index is invalid - To drop an index on VistaDB, Telerik OpenAccess ORM generates a 'DROP INDEX [indexname]' statement. The right syntax should be generated i.e 'DROP INDEX [indexname] ON [tablename]'
• Fluent: Associations to base classes are now correctly resolved - Whenever a base class references a derived class the association was not correctly setup due to inability to locate the inverse field.
• Profiler - The status of the Navigate to LINQ query command is now calculated properly. - The command is enabled for some alerts, although they are not associated with any LINQ events. The command should be disabled in this case.
• Fluent: Prevent possible TypeLoadException when retrieving configuration from static methods - It is possible that a TypeLoadException be thrown when retrieving configurations from the assembly due to naming issues, the exception is now caught and handled.
• LINQ: When only filtering on PK-only expressions, null values can lead to an exception when the ObjectKey for the shortcut resolution is created. - LINQ expression handling involves a shortcut that detects if an expression is retrievable from first level cache (GetObjectById-shortcut). When null values are specified, the intermediate ObjectKey cannot be created and fails with an exception.
• Indexes with same members are now read correctly - Fixed issue with index reading that occurs when 2 indexes are defined on one class and the share some fields.
• LINQ: Count(condition) now working on grouped results - When a Count(condition) is made on a group result, the condition is now properly pushed to the server.
• Update Database from Model - When a many-to-many relationship is updated no sql scrip is generated in "Update Database from Model" for the new join table. - Sql for join tables, as well as foreign key constraints, is now correctly generated when using the "Update Database from Model wizard".
• LINQ: TypeConverter is now found when value typed expressions are passed into object typed methods - When a 1 is passed as in X.Equals(1), where object.Equals(object) is used, the constant expression is converted (in the LINQ expression tree) to object. This previously lead to an un-resolvable type converter.
• OData DataService: Using nested string functions can lead to invalid, non-compilable SQL - When an OData expression like '/$filter=startswith(tolower(Name), "tele")' is used, the nesting of the ToLower string method can lead to invalid SQL being generated, leading to exceptions.
• RIA DomainService: Fixed inability to set null values when ConcurrencyControl is None - When the ConcurrencyControl mode is set to None, changes to null values are not reflected in the database.
• LINQ+VB: Multiple joins not working - If you use Visual Basic LINQ expressions which include multiple joins you will get an exception.
• Domain Context Wizard: The generated template does not work properly in VS 2008 - The reference to the Telerik.OpenAccess.Dsl assembly in the generated .tt file does not work in Visual Studio 2008 because it points to the assembly for Visual Studio 2010.
• DSL: Unable to load .rlinq files that uses a backend for which the driver is not installed on the current machine - When an .rlinq file needs to be loaded on a different machine for design time purposes, the machine must have a driver installed too. This is too restrictive and for such cases an ADO driver will not be needed any more.
• Profiler report missing events - The profiler reports missing events because the sort order of the events is wrong.
• RIA Wizard – “Enable client access” should not be added, if you have not checked it for the corresponding .rlinq file. - Ria Wizard - select one .rlinq file and click Finish. You will see that 'Enable Client Access' will be added in front of the class never mind that you have not checked it.
• LINQ: Incorrect detection of projectable types affecting PersistentCapables that implement IList,IEnumerable,ICollection interfaces - When a PC type also implements the IEnumerable interface, it might not be handled correctly when a field of such a type is projected in Select().
• LINQ: Potentially wrong execution order of client side sub-queries in projections - When a LINQ query contains a projection (Select()) that involves a second, separate, client side executed LINQ query, the inner LINQ query must be executed immediately when the outer query is enumerated, because the inner query might reference outer query results.
• LINQ: Handling of value typed client side executed methods wrong, leading to exceptions during lambda.Compile() for projections - When a client side method is invoked during projection of a LINQ expression, the handling of the return type was wrong for value types.
• Runtime: Order of extents influences the joins generated - When a LINQ (or OQL) expression is processed, the order in which extents are joined is of important and wrong joins can be generated.
• LINQ: Filtering on bool? persistent fields can generate non-compilable SQL - When a persistent field is of type bool? is accessed in a non-projection expression, the generated SQL can be non-compilable.
• The namespace of the generated VB.NET classes depends on the active project - The namespace of the VB classes generated by the visual designer depends on the currently selected project in the Solution Explorer. If the active project is not the one containing the domain model, the classes are nested in an additional namespace.
• Runtime: The Highlow key generator generates wrong identity values when the identity field is of type 'long' - The Highlow key generator generates unique primary key values, of type 'int', for each new row added. If the identity field is of type' long' this causes the value to get wrapped to an 'int' resulting in unexpected behavior.
• Root Namespace in Visual Basic is not correctly resolved if a project different to the one containing the .rlinq file is selected. - Root Namespace in Visual Basic is not correctly resolved if a project different to the one containing the .rlinq file is selected. This is an option in VS2010 that allows you to select a different project in the Solution Explorer while generating the code(saving) the rliqn file.
• ProjectTemplate: Missing app.config file for the VisualBasic FluentLibrary. - The generated FluentContext should have "mssql" as its backend and not "msqsql". An application configuration file should also be included.
• Fluent: Extending models does not handle Turkish I operations - When a property is updated with the name for example Id, the Turkish I consideration is not taken into account and the field name is updated from 'id' to 'ıd'.
  The issue can also occur when two MappingConfiguration are added to a mapping source that define the same type. (This should not be allowed).
• Oracle: Migrating a VARCHAR2 column to a NUMBER column fails with an error - ORA-00911: invalid character - Migrating a VARCHAR2 column to a NUMBER columns fails. Assume a 'string' field mapped to a VARCHAR2 column is replaced by an 'int' field that maps to the same column. When the schema migration mechanism is used to migrate the existing table for this new configuration, the generated script attempts to convert the VARCHAR2 column to a NUMBER column keeping the data intact (by converting it appropriately). On executing the generated script an error is reported. ORA-00911: invalid character
• ADS: Migrating a nullable VarChar column to an non-nullable Integer column generates incorrect default value. - Migrating a VarChar column to an Integer columns fails. Assume a 'string' field, mapped to a VarChar column, is replaced by an 'int' field that maps to the same column. When the schema migration mechanism is used to migrate the existing table for this new configuration, the generated script attempts to convert the nullable VarChar column to a non-nullable Integer column keeping the data intact (by converting it appropriately). The generated script tries to assign a default value - 0, to all columns that have a null value. This default is not compatible with the column type and hence an error is generated.
• SQLite: Migrating a table with column changes fails with a syntax error in the generated migration script - When the database is migrated (using the VSchema tool or the schema handler API) in order to accommodate a change in the column definition , the generated migration script fails with a syntax error. For example migrating a nullable integer column to a non-nullable integer column fails.
• MySql: Migrating a column from nullable to non-nullable fails with a data truncation error - Migrating a nullable column to a non-nullable column fails with a data truncation error. The migration script does not generate appropriate default values for columns with a NULL value.
• PostgreSql: Migrating a column from nullable to non-nullable fails with error 23502: column "columname" contains null values - PostgreSql: Migrating a column from nullable to non-nullable fails with error 23502 - column "columnName" contains null values. The migration script generated attempts to alter the column and sets the column to 'NOT NULL'. If there are any null values an error is generated since no default value is assigned prior to making the column NOT NULL
• Inserting a new object that has a reference to a persistent 'readonly' object throws InvalidOperationException. - Inserting a new object that has a reference to a persistent 'readonly' object throws InvalidOperationException. The correct behavior is to throw an exception in case the readonly object is a new object. However in the case where the readonly object is already persistent e.g. read from the database, we should insert the readwrite object without problems.
• SqlAnywhere: Migrating a column from nullable to non-nullable fails with an error - SqlAnywhere: Migrating a column from nullable to non-nullable fails with an exception - Column 'columnname' in table 'tablename' cannot be NULL
  The migration script generated attempts to alter the column and sets the column to 'NOT NULL'. If there are any null values an error is generated since no default value is assigned prior to making the column NOT NULL
• Second Level Cache Metrics are not calculated - With a regression in the 2011 Q2 release, the metric information about the second level cache are not stored any longer.
• When you click 'Clear Profiler Window' the values in the 'x' axis will stay. - When you click 'Clear Profiler Window' everything should be cleared (deleted). At the moment the values in the 'x' axis will stay.
• Oracle: Migrating a character column to a CLOB or NCLOB column fails with an error - ORA-22858: invalid alteration of datatype - Migrating a character column to a CLOB or NCLOB column fails with the error - ORA-22858: invalid alteration of datatype. The migration script generated tries to modify the column type to NCLOB/CLOB via the 'ALTER TABLE' statement. Changing the data type of a column to a LOB type (CLOB,NCLOB etc) via the 'ALTER TABLE [table] MODIFY [column]' syntax is not supported. A temporary table needs to be created in order to migrate the column to CLOB or NCLOB.
• Postgres: Generation of constraints are not delimited. - If OpenAccess creates the ddl script for PostGres, the constraint names are not delimited. This can result in unnecessary schema update scripts.
• ADS: Migrating a nullable timestamp column to an non-nullable timestamp column generates incorrect default value. - ADS:  Migrating a nullable timestamp column to an non-nullable timestamp column generates incorrect default value. The migration script generates a space (' ') as the default value which cannot be converted to a timestamp value. The migration script now generates a call to the 'NOW( )' server method that returns the current date and time on the server.
• Update Database from Model wizard doesn’t generated code for indexes, stored procedures and constraints. If you have added association between classes or add stored procedures in the model and execute ‘Update Database from Model’ wizard you will see that no code is generated for indexes, stored procedures and constraints.
• Update Database from Model and Update from Database wizards serialized the connection string in Empty Domain Model. If you add connection string through Update Database from Model or Update from Database wizards in Empty Domain Model, it is serialized now.
• Update from Database wizard doesn’t add in the designer table which is a join table between three tables. - When a table has references to three tables and it is a valid join table for all of them, “Update from Database’ wizard does not add it to the domain model.
• Association editor fields are reset when you close it without opening the “Relation View” tab. - If you open the Association editor and fill all fields when you click ‘OK’ button you will see that all fields will be reset and you cannot add the association.

Enhancements

• The OpenAccess project templates are now available for .NET 3.5. - The following project templates are now available in Visual Studio 2010 for creating projects that target the .NET 3.5 framework:
  - Telerik OpenAccess Fluent Library
  - Telerik OpenAccess Class Library

Fixes

• Fluent Mapping: Generated column names are incorrectly calculated based on field and not property names. - When using auto-implemented properties, the column name is incorrectly calculated based on the backing field name and not on the property name.
  If a property is defined like 'public string Name { get; set; }' it should have a column named "Name" and not the autogenerated backing field name.
• Fluent Mapping: A Many-to-Many relationship mapped using 'MapJoinTable(TableName)' now always takes the table name into account - Mapping many-to-many associations using the string overload with a table name depended on the order the mapping configurations were added in the FluentMetadataSource's prepare mappings overload.
• Fluent Mapping: Many-to-many associations defined with 'MapJoinTable(...)' do not create the correct schema. - When defining associations using 'MapJoinTable(...)' the settings provided are now taken into account and the association is not calculated by the runtime.
• Attribute Mapping: Foreign Key Associations are not correctly resolved when attributes mapping is used. - If attributes mapping is used, the runtime is always creating default foreign key columns. The shared field information that was previously missing is now correctly stored in the attributes.
• Attribute Mapping: Custom discriminator columns are not handled by the attributes mapping - If the domain model contains an inheritance hierarchy where custom discriminator columns are used (named differently than "voa_class"), the information is lost, as it is not persisted in the generated attributes.
• Runtime: Version field not updated after Flush - With the changes in the Flush() implementation, the changed objects were not reloading any data. The server side calculated values and the version field are now updated.
• Runtime: Using FetchStrategy for collections properties on a class with a composite primary key leads to exception - When a FetchStrategy includes a collection where the primary key of the owner class is composite, a NotSupportedException is thrown when the data is fetched.
• Runtime: FieldAlias or Storage attribute not resolved when applied to a non-public interface property implementation - When an interface-declared property is implemented non-public in a persistent class, a FieldAlias or Storage attribute is ignored, and LINQ/OQL queries will not find the respective field, throwing an exception.
• Runtime: Database open can throw ArgumentException - If the customer application catches an exception that the database cannot be opened but continues to use the context, an 'An item with the same key has already been added.' exception can be thrown.
• ADS: Constraint and Index generation failed for composite keys - When composite keys are used, the index that backs a foreign constraint was not created correctly.
• LINQ: Using custom collections and .Count / Enumerable.Count() can generate exceptions during translation to SQL - When a custom collection is used as a return type of an aliased property, and the .Count property or Enumerable.Count() extension method is used in a LINQ expression, an IndexOutOfRange exception can be generated.
• LINQ: InvalidCastException can be thrown when database delivers value that is not IConvertible but result expects different type - When the database delivers a type like SqlDouble, the conversion to an int can fail. Usually this is the result of a cast the was not pushed to the server side; e.g. (int)x.STDistance(y). The int cast is not pushed to the server, but an int is expected by the client and the conversion of the delivered SqlDouble value fails.
• LINQ: Using enumerable parameters that do not implement ICollection fails with ArgumentOutOfRangeException (Wrong type of instance, expected ...) - When a collection of values is used with Enumerable.Contains<X>(this source, X x), the input parameter of the actual query execution is checked as ICollection, not as IEnumerable. Parameter values that do not implement ICollection can lead to an ArgumentOutOfRangeException. This can happen for results of Enumerable.Where and Enumerable.Select calls, because they do not implement ICollection.
• LINQ: Improved handling of Cast() expressions - When a LINQ query that looks like
  from Person p in Scope.Extent<Person>() where p.Spouse.Name == "John" select p;
  is used, the superfluous Person type specification leads to a Cast<Person>() expression being generated that will currently force the transition to an in-memory execution, that can lead to a null reference exception.
• LINQ: Exception thrown when client side boolean equality condition is pushed to the server - When a client side calculable boolean equality condition is pushed to the server, an exception ("Directly parameterized literal boolean eq/neq expression found; use integer type here.") can be thrown during translation of LINQ to SQL.
  Example:
  bool withAge = true;
  var q = from x in context.Persons where x.Age > 42 && withAge == true select x;

Enhancements

• Visual Designer: Batch Operations Dialog - The users are now able to perform refactoring operations on multiple items from a domain model. For example, classes or properties can be renamed with a single operation. Changing the most commonly used properties of classes and members like Namespace, Key Generator, CLR type, etc. is also possible in an automated manner. Additional search functionality has been implemented to allow quick filtering and location of domain model items. Support for easily renaming classes and properties in a grid like manner is also added.
• Visual Designer: Support for fluent mapping code generation has been added for the Visual Designer. - Fluent mapping has been added as the third option for mapping definition with the Visual Designer, besides Xml and Attributes. The existing template for fluent mapping code generation used by the "Upgrade to Domain Model" Wizard, has been re-used in the Visual Designer.
• Context API enhancements - The OpenAccessContext did not expose certain functionality that is available via the IObjectScope interface and via the Database class. This includes operations like flushing a transaction, explicitly beginning and committing a transaction, evicting that L2 cache etc. All such relevant functionality has been exposed via the OpenAccessContext.
  
  • context.FlushChanges()
  • context.Events...
  • context.GetState(customer)
  • context.DisposeDatabase()
  • context.ReadOnly = true;
  • context.HasChanges
  • context.Cache...
  • context.LevelTwoCache...
• Profiler: Save functionality for live data profiling. - A user is now able to store his profiling session and open it for review later.
• Project Template: The Fluent Class Library templates should contain code that can update a database schema - The sample context that is generated is now enhanced with common code for creating and updating a database schema.
• NuGet: The sample package should contain code that can update a database schema - The sample context that is generated is now enhanced with common code for creating and updating a database schema.
• LINQ: Support for FetchStrategy settings per LINQ query - When a LINQ query is executed, a FetchStrategy can now be set by the user.
  Previously, the context instance has a FetchStrategy, but this strategy can now be overridden on a per-query base.
  Example:
  var q = context.GetAll<Northwind.Order>().Include(p => p.OrderDetails).Where(m => m.Id == 10249 || m.Id == 10250).Take(3);
  var q = context.GetAll<Node>().Include(e => e.Parent.Parent.Parent.Parent.Parent.Parent.Parent);
  var q = context.GetAll<Node>().Include(e => e.Children.Select(f => f.Children.Select(g => g.Children.Select(h => h.Children.Select(i => i.Children)))))
• LINQ: Support for IQueryable<InterfaceType> added for right sides of Queryable.Join() - When a class Product implements an interface IProduct, an extent of that class (like context.AllProducts) can be used as IQueryable<IProduct> by calling context.AllProducts.OfType<IProduct>(). LINQ expressions can then be formulated with the properties that the interface provides. Support has been added so that an IQueryable<IProduct> can be used as the joined (right side of a Queryable.Join()) expression:
  from od in context.AllOrderItems.OfType<IOrderItem>()
  join p in context.AllProducts.OfType<IProduct>()
  on od.ProductId equals p.ProductId
  select new { ... }
• Runtime: Background Threads error handling - OpenAccess executes background threads for level 2 cache synchronization, storing log files and closing busy connections. Those threads were not writing all errors or exceptions they get into log files. This used to make it hard to understand how OpenAccess works and had to be changed.
  Whenever an error occurs in such a thread, this error can be ignored if necessary to not stop the application execution but is now reported with the actual enabled log mechanism(s).
  To detect that those threads are running and with which setup, the start of all threads should be reported in logging mode 'Verbose'.
• Runtime: Support for logging events in the Windows Application Event Log - Errors can be logged now into the Windows Application Event Log. You have to turn on this feature using the backend configuration:
  be.Logging.LogErrorsToApplicationEventLog = true;
• Schema Read: Performance improvements for the schema read process - The performance for the schema read process is now improved. Now it is using optimal and minimum amount of queries to obtain required schema metadata information.
• Stored Procedure support: Oracle stored procedures that return result sets can now be executed via a generated domain method. - The 'Stored Procedure Editor' provides the ability to generate a method, in the context class, for a stored procedure in order to execute it. If a stored procedure returns a result set(s) the editor can be used to create a CLR type with properties that map to the columns returned in the result set.
  Oracle stored procedures return result set(s) via an output REF CURSOR parameter. It is now possible to obtain the result set shape for such stored procedures and map them to existing persistent type(s) or generate a new CLR type to hold the result set.
• Generic Data Access: A new extension method has been provided method for setting field values for persistent objects - Provide a SetFieldValue<T> extension method that can be used for setting field values. Together with the FieldValue<T> extension method it is now much easier to work with artificial fields.
• Fluent: Support for defining relational items for artificial associations - Support has been added for defining relational items for one-to-many and many-to-many artificial associations. The .ToColumn() and .MapJoinTable(...) can now be used after specifying an artificial association.
• Fluent: Support for specifying indexes over columns in a base horizontally mapped class. - An index can be defined over all properties in a horizontally mapped class as they are all stored in a single table, currently this is not possible through the HasIndex API.
• Fluent: Support for specifying the field name of dictionary and array properties - The .HasFieldName(string) overload has been added for properties of type Dictionary<TKey, TValue> and Array properties.
• Fluent: Using IsVersion() or HasVersion(...) should automatically set the concurrency control to Version. - When either HasVersion or IsVersion is used in the mapping configuration of a type, the Fluent Mapping API now automatically infers that the concurrency control is set to Version.
• Installer: A new Getting Started guide added to the installer - A new Getting Started guide is added to the installer and a shortcut for it is placed in the start menu.
• SDK New Example: Data Binding with OpenAccessLinqDataSource - The old OpenAccessDataSource example is replaced by a new OpenAccessLinqDataSource example, presenting RAD data binding using the new LINQ-based OpenAccess component.
• SDK New Example: Kendo UI integration with a WCF Data Service - A new example is added to demonstrate the integration between Telerik OpenAccess ORM and Kendo UI. The example is based on a WCF Data Service that exposes the entities using JSON and provides support for JSONP. The Data Service is consumed by a Kendo Data Source, presenting data in a Kendo Grid.
• SDK New Example: Sofia Car Rental MVC3 Razor with Fluent Mapping - A new Sofia Car Rental MVC 3 example is added to the SDK, presenting a full blown ASP.NET MVC 3 (using the Razor view engine) application developed to show the best practices in implementing MVC applications using the Fluent Mapping approach.
• SDK New Example: Sofia Car Rental MVC3 Web Forms with Domain Model - A new Sofia Car Rental MVC 3 example is added to the SDK, presenting a full blown ASP.NET MVC 3 (using the old Web Forms) view engine application developed to show the best practices in implementing MVC applications using the Database-First mapping approach.
• SDK New Example: Sofia Car Rental MVP - A new ASP.NET example is added, demonstrating the best practices for integrating OpenAccess ORM in Web Forms MVP applications.
• SDK New Example: Managing OpenAccess Context - The two best practices examples for context handling in a web environment have been improved and merged into one.
• SDK: Sofia Car Rental Web site sample is enabled for profiling - The SofiaCarRental Web Site application is configured to support online profiling.
• SDK: Sofia Car Rental Win Forms Sample is improved - The "SofiaCarRental - WCF Plain Services with WinForms" example is updated. It uses the latest version of the RadControls for WinForms. The example is refactored to follow the design principle of loose coupling. In addition, there is an entirely new Data Access Layer that uses our best practices in dealing with WCF services, i.e. UnitOfWork, DTOs, Assemblers and Repositories. The presentation logic and the data access layer are fully covered by unit tests.

Fixes

• ADO API: Execute Scalar method throws cast exception - When the OADataReader returned DBNull as result the ExecuteScalar method was unable to cast it and a CastException was thrown.
• Association Editor: Pluralization issue with navigation property names in many-to-many associations. - When a many-to-many association is configured in the relational view, the property name of the source end was in singular form instead of plural.
• Association Editor: A validation error was incorrectly shown when there was a mismatch between the nullability of the foreign key and identity column. - Validation error was thrown in case a user tried to add an association between two classes where the foreign key column is nullable and the primary key column is not nullable. This is a valid scenario and the validation has been improved for such cases.
• Association Editor - when 'Target End' is unchecked the validation for its name was still executed. - Association Editor - Object View: typing incorrect symbols like '@#$%^ in Target End TextBox resulted with an error indicator. Unchecking 'Target End' did not remove the validation error indicator.
• Association Editor: When the association name is edited and the target (or source) table is modified, the association name will be reset. - The user input for the association name now prevails over the calculation that occur when the target or source class or table is changed.
• Attributes Mapping: NullReferenceExpection can be thrown when an internal property is added in a partial class of the generated context. - The AttributesMetadataSource can now handle customizations made to the generated OpenAccess context by the users.
• Cannot generate a service in a web application that contains a packages.config - The packages.config file that is used by NuGet was picked up as a regular configuration file by the new "Generate OpenAccess Data Service..." wizard which lead to an exception in the generation step of the wizard.
• Code generation: Using (Imports) directives are not always generated properly when generating code into a single file. - The default namespace is not included in the generated using (Imports) directives when the code is generated in a single file. This may lead to unresolved type errors for classes in a non-default namespace.
• Context: Wrong values reported by ContextChanges.GetInserts() when adding and deleting the same data within the same context. - Following the change tracking example in the documentation http://www.telerik.com/help/openaccess-orm/openaccess-tasks-working-with-objects-get-changes.html, the Telerik.OpenAccess.ContextChanges.GetInserts() method reports 2 objects to be inserted. Since they are also deleted within the same context instance, the count of the inserted objects should be 0.
• Convert To Domain Model: Converting a model that contains base classes from another assembly fails. - This exception was thrown due to the fact that the wizard lacked assembly resolution mechanisms and could only load the needed assembly if it is in the GAC.
• Entities not shown in the RIA wizard when the default namespace is changed. - When changing the default namespace of one Domain Model it is possible that the entities that remain in the "old" default namespace will not show up in the RIA wizard.
• Fluent Code Generation: Generation of property configurations for Enum properties results in uncompilable code for Visual Basic. - Calls to generic methods in Visual Basic are now generated with explicit casts, this has resolved issues related to method overload resolution for HasProperty(...).
• Fluent: HasConstraint expressions not resolved when the compared types are mismatched. - When using expressions like .HasConstraint( (x, y) => x.ShortProperty == y.NullableShortProperty) could not be parsed due to multiple convert expressions being constructed.
• Fluent: If the first non-horizontal class in an hierarchy is marked as either Flat or Vertical derived properties mapping can be lost. - The mapping information for a class marked with Flat and Vertical that is also the first non-horizontal class in an hierarchy can be lost.
• Fluent: ReferenceID values are now correctly produced - If a reference is not mapped additionally by a shared field, the underlying id value is not read as part of the default fetch query.
• Fluent: Specifying a custom TypeConverter for a DateTime or string field via the 'WithConverter<T>' method throws a TypeLoadException - Using the Fluent API a custom type converter implementation can be used for a primitive member of a persistent type. This converter can be set via the 'WithConverter<T>' method of the DateTimePropertyConfiguration or StringPropertyConfiguration type. If a converter is set a type load exception with the following message, is thrown. - 'Could not load type <T> from assembly 'Telerik.OpenAccess.Runtime'"}'
• Fluent: Specifying HasLength(0) results in null length in the produced MetaColumn - Specifying HasLength(0) is a valid scenario and should produce a Length of 0 in the MetaColumn.
• Fluent: Support for navigation properties of type TrackedList - If the model contains TrackedList<T> as persistent collections, the fluent mapping could not be used. Null reference exceptions were thrown if such a mapping was specified.
• Fluent: Two sided arterial associations defined on a non-artificial type not working - When defining an association using HasArtificialAssociation(string, Type).WithOpposite(string) on a type that is not persistent the enhancer used to throw a FieldNotFoundException.
• Fluent: Constraint names not generated properly for associations between the same two classes - When two associations are defined between the two classes (for example Order and Customer) using the HasConstraint((x, y) => x.CustomerId == y.Id) a single association was created with name FK_Orders_Customers instead of two.
• LINQ: Comparison of reference type parameter with null in the filter condition can throw an exception - When a reference type parameter is compared with null (or null is on the right side), the client side calculation used to throw an exception.
  Workaround: Rather with null, compare with a new object instance, which will also produce false when evaluated on client side.
• LINQ: Conditions on joined extents can throw exception during compilation under specific circumstances - When a condition is placed on a joined extent iterator and that condition is translated with a copy of the internal query representation for that iterator, there might be an exception 'Invalid subquery' or invalid SQL is generated ('multi-part identifier could not be bound').
• LINQ: Handling of entity.boolField.Equals(boolValue) not equivalent to entity.boolField == boolValue, failing with invalid SQL - When entity.boolField.Equals(boolValue) is used, incorrect SQL is produced.
  Workaround: Use entity.boolField == boolValue instead.
• LINQ: Improved support for the let keyword - Support for the let keyword has been improved so that normal use cases are handled.
• LINQ: Intermediate simple interface cast not working, leading to an exception - When a persistent class queryable is cast to an implemented interface, an exception occurred during query compilation.
  Example: context.Persons.Cast<IPerson>().Where(p => p.Age > 42).ToList();
• LINQ: Join on an already joined/grouped/projected right side not detected correctly, leading to InvalidOperationException - When a non-trivial right (already grouped,joined,projected) side has to be joined, the join must happen in memory. The transition was not correctly detected, leading to InvalidOperationExceptions.
• LINQ: Multiple conditions in a where clause are now working when using properties of other objects as filtering conditions - A sample of a non-working query:
  Employee emp = new Employee { FirstName = "Nancy", LastName = "Davolio" };
  Employee employee = context.Employees.Where(e=>emp.FirstName.Equals(e.FirstName) && emp.LastName.Equals(e.LastName)).FirstOrDefault();
  As Workaround use:
  Employee emp = new Employee { FirstName = "Nancy", LastName = "Davolio" };
  string fName = emp.FirstName;
  string lName = emp.LastName;
  Employee employee = context.Employees.Where(e=>fName.Equals(e.FirstName) && lName.Equals(e.LastName)).FirstOrDefault();
• LINQ: Projection of referenced nullable base type fields can yield default value instead of null - When a projection is made like 'from x in context.Employees select { a = x.ReportsToID, b = (int?)x.ReportsTo.ID }', the result can contain different values for a and b: a = null and b = 0.
  Workaround: Use 'from x in context.Employees select { a = x.ReportsToID, b = (x.ReportsTo == null ? null : (int?)x.ReportsTo.ID) }'
• LINQ: Resolution of lambda parameters can fail with ArgumentOutOfRangeException when same source expression is used a second time in the LINQ expression tree. - When a common IQueryable<T> is used a second time in the same LINQ expression tree and this queryable has a condition specified, the same parameter expression instance is used a second time, leading to an inner exception that is potentially hidden by an outer StackUnderflowException.
  Workaround: Avoid using the exact same source (with conditions) a second time. Express the same condition a second time with a differently named parameter expression.
• LINQ: Sum of Sums statements are now working properly - LINQ queries that contain sum of sums aggregates are now working as expected.
• LINQ: Using an already joined and projected iterator can lead to exceptions during compilation of the query - When the right side of a LINQ Join() is already a projected join a NotSupportedException can be thrown.
• LINQ: Using nested Any() expressions can lead to exception when SQL is generated - When an expression of kind context.Customers.Where(o => !o.Orders.Any(d => d.OrderDetails.Any())).OrderBy(c => c.Id).Select(c => c.Id); is encountered, the handling of the inner sub-expression can yield an exception.
• LINQ: When OfType<X>() is used, the following expression parts cannot resolve the new type X which can lead to exceptions when accessing X fields. - When an expression like ctx.Persons.Where(p => p.Age > 20).OfType<Student>().Where(s => s.Grade == 'A') is given, the resolution of Grade will fail.
• LINQ: When Take()/Skip() comes before Select(), the resulting query is not paged - When Take() or Skip() is written before Select(), the resulting SQL is not taking the paging into account, potentially delivering more than expected.
  Workaround: Perform Select() before Take() or Skip().
• LINQ: When using .NET 3.5, intermediate anonymous type members and properties are represented by their getter. This can lead to wrong SQL compilations or compilation errors for unresolvable FieldAliases - When an anonymous type is generated (for example during projection of src1.Join(src2, keySel1, keySel2, (a,b) => new { a,b })), the members of the anonymous type are represented by their getters in 3.5, but .NET 4.0 uses PropertyInfo instances. This can lead to the situation where the wrong member is chosen for further processing, causing wrongly generated SQL or (more likely) non-compilable LINQ ('FieldAlias not found').
• LINQ: Intermediate simple interface cast can lead to an exception - When queryable of a persistent type is casted to an implemented interface, an exception occurs during query compilation.
  Example: context.Persons.Cast<IPerson>().Where(p => p.Age > 42).ToList();
• Model Details Editor - Inheritance mappings: Discriminator column was set to <None> by default when Vertical Inheritance is defined, but a default discriminator column was actually created in the database schema. - When Vertical Inheritance is defined, the default selected value in the Discriminator Column combo-box was <None>, indicating that no discriminator column will be created for this hierarchy in the database. The runtime however was creating a voa_class column, which is the default behavior for any inheritance mapping. If a user does not want a discriminator column in the database, the <None> option should be explicitly selected. When the inheritance is created however, there is now an additional setting <Default> which indicates that a default voa_class column will be created by the runtime for this inheritance strategy.
• ObjectNetworkAttacher does not work with new mappings - If the ObjectNetworkAttacher was used with fluent mapping or rlinq file, all persistent types were not detected and an exception is thrown. The ObjectNetworkAttacher can now be used in a context by adding these method to the context class:
  public object Attach(object objectToAttach)
  {
  return ObjectNetworkAttacher.AttachXML(GetScope(), objectToAttach);
  }
  The ObjectNetworkAttacher source (found in the OpenAccess \src directory) must be included as well.
• ODataService: SQL generation error when more than one condition is given in a filter - When a filter condition consists of more than one part (in other words, an AND or OR was used), the generated SQL was not executable on the database server.
• OpenAccessContextBase.Translate<T> does not reliably detect an already closed DbDataReader - The OpenAccessContextBase.Translate<T>(DbDataReader reader) returns a lazily evaluated IEnumerable<T>. When an actual enumerator is requested, the reader can be already closed. This circumstance is now reliably detected and an exception is thrown.
• PostgreSQL: Reading the database schema can fail with duplicate key exception - Reading the database schema for a PostgreSQL database can fail with a duplicate key exception. It happens if unnamed stored procedure parameters are used.
• Runtime: Base table join missing in some case of vertically inheritance - If a class hierarchy is mapped vertically and the base type field under a reference is located on the base class, the join to the base table was missing. The result is an invalid SQL statement.
• Runtime: Invalid parse of a Scope.GetSqlQuery when the query starts with a new line - When calling the Scope.GetSqlQuery method with a SQL that has a carriage return before the word select, we assume that we have a stored procedure, which will cause the fail of a simple select statement.
• Runtime: CLR and ADO type Default Mapping not used - If a special type mapping is defined in the metadata container, this was not used during runtime. Example:
  metadataContainer.DefaultMapping.ClrMap.Add(new Telerik.OpenAccess.Metadata.Relational.DefaultTypeMapping() { ClrType="System.String", AdoType = OpenAccessType.Varchar, SqlType = "nvarchar", UseDefaultMapping=true });
  Workaround: the mapping can be set at each string field directly.
• Runtime: Flush does not update concurrency control information - If an object with concurrency control changed is flushed twice to the database a optimistic concurrency control exception is thrown. This is caused by Flush optimizations. Workaround: Use FlushAndUnmanage() instead of Flush().
• Runtime: Implement a type converter that can write GUIDs always in upper/lowercase - In some situations it might be required to write GUIDs always in upper/lowercase letters to the database. Therefore we created the new converters "String2UpperGuidConverter" and "String2LowerGuidConverter".
• Runtime: Wrong SQL when using string literals with question marks - When string literals are used from LINQ or OQL, and those literals contain question marks, the generated SQL was invalid.
• Runtime: Vertical mapped class hierarchy produces now produces fewer join statements - If a class hierarchy is mapped vertically, a query to a base class contains all joins to all derived classes tables regardless if data from those tables is required. Those joins can now be avoided by removing all derived class fields from the default fetch group or set their load behavior to Lazy.
• Schema Read Oracle: Stored procedure with same name - Oracle can have Stored Procedures with the same name in the same package. OpenAccess could not distinguish between them and creates one procedure that has all parameters.
• Schema Read: Tables or procedures that have the same name as a system schema are not read. - OpenAccess ORM failed to read tables or procedures that have the same name as a system schema. For example: In MS SqlServer if a table has the name 'guest', this table is filtered out while reading the database schema. Such tables are now read successfully.
• Schema Read: Composite foreign key constraints can be unordered - If a foreign key constraint is based on a composite key, the relation between source and target columns can be mismatched.
• SqlServer CE: NullReferenceException thrown when trying to read the schema for a database that is part of a replication setup - If a SqlServer Compact database is part of a replication setup (used to synchronize data between the server and a 'disconnected' device), trying to create a domain model for such a database resulted in an 'Object reference not set to an instance of an object' exception.
• VistaDB: Cannot read schema under Turkish locale - When Turkish locale is set as current locale, the schema read process fails as the ADO driver from VistaDB does a ToUpper internally, giving an exception. VistaDB fixed this issue with VistDB version 4.3.0.27.
• Table editor: The rlinq file is not marked as modified after a new table is added. - After making changes to the domain model via the Table Editor, the rlinq file is now marked as modified and a '*' symbol appears in its name. Otherwise the rlinq file could be closed without persisting the changes to the model.
• Validation: The DSL model not updated when a primitive member is marked as identity by a validation action - When a domain class does not have an identity, the validation dialog shows an error and it is offering an automatic action for resolving the error. After the user chooses a property to become an Identity, executes the action and closes the validation dialog, the change is now shown in the Visual Designer.
• Validation: The validation resolution action for automatic generation of property/field names does not generate unique names. - The resolution actions for automatic generation of property and field names did not take into account whether the suggested name is already used only whether it is a valid identifier. An additional check for the name uniqueness is now performed.
• VistaDB: Cannot read schema under Turkish locale - When Turkish locale is set as current locale, the schema read process fails as the ADO driver from VistaDB does a ToUpper internally, giving an exception. VistaDB fixed this issue with VistDB version 4.3.0.27, please use the newest version.
• Visual Designer: Inheritance between class and interface which have properties with the same name results in uncompilable code. - Inheritance between class and interface which have properties with the same name resulted in uncompilable code. Explicit implementation of the interface property is generated, but there were public and virtual modifiers which are not valid for this scenario. The fields for both properties had the same name as well.
• Visual Designer: Setting IsIdentity to true on an implemented property not reflected on the underlying MetaMember in the metadata model. - Setting IsIdentity=true on an implemented property was not reflected on the underlying MetaMember in the metadata model. The problem was related to the fact that the identity guid from the implemented member was not equal to the identity guid of the meta member. It instead had the identity guid of the actual member in the base class.
• Visual Designer: The AUTOINC key generator is not serialized when the class is using Internal identity mechanism. - The key generator was always deserialized as HighLow when Internal Identity was used, given that that is the default. The KeyGenerator is now correctly serialized and deseriliazed.

Enhancements

• Runtime: Prevent parallel GC beeing triggered by empty connection pool - When the connection pool is empty (all connections are in use), the blocked thread requests a garbage collection. The fix prevents that multiple blocked threads will lead to parallel invocations of System.GC.Collect.
  Workaround: Use a proper setting for the maximum size of the connection pool so that blocking is prevented.
• Batch Operations Dialog: The Change CLR Type operation cannot handle nullable types - The batch operation for members "Change CLR Type" does not provide any means of selecting a nullable type. The user should be able to select a nullable equivalent for all available value types.
• Validation: Usability improvements and fixing visual glitches to the Validation dialog - Numerous improvements to the validation dialog including: validation for NumericUpDown controls, extra validation rules for discriminator columns, better keyboard support, etc.
• Visual Studio Integration: Added new items in Telerik -> OpenAccess -> Help menu. - Added links to the new help sections and the newly shipped 'Getting Started with OpenAccess' pdf guide.
• Association editor: Association mapping can be lost if the columns used are not mapped to primitive members. - Associations that use columns that are not mapped in the model as their foreign keys are now correctly persisted while working with the designer.

Fixes

• Runtime: Potentially invalid handling of managed inverse collections can lead to exceptions and incorrectly set data when detail instance is of derived type - When a managed inverse collection involves a detail type that is not the root of a persistent class hierarchy, but is from a derived persistent class, the changes of the collection need to manage the inverse reference too. This management can fail when the persistent base classes of the detail type have persistent struct fields, artificial fields or other fields that are not directly user visible (e.g. version field).
  The effects can lead to exceptions because the type converter cannot handle incompatible values, or can lead to inconsistently stored data.
• Add New Item Wizard: 'CamelCase' class casing removes underscores from the table names. - Class names generated by OpenAccess now include the underscores from the table name when 'CamelCase' class casing is specified.
• Attributes Mapping: Attributes mapping does not take into account schema names for join tables - The JoinTableAssociationAttribute that defines a join table does not provide a way to specify the schema name of the join table used in a many-to-many association.
• Enhancer: An null reference exception is thrown if an identity member cannot be found. - The enhancer used to throw a null reference exception if the identity or version member specified in the metadata cannot be found.
• Fluent Code Generation: Uncompilable code generated if Generate Context and Generate Multiple Files options are disabled. - The Fluent API namespaces are now added when generating into a single file and with no context.
• Generate OpenAccess Domain Model Service: Resolving contexts can fail in certain isolated scenarios. - The Generate OpenAccess Domain Model Service wizard can now always (given that the solution is built) find the contexts from the solution and list them on the first page.
• LINQ: Ordering by subquery count produces exceptions - When ordering is performed on the result of a sub query aggregate, an exception is thrown.
• LINQ: Invalid SQL generated when translating entity.StringField.Contains("X") == Y - When the string.Contains(string) method is used on a persistent member and the right side is a constant value, the translation of the expression is wrong and invalid SQL.
  Workaround: Use negation or compare to a boolean parameter.
• LINQ: Translation of persistentMember.ToString() leads to potential truncation for string columns - When a varchar(80) column is used in a LINQ expression 'member.ToString() == param', the resulting SQL contains a cast to varchar(60) causing string truncation.
  Workaround: Do not use ToString() on string fields.
• LINQ: Using byte[] parameter leads to interpretation as byte parameter collection instead of single parameter - When a byte[] parameter is used in a LINQ expression, the parameter is interpreted as collection of byte values rather than one value.
• Profiler: Error not shown if the binary event log format is too old. - If a binary event log is produced by an older version of the profiler, the error message was hidden and no events were visible. OpenAccess now shows a proper error so that the user can update the runtime system or downgrade the used profiler.
• Runtime: Invalid conversion of SQL 'exists' nodes can lead to 'Query too complex' exceptions - When a LINQ Any/Contains expression that is transformed into an SQL 'exists' expression is combined with another condition by AND, a 'Query too complex' exception could be thrown.
• Runtime: Ordering by primary keys of joined extents is not working - When a LINQ expression of type srcA.Join(srcB, a => a.Id, b => b.Id, (a,b) => new { a, b }).OrderBy(x => x.a).ThenBy(x => x.b) is given, the ordering of b was not appended to the SQL.
• Runtime: Ordering by reference members not possible - When a LINQ expression is given like 'from p in ctx.Persons order by p.Spouse', the ordering is not appended in the generated SQL.
  Workaround: Use explicitly the id field as in ' from p in ctx.Persons order by p.Spouse.Id'. This will lead to an additional join however.
• Runtime: Shared Column synchronization missing when instance is made persistent by reachability only. - When an instance that has synchronized fields is made persistent by reachability alone (that is, no context.Add/scope.Add was performed explicitly), the field synchronization code is not invoked.
  This can lead to missing references in the database, because the foreign key values that were specified by simple fields will not be taken into account and NULL values are inserted instead.
  Workaround: Either use managed collections or call context.Add() with the instance explicitly.
• Runtime: Projection of references or extents variables with composite foreign keys can lead to missing columns in projections - When a composite foreign key or an extent iterator is projected in a LINQ expression, the resulting SQL select clause can have to few columns, causing errors and exceptions during projection result read operations. This applies only if the foreign key reference itself is projected, not a field of the referenced instance.
• Schema read: A null reference exception is thrown while reading the database schema for Advantage Database Server if the database has indexes defined using a sql expression - An index in Advantage Database Server can be created using a SQL expression which is evaluated by the expression engine to calculate the index column. Such index definitions are not supportd by OpenAccess, at the moment.
  If a database has such an index the schema read process throws a NullReferenceException. This has been fixed to now ignore such indexes.
  Advantage Database Server also allows a user to connect to a database created with a password, without specifying the password. While reading the database schema with such a connection (where no password is specified) a NullReferenceException is thrown.
  The exception is now improved with details about the possible missing password. Specifying a valid username and password fixes the problem.

Enhancements

• Runtime: Support for one-to-one associations - OpenAccess is now able to map one to one associations out of the box.
  Database first scenarios - a 1:1 relationship defined in the database using a foreign key constraint between primary keys of the tables involved is automatically detected and mapped to an appropriate association between the 2 domain classes in the domain model.
  Model first scenarios - creating a 1:1 association between primary key members in the designer generates the appropriate tables and foreign key constraint in the database.
  Limitations in this version:
  - One-ended associations with a navigation member only on the referenced class are not currently supported.
  - Limited support in the Fluent API.
• Visual Studio 2012 RC: Full functional support - Introducing improved project templates for both Web Application and Web Sites, to resemble the newly redesigned ones by Microsoft. Fixed various issues related to integration of OpenAccess in all wizards and dialogs (including the new Add OpenAccess Service wizard, the RIA service generation, the Batch Operations dialog and others).
• Add OpenAccess Service: Various improvements in the wizard UI and code generation assets- Improved overall state of the UI, redesigning the service selection page, added usability improvement to the entities selected, enhanced inline validation. Fixed issues with Rest and Atom services related to entity operations and warnings in generated code. UnitOfWork now properly generated in cases of fluent. Improved support for Visual Studio 2012 (fixed a lot of issues related to the handling of Visual Studio assets).
• Add OpenAccess Service: Enable usage of customized in-project code generation templates - Support for using custom templates in the Add OpenAccess Service wizard has been introduced. One can simple add these templates in a folder named OpenAccessTemplates in the desired project and they will be picked up by the user.
• Add OpenAccess Service: Navigation Properties support and generation - Provided support for navigational properties in the WCF Plain Service code generation of the Add OpenAccess Service wizard. The collections and references are not populated by default, however this can be easily done.
• Add OpenAccess Service: Support for WCF Data Services 5 with OData v3 - Added a new option in the Add OpenAccess Service wizard that allows for easy configuration of an OData v3 enabled service with the WCF Data Services 5 implementation.
• Database Default Values support - Default values defined on the database columns can now be reverse mapped with OpenAccess. All the columns that have a default value are marked with HasDefaultValue=True in the Domain Model. Such columns will be skiped during insert should they have no other value specified.
• Fluent: Enhanced support for defining indexes for various backends - Support for defining sort order on columns has been added to the index functionality exposed by the Fluent Mapping API. This resulted in a breaking change in the object API, more specifically the MetaIndex type.
  Example: classConfiguration.HasIndex()
                          .WithMember(x => x.FirstIndexColumn).Ascending()
                          .WithMember(x => x.SecondIndexColumn).Descending()
                          .WithName("indexName");
• Provide the ability to use autoinc for Oracle and Firebird using triggers and sequences/generators - OpenAccess now provides out-of-the-box support for automatically incremented keys in Oracle and Firebird. The corresponding Identity Mechanism setting on the Domain Class is 'DatabaseServerCalculated'.
• Availability of original values - A new method GetOriginalValue<T>(object persitentObject, string propertyName) has been implemented that allows retrieving of the original value for a property that has been already changed. The original value is now available regardless of its current state (loaded or not). If the value is not loaded an additional trip to the database is done in order to load the value. This method will work for all concurrency control types via the property MaintainOriginalValues available on the context.
• Sequential GUID support - SQL server provides GUIDs as primary keys. Nevertheless not all kinds of GUIDs can be stored without performance overhead. The fastest way is to use server side generated sequential GUIDs. OpenAccess is now able to support primary-key columns that store sequential GUIDs generated by the server. It is now possible to Forward and Reverse map a System.Guid identity field to a 'uniqueidentifier' column where the value is generated on the server and the generated value is successfully retrieved after insert.
• Context Options: Data Synchronization Setting is added - A option has been added that turns off the internal calculation of the following types of members:
  - members for versioning
  - members used as timestamp
  - DateTime members that are marked with AutoSet on Update, Insert or both
  Usage Example:
  context.ContextOptions.EnableDataSynchronization = true;
• Runtime: Detached tracked data - OpenAccess can now detach objects from an active OpenAcess context. Those objects are context independent but nevertheless have change tracking that helps preserve the changes to that object for future use. The detached objects can be used to implement scenarios where the data is needed for a long time while the context and underlying database connection are not. The new DetachCopy method on the context instances will generate self tracking copies of persistent objects that can later be attached with all their changes back to an active context using the AttachCopy method on that context.
  Currently attaching object that are new and not previously detached is not possible, however this will be made available in the upcoming service pack.
• Batch Operation Dialog: Numerous fixes related to search and filter and to available operations- Fixes related to wrongly applied filter conditions, fixes for operations including "Change CLR Type", "Change Cache Strategy" and other visual glitches.
• Convert from Entity Framework (LINQ to SQL) Wizard: Improved support for many-to-many associations- Added improved support for translating many-to-many associations. Fixes issues with generated code in Visual Basic. Various visual glitches fixed.
• Model Settings Dialog: Minor fixes and improvements - Changing the Backend setting now correctly updates the ProviderName. Added missing and improved overall state of tooltips. Fixed dialog behavior when started through the Properties Pane.
• Profiler: Numerous fixes and usability improvements applied to the application - Fixed issue that caused the StackTrace to be always available. Filtering of events used to break navigation back and forth from SQL and Linq events. Fixed issues with sorting and filtering in the grids. Fixes issues causing crashes when loading metrics.
• Update Database From Model: Improved stability and UI fixes- Fixed crashes caused by devArt's MySql driver in the case the trial license has expired. Fixes possible issues when using the wizard with an Oracle backend. Improved validation for the Destination folder control. Fixed issue with Visual Studio 2008 and radio buttons on the first page.
• Validation: Improvements in the validation framework- Overall improvements in validation rules applied to the model. Fixed a couple of visual issues with the validation dialog.
• Association editor: Added support for one-to-one association and improved validation for the wizard- The association editor can now create all kinds of relation including one-to-one (with the exception of a one-to-one association without a source member). Improved validation for the join table combo box control and for association end names in the case of a self-referencing association.
• Stored Procedure Editor: Improvements to the dialog and generated code- Provided support and code generation for Oracle stored procedures that return result sets. Fixed issue with Complex types, that required restart of Visual Studio. Fixed issue with procedures using System.Byte[]. Improved validation rules in the dialog.
• Fluent Code Generation: Numerous fixes and improvements- Provided support for column with the type DateTimeOffSet. Now producing compilable code for char and ulong properties. Fixed issue with concurrency mode Backend and a concurrency member of types Int64 and timestamp . Now properly taking into account the OrderBy clause of navigation members. The generated FluentMetadataSource is now a partial class and only picks up properties generated by the designer and correctly leaves out the ones defined in partial classes.
• Fluent: Support for disabling the resolution of mapping configurations from the assembly - A boolean flag (source.ResolveAssemblyConfigurations) has been added to the FluentMetadataSource that allows for disabling the assembly resolution of MappingConfiguration objects.
• Fluent: Support for extensible compile-time validation for the FluentMetadataSource - An additional build step in the form of a MSBuild task has been added that can execute the validation rules provided the a FluentMetadataSource over its model and report the errors in the error pane.
  Usage: In order to use this functionality one has to override the GetValidationRuleProvide method in their source and provide an additional MSBuild property ValidateMapping that is set to true
• Fluent: Support for multiple Fluent Metadata sources in a single project - Support for enhancement of multiple Fluent Metadata sources in a single project has been added. It is now possible for mapping produced by them to overlap (i.e. classes are mapped in both sources).
• Runtime: Improve handling when wrong type is used while creating a LINQ entry point - When an IQueryable<T> is generated for a type by the user, the type T was not checked until the query is executed. Now the type is checked and an unknown or unenhanced type is reported. This applies also for artificial types, where there is a chance that the types FullName is ambiguous. When there is a difference in the definition of the artificial type, two types will be available at runtime, both potentially having the same full name.
• Runtime: Memory usage optimization - Provided some memory usage optimizations that can improve the overall performance.
• Runtime: Improved performance for all fetch operations - Caused by a potentially inefficient GetHashCode() implementation the first level and the second level cache as well as the fetching code could get inefficient dictionary operations. Most likely this occurred with small integer values. In a specially crafted test case we observed a decreased execution time by 70%.
• Runtime: Improved shared columns functionality - The functionality to work with shared columns has been improved. It is now possible to share a column with one simple field and one or more references (using this column as a foreign key). Reference-reference shared scenarios are possible as well as support for shared columns over class hierarchies.
• Runtime: Metadata update in open database instances - If a module with OpenAccess persistent classes has to be lazily loaded, OpenAccess had no mechanism to add this new metadata to the running application. A smarter startup and module load mechanism is introduced to reduce the startup time and memory consumption during such operations.
• Runtime: Unique Id generation functionality - OpenAccess has the functionality to generate unique values for a persistent objects based on the HIGHLOW key generation algorithm. This functionality was so far used internally, for generation of primary keys of persistent objects. Now the unique id generation functionality is exposed via an API using which unique values can be obtained for any user-specified sequence.
• Data Services: Support for the newly released WCF Data Service 5 with OData v3 - The OpenAccessDataService<T> implementation is now available for WCF Data Services 5 in the Telerik.OpenAccess.DataServices.50 assembly.
• Data Services: OpenAccessDataService does not allow custom service operations - Fixed an issue that prevented users from extending WCF DataServices with additional service operations. Now you can add custom service operations to WCF DataService version 2 and greater.
• LINQ: Support for string.Equals(left,right,comparison) was added - Support for string:Equals(string left, string right, StringComparison comparison) was added.
• LINQ: Incorporate client side support for binary not operation - Included support for client side evaluated binary not operations as in
  int clientValue = 0x1234;
  ctx.Descriptions.Where(d => d.MyIntValue == ~clientValue) ...
  to search for bit-negated values (e.g. the negated value here is 0xFFFFEDCB).
• LINQ: Server side execution of 'System.Linq.Enumerable:Select(IEnumerable`1,Func`2) for persistent collections - Support was added for query expressions involving System.Linq.Enumerable:Select(IEnumerable<T>, Func<T,S>) like
  string m = "France";
  var q = from city in Scope.Extent<Country>()
  where city.Neighbors.Select(x => x.Name).Contains(m)
  from x in city.Subs
  select x.Name;
• SDK: Various improvement and bug fixes to the examples- Small fixes introduced in the Sofia Car Rental Silverlight, ASP.NET MVP and ASP.NET Ajax examples. Added validation to the booking page in the Sofia Car Rental MVC example and to the Data Binding with OpenAccessLinqDataSource example.

Fixes

• ADO API: Executing a stored procedure throws security exception under medium trust if the DbType of the OAParameter is not set explicitly. - A stored procedure with a parameter that does not have its DbType explicitly defined used to throw security exceptions due to a ComposableType implementation that demands Full trust.
• ADO API: The OAConnection.StoreConnection.StateChange event not fired - The OAConnection.StoreConnection.StateChange event was not fired when the connection state changes. The 'StoreConnection' property now returns the underlying ADO connection instead of a wrapped LoggingDbConnection instance.
• Attributes Mapping: If there is no explicit table defined for an entity, it was not consider a part of the model in runtime - In case there is no explicit table defined for an entity, it was not considered at all in runtime. This has been fixed and tables for such entities are now auto-generated as expected.
• Backend Configuration: Support for xml based configuration of the BackendConfiguration - Provided support for merging backend configuration settings from an xml file in addition to currently available object API. This allows for easily reconfiguring important settings such as logging, caching, etc.
• Backend Configuration: Improved exception in the case the configuration section is not found - In case where a user would merge the backend configuration from the app.config (or web.config) and there is no 'openAccessConfiguration' section present in the configuration file, a NullReferenceException was being thrown. The correct exception in this case is the ConfigurationException.
• DataServices: Properties marked as private in the designer are exposed through the service - Non-public properties are now not included in the service metadata, as this used to cause serialization exceptions and a faulty service.
• Enhancer: The enhanced assembly damaged if persistent field is passed by ref into a generic method - If a persistent field is passed by ref into a generic method and changed inside, the field was not marked as dirty. Whenever the field is passed by ref to a function OpenAccess now marks it as dirty. Additionally the assembly could have contained broken IL code.
• Enhancer: Code coverage results damaged during enhancing - If an enhanced assembly is tested and code coverage is enabled, the method names are modified. That makes it impossible to analyze the coverage results. A new mono cecil version fixes this problem and is now integrated into OpenAccess.
• Enhancer: Delayed signed information is removed - If the key file contains only the public part of the key, the enhancer used to remove the strong name.
• Enhancer: Overriding the enhancer.exe path with relative one results in compile time errors - If a relative path to the enhancer is specified, either in the OpenAccess.targets file or in the project file that includes it, a compilation error was produced stating that the executable cannot be found.
  Workaround: remove the check at the end of the OpenAccess.targets file.
• FetchPlan: Potential wrong evaluation of fetch plans when explicit path includes were used - When the FetchPlan includes an explicit path, this non-associative part could have been potentially undetected due to an internal set issue if given as the last element in the fetch plan groups.
• Fluent: Configuration for array properties not taken into account during schema creation - Specific configurations for array properties are now respected when generating schema.
• Fluent: Creating a model can throw a comparer exception in .NET 4.5 - The FluentMetadataSource used to crash in certain configurations when used in .NET 4.5.
• Fluent: Order of properties used in a MapJoinTable(string, Expression) sometimes not respected. - The order of the properties passed in the expression that defines the columns in a JoinTable is sometimes not respected.
• Fluent: Using HasField resulted in lost properties mapping in the case of Vertical or Flat inheritance. - Using HasField both in the base in derived classes of either a Vertical or Flat inheritance resulted in the properties mapped in the derived classes to not be skipped.
• Fluent: Configuration for array properties not taken into account during schema creation - Specific configurations for array properties are now respected when generating schema.
• LINQ: Incomplete detection of client side evaluatable enumerable methods. - Enumerable methods that can be evaluated completely on the client were not reliably detected, leading to 'XXX on the database server side currently not implemented' exceptions.
• LINQ: InvocationExpression not handled properly, leading to exceptions - When an InvocationExpression is used in a LINQ query, the handling of the parameters was not correct, leading to exceptions like ArgumentOutOfRangeException.
• LINQ: Calling ToString() on value types on the server leads to wrong SQL generation - When an expression of kind 'from x in context.X where x.avalue.ToString() == param select x' is given, the translation of the ToString() on the database server has regressed for MSSQL so that invalid SQL is produced.
  Workaround: If possible, use the real type in the param, not a string.
• LINQ: Conditions not working on collection items from a SelectMany result - When a LINQ expression similar to .SelectMany(x => x.Details).SingleOrDefault(det => det.Prop == param) is made where the result of a SelectMany is further filtered, an exception is thrown during translation to SQL.
• LINQ: Ordering on grouped queryables leading to exception - When a grouped queryable is ordered, the ordering conditions can not include anything but the grouping key, otherwise an exception was thrown.
  Hint: It is currently not possible to efficiently handle grouped and then ordered queryable, although the LINQ syntax allows this. On a relational server, the ordering can at most include the projected columns, thus the key of the grouping. If some other ordering condition is given (like a field when the grouping key was a reference), the relational server will need to be accessed again. This leads to 1+n+n queries.
• LINQ: Support for base Enumerable.Contains(value) as needed for array handling - When a base type array is used as a persistent field like Guid [] pc.myGuids, expressions like .Where(pc => ((IEnumerable<Guid>)pc.myGuids).Contains(new Guid("abc-def"))) are now allowed.
  Workaround: Use IList<Guid> instead as the persistent class field type.
• MSSQL: If a table has a database generated primary key (IDENTITY column) and also a trigger then inserting into this table resulted in an exception. - In SqlServer if a table has a database generated primary key (IDENTITY column or uniqueidentifier column with newsequentialguid() as the default value) and also an enabled trigger then inserting into this table resulted in an exception with the message - "The target table 'tableName' of the DML statement cannot have any enabled triggers if the statement contains an OUTPUT clause without INTO clause."
• MSSQL: Schema Read: Unable to resolve the 'identity' setting for a column in a table with a schema name that contains a dot (.) - In Ms SqlServer, if a schema name contains a dot (.) then the 'Identity' setting for column(s) within tables in this schema was not read.
• MySql: Custom builds of MySql not supported - If the OpenAccess Free Edition is used with a MySql server that was build from the downloaded sources, an Exception of type Telerik.OpenAccess.Exceptions.LicensingException was thrown. Workaround is to use a pre-build MySql versions from the community page.
• OpenAccessLinqDataSource: Update fails when one of the properties of the updated object is read-only - In case the updated object, has one or more properties that are not updateable, the OpenAccessLinqDataSource tried to insert null for the value of those properties when Update operation is executed. The correct behavior is to preserve the actual value of the updated object instead of overriding it with null.
• PostgreSql: Incorrect migration script generated related to a serial column - If a byte field is mapped to an autoinc column in a Postqres database, an unnecessary schema migration script was being generated.
• PostgreSql: Schema read does not recognize schemas that a user has access to - The schema read process is now able to detect the schemas that a user (who is not owner of the schema) has been given access to.
• Oracle: Reading the 'SYS' schema for Oracle 10 databases could cause an exception - An "Unable to retrieve database schema information" exception was thrown if the SYS schema for Oracle 10 was read.
• L2 Cache cluster: .NET 4.5 installation breaks MSMQ - The OpenAccess cluster synchronization was broken because of a bug in .NET 4.5 that replaces the .NET 4.0 System.Message dll.
• Runtime: Damaged SQL prepared statements - If a SQL statement generation fails during the first parameter generation, it was possible to be reused and cause double parameter exceptions later.
• Runtime: Failing schema read for ADS when using composite function based indexes - The schema read process for ADS databases used to cause an exception when an index is defined that has a function definition for the second or latter columns.
• Runtime: Metadata error during runtime can be hidden - Sometime important metadata errors were being hidden behind a string format exception.
• Runtime: Misconfigured type converter used on the parameter when a comparison was made against a string.ToUpper/ToLower on a persistent field - When a LINQ expression involved something like 'x => x.field.ToLower() == param', the parameters converter was not properly initialized from the fields converter. This can lead to suboptimal performance on Oracle, where indexes are skipped by the query optimizer due to wrong parameter types being used (NVARCHAR2 vs VARCHAR2).
• Runtime: Ordered collections not accessible if empty - Ordered collection that are ordered by a base class field might have thrown a row not found exception if lazily loaded and empty.
• Runtime: Retrieving of an instance can load data that is not in the fetch plan - Retrieve operations could follow additional references, even when they are not in the fetch plan, causing unnecessary server queries.
• Runtime: SqlGeometry forward mapping - if an SqlGeometry type is forward mapped, the default mapping to 'geometry' was not found. This lead to mapping problems.
• Runtime: StoredProcedure generation won't work with inheritance in shared field scenarios - CUD stored procedures generated for derived classes having shared fields caused the generation of duplicate parameters.
• Runtime: Incorrect handling of fixed size character/binary columns - When a char(x) or binary(x) column is used, the contents of the non-first row to be inserted in a commit can be truncated to the length of the value inserted in the first row.
  Workaround: Use varchar instead of char or use the VariableLengthStringConverter.
• Runtime: Using Fetch Strategy on collection fields can lead to invalid collection content to be read - When a collection field is prefetched by a fetch strategy, the collection content can be wrong. This only happens if the FetchStrategy is three levels deep and the second level instance is fetched twice.
• Runtime : Values are inserted in a wrong order in a join table that maintains an m:n collection - An M:N collection is maintained using a join table. If one of the persistent types in an m:n relation has a composite primary key the order in which the values are inserted into the join table is not reliable. This could lead to Foreign Key constraint violations. The order is dependent on the order of the mapping specified for the association, in the association editor.
  This has now been fixed so that the columns are always inserted in the right order.
• Runtime: A one-to-many collection maintained using a 'fake' inverse reference field was not managed even though the 'IsManaged' property for the association is set to true - A 1-n collection can be managed with an inverse reference field which is defined on the "Many" side of the collection. It is possible to have this setup without actually having a field defined on the Many side; in this case OpenAccess would maintain an internal reference to maintain this collection. If the 'IsManaged' property for such a collection is set to 'true' it is ignored by the runtime (unless the field is defined on the Many side).
• Runtime: Concurrent usage of MetadataSource can lead to missing metadata - When a MetadataSource (required to interpret the .rlinq file content at runtime) is used in a concurrent fashion, there is a time window in which threads obtaining metadata can find an empty MetadataContainer instances, thus leading to later exceptions during runtime.
  Workaround: Force the MetadataSource to create it's model from a single-threaded place before an OpenAccessContext is obtained.
• Table editor: Updating tables does not edit the rlinq file explicitly - When a table is edited in the table editor,the rlinq file was not marked as modified(the * sign is not present). In this case, if the user closes the rlinq file, he was not prompted to save it which lead to the changes done in the table editor being lost.
• Upgrade References: The Telerik.OpenAccess.DataServices reference was not updated - The "Upgrade References" command (found in the Telerik -> OpenAccess menu) can now update references to the Telerik.OpenAccess.DataService binary.
• Visual Designer: The 'order-by' attribute in the collection element of the .rlinq file is not deserialized - It is possible to define an ORDER BY clause that will be applied to the query when an inverse collection of an object is being fetched. This ORDER BY clause can't be currently specified via the Visual Designer UI assets, but it can be set manually in the .rlinq xml. When a user manually sets the clause, the value is serialized in the 'order-by' attribute of the 'collection' element, but the value is not deserialized.
• Visual Designer: Keyboard input blocked after executing the Update Database from Model wizard - If the project containing the OpenAccess domain model is bound to TFS and a new DDL script is created via the Update Database from Model wizard, Visual Studio used to display the following message while being closed:
  Microsoft Visual Studio has detected that an operation is blocking user input.  This can be caused by an active modal dialog or a task that needs to block user interaction.  Would you like to shut down anyway?

Enhancements

• Runtime: Attaching new objects - OpenAccess can now attach new objects. These objects can be the result of a deserialization, which makes the detach/attach functionality applicable in N-Tier scenarios.
• Runtime: Improve support for 1:1 associations - One is no longer forced to specify IsRequired() on one of the association ends of an one-to-one association. Unidirectional 1:1 associations with Fluent API are now supported. Enhancements to the Fluent API were developed in order to support such scenarios. The validation rules executed in the Association Editor are also improved so that they check for more 1:1 specific issues.
• Fluent: Introduced support for mapping struct properties and fields - Custom structs can now be a part of a model that is mapped using the Fluent API. Supported scenarios include basic struct mapping as well as a struct nested in structs.
• Fluent: Introduced support for polymorphic references - Polymorphic references (references of interface types) can now be used as a part of a model mapped using the Fluent API. Specifying the allowed types can be done using one (or more) calls to WithAllowedType(Type). Example:  configuration.HasAssociation(x => x.Animal).WithAllowed(typeof(Cat)).WithAllowed(typeof(Dog));
• Runtime: Ignore existing indexes during schema migration - It is now possible to ignore existing indexes on the database (delete scripts will not be generated for them) during the schema migration. A new property called CheckExtraIndexes is added to the SchemaUpdateProperties.
• Runtime: Prevent refresh after SaveChanges - The default setting for a context is to refresh all loaded objects after SaveChanges has been called and the objects are touched again. A new setting has been added that can avoid this time consuming operation but will increase the risk for concurrency control conflicts.
  The new setting can be used like: context.ContextOptions.RefreshObjectsAfterSaveChanges = false, this setting will be taken into account after the next SaveChanges or RollbackChanges call.
• Runtime: Schedule GC run if last context using replaced metadata is disposed - If metadata replace has been called on a context instance, the old metadata is still used by old context instances. To help the Garbage Collector, OpenAccess calls GC.Collect(0) if the last context with an old metadata version has been disposed.
• Visual Studio 2012 RC: Introducing new metro style icons for the Visual Designer - A set of new icons has been introduced in the OpenAccess design time support for Visual Studio 2012, that complies with the metro requirements.

Fixes

• Add OpenAccess Service: Various fixes and improvements in the wizard and generated code - Fixed issues with WCF Data Services generation in Visual Studio 2012 RC. Create/Update/Delete operations are now not available for views. The Telerik.OpenAccess.DataServices.50.dll binary is now updated by the Upgrade references command.
• Association Editor: Added missing validation to the editor - Validating property names now takes into account existing properties. Added validation for one-to-one scenarios with two database calculated identities. Added validation for one-to-one self-referencing associations. Improved property/column grids, it is now impossible to use a property/column twice.
• Fluent: Calling HasConstraint() does not create a constraint for unidirectional associations. - If a user uses the parameterless HasConstraint() method do declare that he wants a constraint created for an association ( config.HasAssociation(x=>x.Person).HasConstraint() ), the constraint was created only if the association was bidirectional e.g. there was a WithOpposite() call before the HasConstraint() one.
• Fluent: Inconsistent source and target ends of many-to-many associations - The source and target ends of a m:n association used to depend on the order of the configurations that were defined.
• Level Two Cache: Ability to specify multiple queue names that configure fallback queues - In environments where the second level cache of Telerik OpenAccess ORM is used within IIS it is useful to be able to specify more than one queue for fallback scenarios. Overlapped recycling will be possible then. The queue names are separated with a semi-colon. The initialMessageTimeout can now be adjusted as well.
• LINQ: Using intermediate locals to hold query fragments for composition might not work - Using a local variable to hold a queryable fragment of the whole query expression could have led to 'Query parameter name is not declared' exceptions.
  Example:
  int num = 10000;
  var q = Scope.Extent<Northwind.Order>().Where(o => o.Id > num);
  var q2 = Scope.Extent<Northwind.Customer>().Where(c => q.Any(o => o.CustomerID == c.Id));
  var r = q2.ToList();
  Workaround: Avoid the local, use the query expression directly in the LINQ expression.
  var q2 = Scope.Extent<Northwind.Customer>().Where(c => Scope.Extent<Northwind.Order>().Where(o => o.Id > num).Any(o => o.CustomerID == c.Id));
  var r = q2.ToList();
• Medium Trust: Materializing to a Non-PC type from a Data Reader yields SecurityExceptions - When a DataReader is used to materialize to a type which is not a persistence capable (like DTO for example), SecurityExceptions could have been thrown under medium trust.
• Runtime: Ado type mapping requires length - If an ADO or CLR type mapping is added to the container.DefaultMapping.ClrMap or container.DefaultMapping.AdoMap, it used to be necessary to specify the length and scale. This no longer applies for types that does not support this setting.
• Runtime: Artificial types do not respect the default fetch group - Artificial types that contain non value type fields like references and collection used to return those as null values even if they marked as eagerly loaded.
• Runtime: Data in join tables was not deleted when additional autoset fields were mapped in many to many setups - When working with many to many setups and having additional autoset fields mapped in the class, it could have been, that data stored in a join table was not deleted, causing foreign key violations.
• Runtime: Duplicated optimistic locking fields - If the mapping of an optimistic locking field is specified in the app.config and in the persistent attribute, only the setting from the app.config file were taken in account. This lead to duplicated columns that are not synchronized.
• Runtime: Exists statements should only be generated if possible - OpenAccess generates as many exist fragments as possible. If a projection value is calculated inside an exists fragment, the SQL is not executable. In such cases, the exists is now replaced by a distinct join.
• Runtime: Handling of navigation to 1:1 partially missing, leading to insufficient checks with NULL values - When a 1:1 relationship is used in a LINQ query like ' ... where person.Address == null', only foreign key relationships used to be handled correctly; 1:1 requires a left outer join to test against a NULL value.
• Runtime: In multithreaded scenarios an InvalidOperationException is randomly thrown while trying to save similar objects with a 'varchar(max)' column in parallel. - The runtime used to randomly throw an "InvalidOperationException - Nullable object must have a value, while trying to save objects with a character column (varchar(max),nvarchar(max),ntext)" under certain multithreaded scenarios.
• Runtime: Inserting multiple instances of a derived vertically mapped class can fail. - Inserting multiple instances of a derived class with 'Vertical' inheritance strategy and 'Database server calculated' identity mechanism used to throw an exception with the message - ' Previous result set was not closed.
• Runtime: Insufficient handling of database connection and transaction when non-fatal error occurred during Flush() or Commit(). - When a non-fatal error like OptimisticVerificationException occurred during Commit/Flush, the underlying database connection and transaction was not handled correctly.
• Runtime: Parallel fetch of collection in derived class - If a collection in a derived class is included as parallel result into a base class query, the result set might have not been complete.
• Runtime: Persistent class with Identity Mechanism Guid will override manually set identity - A persistent class that has a Guid Identity Mechanism used to override the explicitly specified identity when it is a part of a one-to-one association when saving changes to the database.
• Runtime: Potential difference between enhanced default fetch group and SQL default fetch group - When the enhanced default fetch group contains more fields than the SQL default fetch group, inefficient or wrong operations were possible because in-memory state can be different than executed operations.
  This can occur when there is a difference between enhancement information and runtime information or when a non-default value type is used (SqlHierarchy).
• Runtime: Schema handler has wrong mapping after metadata replace - If the metadata has been changed on a context instance, the schema handler was still using the old metadata.
• Runtime: Schema Migration could have generated double drop index statement - If a class has several new indexes defined, an unnecessary drop index statement is generated. Workaround: add only one index per schema migration run or correct the migration script prior to execution.
• Runtime: Should not initialize key generators to early - The full initialization of the metadata can only be performed after the schema migration has been completed. For replace metadata this means, the initialization has to be done after the schema migration call back returns.
• Runtime: Using a column as a discriminator and as a property causes wrong insert statement generation - If a column is used as an inheritance modifier and for a property, Telerik OpenAccess ORM generates wrong insert statements adding the column twice to the statement.
• Schema Read: SQL server replication setup databases contains artifacts - If replication is enabled on a SQL server database, a lot of extra tables, views and stored procedures are added. Those artifacts were not filtered out by the OpenAccess schema read and could have led to command timeout exceptions.
• SDK: Silverlight 5 Tools for Visual Studio requirement check was wrong. - The requirement check for Silverlight 5 Tools did not work as expected with certain versions of the toolkit.
• SDK: SofiaCarRental21 database creation script is not compatible with SQL Server 2012 - The script that is used to create the SofiaCarRental21 database used to be incompatible with SQL Server 2012.
• SQLite : Invalid 'CREATE TABLE' SQL is generated when a class with 'DatabaseServerCalculated' identity mechanism has an integral identity field other than Int32 - When a class has 'DatabaseServerCalculated' identity mechanism the corresponding primary key column in the table has the 'AUTOINCREMENT' keyword specified. If the identity field in the model is of type Int64 this generates a column with SQL type - 'bigint' along with the 'AUTOINCREMENT' setting. 'AUTOINCREMENT' is allowed only on a INTEGER data type column and hence an exception was thrown while trying to create the table
• Stored Procedure Editor: Fixed issue related to handling of string parameters - When NULL is passed as a value of a stored procedure String parameter, the value was not handled correctly and an exception was thrown: "Procedure or function [] expects parameter [], which was not supplied"
• Update From Database: Mismatch in the FK columns for associations with composite primary keys. - If you have an association (1:1) that has a composite primary key on both sides when updating from database your association source and target columns used to be mixed.

Enhancements

• Visual Designer: Name generation for database objects is made configurable - OpenAccess has a name generation mechanism to generate names for various database objects such as tables, columns, constraints, indexes etc. This algorithm does a variety of checks such as handling CamelCasing, checking for reserved words, checking for length etc on the class or field names to generate the object name. The generated name was sometimes difficult to read and very different from it's source (class, field name).
  It is now possible for the user to customize this processing or switch it off altogether. A new form is provided for these settings on the Add New Item wizard and as part of the Model Settings dialog.
• Fluent API: Backend Independent Type Mapping - An OpenAccess user of the Code Only approach is now able to map the CLR types to database types in a backend independent manner so his model can easily be migrated across backends. An example is a mapping for a Unicode infinite length string, SQL Server needs “nvarchar(max)” as SQL type, Oracle needs “ntext”. An abstract mapping is provided that would be stored in one place and generate the appropirate script for both servers.
• Visual Designer: Better error handling for the default mapping - The default mapping process is used to calculate the relational artifacts for a conceptual model. This process can generate various errors if the conceptual model has ambigous mappings. These errors are now visualized in a better way by posting errors in the Error List. The Visual Designer is no longer blocked by such errors and the user can continue defining the conceptual model.
• Context API: LookupObjectByKey function added - A function is added in the Context API, checking if an object is loaded in the first level cache of a context. This functionality used to be available only in the IObjectScope API. The new function is LookupObjectByKey<T>(ObjectKey key).
• Runtime: Avoid second access to the database server for 1:1 references coming from a fetch plan - When the 1:1 reference cannot be resolved by an outer join, the database used to be accessed for a second time.

Changes

• Metadata Container: Name generation API is changed - The API for defining naming settings for the default generated database items is changed. The following properties of the NameGenerator in the MetadataContainer are marked as obsolete and replaced:
  • UseModelNames - marked obsolete, replaced by RemoveCamelCase and ResolveReservedWords
  • EnforceSimpleNames - marked obsolete
  • BREAKING CHANGE: PKFieldSuffix is renamed to PKColumnNameSuffix
  • BREAKING CHANGE: WordBreak is renamed to WordSeparator
  • BREAKING CHANGE: NameCanStartWithUnderscore is renamed to RemoveLeadingUnderscores
  • BREAKING CHANGE: Disambiguate is renamed to ResolveDuplicateNames
  • BREAKING CHANGE: DisambiguateJoinTables is renamed to ResolveDuplicateJoinTableNames
  • BREAKING CHANGE: DisambiguateConstraints is renamed to ResolveDuplicateConstraintNames
• Runtime: BackendConfiguration.ConnectionTimout property is marked as obsolete - The BackendConfiguration.ConnectionTimout property is marked as obsolete as a new API is going to be implemented for the purpose of delayed closing of an inactive database.

Fixes

• DSL: Stored procedures from different Oracle packages could not easily be distinguished - In an Oracle setup where stored procedures with the same name are spread over different packages it was not easily visible in the DSL where the procedure comes from, since the package name is not shown in the Model Schema Explorer or the Update from Database wizard. Now the package name is shown.
• Fluent API: Structs that are not explicitly mapped caused issues for the AggregateMetadataSource - Structs that are not explicitly mapped (no columns defined for their properties/fields) could not be used with the Aggregate Metadata Source. Column names were inferred from the persistent type that is using them.
• LINQ: Join Table Collection SubQuery could fail when outer owner is accessed - When a join table collection is sub-queried (as part of the filter on the owner), and the sub query accesses the owner fields (besides PK), the resulting SQL was wrong.
• LINQ: Filtering on enum properties does not work for Dynamic Linq queries. - Dynamic Linq queries that contain filters based on enum values like: context.Customers.Where("CustomerType = \"Corporate\"") were not handled correctly and the generated SQL statement contained the string presentation of the enum constant value instead of the numeric presentation.
• LINQ: Filtering on a nullable DateTime property generates wrong SQL in some cases - If the linq expression tree is constructed manually using the classes from the System.Linq.Expressions namespace and contains a node like "Expression.Constant(new DateTime?(someDateTime), typeof(DateTime?))", the DateTime value was not correctly appended to the generated SQL statement, which lead to an error for incorrect syntax.
• Validation: Wrong validation error when using Auto Incremental GUIDs in MS SQL - A validation error was wrongly shown when there is a valid auto incremented GUID setup for MS SQL Server 2005+
• NuGet: The OpenAccess package was not compatible with package restore - The import statement that is added to the .csproj file was not conditional and in case the packages folder is not available (not checked in) the project was not loadable.
• OpenAccessLinqDataSource: The wizard could not find context types if the data source is added to a Web Site project - If an OpenAccessLinqDataSource is added to a page of a Web Site project, the wizard of the data source was unable to find any OpenAccessContext types from the referenced projects.
  Setting the context type manually in the aspx markup was the only workaround.
• Oracle: Wrong parameter type defined for Date columns - When storing Oracle DATE columns, Telerik OpenAccess ORM used the parameter type System.Data.DbType.DateTime instead of System.Data.DbType.Date
• Profiler: The OpenAccess Profiler service fails to start if ASP.NET Compatibility Mode is enabled - The ServiceHostManager.StartProfilerService method could fail if ASP.NET compatibility mode is enabled in the web application, because the default service behavior requires this mode to be disabled. The OpenAccess Profiler service now has the AspNetCompatibilityRequirements attribute defined with RequirementsMode set to AspNetCompatibilityRequirementsMode.Allowed, which allows the service to run with or without the ASP.NET compatibility mode enabled.
• Metadata Translation: Properties of type List not handled during runtime - Properties of type List are not handled during runtime. The problem is in the metadata translation layer as it should make sure that these fields are passed to the runtime as List which is a correctly supported collection.
• Runtime: "Change of Identity is not supported" was thrown when working with composite primary keys shared with references - A "Change of Identity is not supported" message was thrown in scenarios where a reference is shared with one part of a composite primary key, when trying to add the n object in a 1:n association to the context.
• Runtime: After FlushChanges, DirtyObjects still reported the deleted instances as dirty - When FlushChanges() or FlushChanges(false) is performed on the context, the result from Scope.Transaction.DirtyObjects used to report the deleted objects as deleted (modified instances were already removed from the list). The new behavior is made consistent so that deleted objects are no longer returned from DirtyObjects after a FlushChanges.
• Runtime: AttachCopy could fail with deserialized, unmanaged instance graphs involving collections - When an object graph is deserialized (e.g. from JSON), the resulting object network could fail with an exception while attaching.
• Visual Designer: The default mapping mechanism throwing a System.Exception in some inheritance scenarios - The underlying default mapping mechanism in Visual Designer was throwing a System.Exception when trying to map a class to a table in model that has a collection field in a base class with InheritanceStrategy set to 'Horizontal'
• Visual Designer: Field Name not updated correctly when the property is renamed - Field name was not updated automatically when you rename the property in Visual Designer. Now the field name is auto-generated based on the property name, in case the user hasn't renamed the field manually. In case the field is manually renamed, its value is not replaced.
• Class name was missing in a certain 1:1 associations exception message - The class name is now shown in the 1:1 associations exception message.
• VS 2012 RTM: Telerik OpenAccess Web Application and Telerik OpenAccess Web Site project templates not working - Telerik OpenAccess Web Application and Telerik OpenAccess Web Site project templates were not working with the RTM release of Visual Studio 2012. Now they are fully functional.
• VS 2012 RTM: The 'Concurrency Member' and 'Type' property editors can't be resolved in the property grid of the Visual Designer - The custom type editors that provide a combo-box with dynamicly loaded items for the 'Concurrency Member' and 'Type' properties in the DSL Designer could not be loaded in Visual Studio 2012. The result was a black rectangle in the property grid and inability to manage those properties.

Enhancements

• Add OpenAccess Service: Web API support - ASP.NET Web API service code generation added in Add OpenAccess Service wizard
• Database Functions Support - Support for built-in and user-defined database functions is added in the Stored Procedure Editor. It is now called Domain Method Editor. The implementation includes Table-Valued functions support and LINQ-enabled scalar functions.
• Client-side Incremental GUID support - OpenAccess now offers a client side GUID generator to produce optimal sequential values for all supported backends. The GUID generator is available as a key generator for persistent types in the Context API.
• LINQ: Support for bitwise operators enhanced - Bitwise &, |, ^, ! operators are now supported in OpenAccess ORM LINQ statements.
• LINQ: Support for DateTime methods - Support for the DateTime LINQ methods was added to the OpenAccess ORM LINQ engine: Date, Day, DayOfWeek, DayOfYear, Hour, Millisecond, Minute, Month, Second, Year, Now, UTCNow, AddDays, AddHours, AddMilliseconds, AddMinutes, AddMonths, AddSeconds, AddYears, Equals
• Profiler: New alert for detecting client-side LINQ queries - Some LINQ queries can't be completely executed on the server-side, so OpenAccess executes parts of them on the client. A new alert is added to the OpenAccess Profiler for such cases, so the LINQ queries that are inefficient can be easily identified and improved.
• Runtime: Support for shared fields on polymorphic references - Support for shared fields on polymorphic references has been added to the product. With this functionality you can share the foreign key values of your polymorphic references with other simple fields.
• Fluent API: New method added for index creation in Many-to-Many scenarios - A new Method in the Advanced namespace is added - HasValueIndex - which specifies that an index should be created on all the non-primary key columns in the join table of a Many-to-Many association. It is used for fine-tuning the performance in certain scenarios.
• Fluent API: Delete Orphans setting exposed - The Delete Orphans setting, supported by the OpenAccess Runtime, was not exposed in the new metadata. Now it is available in the Fluent Mapping API.
• LINQ: Grouping over joined expressions - Now the LINQ implementation allows aggregates to be used over joined expressions like
  var q = from x in
  (from det in Scope.Extent<Northwind.OrderDetail>()
  join prod in Scope.Extent<Northwind.Product>() on det.ProductID equals prod.Id
  group new { det, prod } by det.ProductID into g
  select new { Make = g.Key, TotalOrders = g.Sum(z => z.det.Quantity * z.det.UnitPrice) })
  orderby x.TotalOrders descending
  select x;
• LINQ: Translation of object.Equals(1) generating parameterized expression - When a geography value is compared (e.g. with .STIntersects(other)), a CLR type of SqlBoolean was returned or further processed in the database server. This forces the code to be writen like .STIntersects(other).Equals(1) in LINQ filters. However, the direct translation of the constant into a parameter as in .STIntersects(@p) = @p1 causes the MSSQL query optimizer to disregard an spatial index and to
  use a filtered index scan (because of the query compile-time unknown value of @p1).
  OpenAccess detects now the .Equals(0) and .Equals(1) method calls and produces a literal integer value instead of the parameterized value.
• MSMQ: Better cleanup in case of failing initialization - When the initial setup of MSMQ fails, the cleanup was not fully done under certain circumstances. This could lead to later sharing violations.
• Runtime: Order of SQL inserts to obey the order of logical adds into the context for same structured new objects - When a lot of new objects are stored, the order in which the objects appeared in the generated SQL was not predictable. Now the insertion order into the context is used to determine it. This applies only to identically structured (same fields have values) objects with the the same type.
• Update Database From Model: Improvements in the change-set production and handling in the wizard. - The change-set that is shown by the wizard is improved. The limitations of the schema migration script are described in a documentation article that is available through a warning message in the wizard.

Changes

• Installation: CHM documentation removed from the default distribtion - The offline documentation is now available only as a separate download for the product, which reduces the size of the installation MSI and speeds up the installer.
• General: The old Data Services Wizard is removed from OpenAccess - The deprecated Data Services Wizard is now officially removed from OpenAccess ORM. The new Add OpenAccess Service wizard should be used instead.

Fixes

• Add New Item Wizard: The generated Model Name should be equal to the written rlinq name. - When selecting ‘Telerik OpenAccess Domain Model’ from ‘Add New Item’ Visual Studio dialog and writing a rlinq file name, this name is not used for creating the OpenAccessContext. Now the RLINQ file name and the context name are synchronized.
• Add OpenAccess Service wizard: Models with one way associations caused AOS wizard to fail the code generation step - Both Code Generation and missing metadata is now fixed for the cases when the model contains one-sided associations.
• Association Editor: Many to Many associations are not mapped correctly when the two classes have different count of identity columns - When the two classes have different count of identity columns the Association Editor used to omit some of the column mappings and to display a validation message like "The join table association 'X_has_Y' has defined 1 association parts pointing to
  the source type 'X'.  The 'X' has 2 identity members and either all or none of them should be included
  in the association definition."
• Class name missing in a certain exception message in 1:1 associations - The class name is now shown in the 1:1 associations exception message.
• Fluent API: The MapType() method failing to default-map members of type DateTime. - The behaviour when calling mappingConfiguration.MapType() is to default-map all primitive members inside the class for which the mapping configuration has been defined. This was not working for DateTimes and they were ommited when the default mapping occures. Currently all DateTime columns are properly handled by the default mapping.
• Level Two Cache: Sending eviction message during SaveChanges could fail with exception when nothing needs to be send - When there is nothing to be evicted from the L2 cache logically, a NullReferenceException could be thrown.
  The workaround used to be to Insert/Update a dummy instance, avoiding 'empty' commits.
• LINQ: Casted expressions (OfType) potentially not resolvable in further processing - In a LINQ expression of the form ctx.Where(x => x.Collection.OfType<Z>().Any(a => a.Prop == value)) the resolution of Prop could fail if Prop is declared on type Z, instead of the collection element type.
• LINQ: Filtering on a nullable DateTime property generating wrong SQL in some cases - If the LINQ expression tree is constructed manually using the classes from the System.Linq.Expressions namespace and contains a node like "Expression.Constant(new DateTime?(someDateTime), typeof(DateTime?))", the DateTime value was not correctly appended to the generated SQL statement, which lead to an error for incorrect syntax.
• LINQ: Filtering on enum properties not working for Dynamic Linq queries. - Dynamic Linq queries that contain filters based on enum values like:
  context.Customers.Where("CustomerType = \"Corporate\"")
  were not handled correctly and the generated SQL statement contained the string presentation of the enum constant value instead of the numeric presentation.
• LINQ: Translation of Nullable.GetValueOrDefault() leading to incorrect SQL - When an LINQ expression like X.Where(y => y.NullableBool.GetValueOrDefault()) is translated, invalid SQL was produced.
  The workaround was: X.Where(y => y.NullableBool.GetValueOrDefault() == true) ; to explicitly test against a value.
  Now the generated SQL is valid.
• Metadata Translation: Properties of type List not handled during runtime. - Properties of type List<Enum> were not handled during runtime. The problem was in the metadata translation layer as it should make sure that these fields are passed to the runtime as List<int> which is a correctly supported collection.
• OpenAccessLinqDataSource: In Vertical Inheritance scenarios updating a row caused an error - Now the OpenAccessLinqDataSource is working successfully with Vertical Inheritance between classes.
• OpenAccessLinqDataSource: Parent properties missing in Form View control when Vertical Inheritance is used - Currently the Form View dialog shows the parent properties when Vertical Inheritance is defined between classes.
• Runtime: Assigning a managed shared field reference before adding the object to the context causing a cast exception - Adding a object to the context that has a shared reference with a managed inverse collection on the referenced side could cause a cast exception when the reference is set before the object is added to the context.
• Runtime: AttachCopy could fail with deserialized, unmanaged instance graphs involving collections - When an object graph is deserialized (e.g. from JSON), the resulting object network could fail with an exception while attaching.
• Runtime: AttachCopy could fail with NullReferenceException with mixed instance graph - When a detached Order object gets an unmanaged OrderLine added to it (inverse managed collection element), the AttachCopy operation used to fail with a NullReferenceException.
• Runtime: Byte[] foreign keys not handled as shared fields. - If a foreign key is of type byte[], it was not recognized as shared field even if the metadata for that was provided. Having a byte[] as a foreign key is now possible as raw(16) columns from Oracle map to a byte[] by default and they logically represent Guids.
• Runtime: Creation of database instance failing with OpenAccessException when done in parallel - When the database underlying an OpenAccessContext is obtained for the first time, some configuration values are set to the default values. This modification lacked a synchronization resulting in an OpenAccessException 'Unable to copy configuration value with null key'. As a result, an exception was thrown when there were concurrent attempts to open the database with the same backend configuration.
• Runtime: Projecting link collection members from OQL potentially joins wrong tables - When a join collection is projected from an OQL expression, the needed join is created in a wrong fashion, resulting in an exception.
• Runtime: Projection with parallel fetch failing with exception under specific circumstances - Performing a query with parallel fetching (default for OpenAccessContext) and having a DefaultFetchGroup attribute specified can lead to exception during the calculation of the parallel fetch when the original filter contains a subquery expression.
• Runtime: Setting the value of a nullable integral field that is shared with a reference field, to 0 and then adding the object to the context results in a NullReferenceException - If a reference field and a nullable simple field are mapped to the same column and the simple field is set to 0 and the object is added to the context, a NullReferenceException is thrown.
  Source obj = new Source();
  obj.NullableTargetId = 0;
  context.Add(obj); //NullReferenceException.
• Runtime: Synchronization of auto-incremented primary key inverse collections could fail with NullReferenceException - When an auto-incremented primary key instance is added to the context, and another instance uses the inverse collection of the inserted type, a synchronization can be attempted which could throw a NullReferenceException in case the collection is not managed and is not in memory.
• Runtime: Synchronization of reference fields throws a MetadataException - When reference fields are synchronized with each other, but one of the references only uses a subset of the columns the other reference uses, then an MetadataException was thrown.
• Runtime: Using Primary Keys with more than 3 columns could fail - When a primary key is defined with more than three columns, the in-memory handling of OIDs was partially broken.
• Runtime: Wrong joins when IList:Contains(T) is used on a referenced instance - When a IList<T.Contains(T) method is used on a referenced instance in LINQ, the resulting join was not build up correctly.
• Schema Generation: Indexes not always created for join table association - There are several join table scenarios when OpenAccess ORM does not generate migration script for creating indexes on the target end columns in the join table.
• Second Level Cache: Eviction of query results missing, when joined type instances are modified. - When a LINQ query like ... from x in Xs join y in Ys ... is made, the query result does not have a dependency on the Y type. This could lead to incorrect/unevicted query results after an Y instance is changed.
• Validation: Wrong validation error when using Auto Incremental GUIDs in MS SQL - The validation error was wrongly shown when there is a valid auto incremented GUID setup for MS SQL Server 2005+

Enhancements

• Fluent API: Support for Multi-Table Entities - New API and runtime capabilities are introduced in the Fluent Mapping API that would allow mapping more than one table to one class. The new mapping is configured through
• Fluent API: More flexibility when configuring properties of type string[] - A way to manipulate the resulting value column in a join table when mapping a string array is introduced. The following methods have been added on a property configuration based on a string[]: .IsUnicode() .IsNotUnicode() .IsUnicode(bool) .WithFixedLength() .WithFixedLength(int) .WithVariableLength() .WithVariableLength(int) .WithInfiniteLength()
• Context API: New API that allows retrieval and modification of the Guid range for incremental GUID generators - Two methods were introduced for that purpose: GetIncrementalGuidRange - Retrieves the range of the last generated incremental Guid value. SetIncrementalGuidRange - Sets the range of the next generated incremental Guid value.
• Context API: CreateDetachedCopy not working properly with List as a parameter - The CreateDetachedCopy methods are now able to handle List<T> without specifying the generic type parameter explicitly
• Context API: New method GetMemberNames() for quering instance members based on the data state. - A new method was introduced for retrieving the members of a persistence instance based on their data state:
  var members = context.GetMemberNames(product, MemberState.Modified);
  The members collection is populated with all the product members that are modified. If the passed instance is new or detached an exception will be thrown.
• LINQ: Provide support for HAVING statements - Support for SQL HAVING clause was introduced, so that the following query would use it:
  var usersWithMatchingAnswers = (from pa in profileAnswers
           group pa by pa.UserID into grp
           where grp.Count() == numberOfSelectedItems
           select grp.Key).ToList();

Changes

• Schema Migration: Removing voa_version columns when the concurrency control is not set to version - Schema migration now generates a drop DDL script for voa_version columns when the concurrency control for the given type is changed from Version to other concurrency control mechanism.
• Model Settings: Class names wrongly capitalized in some cases -
• Model Settings: Remove Prefix / Suffix for class, property or field should be executed only for the first appearance of the written text in the name. - Removing prefixes and suffixes was wrongly executed several time in case the prefix or the sufix were repeated in the name more than once. Now only the first occurance is removed.

Fixes

• 1:1 Associations: Wrong exception when adding objects with 1:1 associations to the context - A "1:1 relation inconsistent" exception message was wrongly shown when a object was added to the context that is part of a 1:n and a 1:1 association where the 1:1 association is eagerly loaded and the n end of the association existed before.
• Add New Item wizard: Wrong default model name - The default model name was wrongly defined as EntityDiagrams1. It is now changed to EntitiesModel1.
• ADO API: Type converter not detected for non PersistenceCapable types - When using the ExecuteQuery<T> method, OpenAccess was not able to find the appropriate type converter for a column type number(5,1) that should be translated to a System.Single type.
• AOS Web API: Generated Delete method throws InvalidOperationException - Fixed the Web API Delete method generated code so it does not throw InvalidOperationException.
• Data Services: Failure to generate metadata for models with Many to Many associations - If you create a Data Service V2 or V3 based on model that contains many to many association there is an internal server error when trying to get the service metadata.
• LINQ: Some queries were failing if the context endpoint exposes the persistent class via interface - If a LINQ query was executed against a context endpoint like the following:
  public IQueryable<IMyClass> MyClasses
  {
  get { return this.GetAll<MyClass>(); }
  }
  where the persistent type MyClass implements the IMyClass non-persistent interface, the query could fail with a "Stack empty" exception if it contains multiple joins or a join with grouping.
• LINQ: Using SqlGeometry data type in a LINQ statement leading to an error - Now properties for columns with the SqlGeometry type can again be used successfully in LINQ queries.
• MSSQL: Value of timestamp columns not displayed correctly - The value obtained from timestamp columns on MS SQL Server (the versioning column) mapped to an Int64 did not display the value from the database server. The concurrency control behavior is correct, but the displayed values had a different byte order than expected.
• Runtime: Deleting an object with two shared references using a primary key caused a exception - When a object is deleted that is configured to have a reference shared with a primary key column and a second reference is shared with the same primary key, and the referenced object also has a managed collection, then in some cases OpenAccess was throwing a exception.
• Runtime: FetchStrategy occasionally returning empty collections - Under some circumstances, a collection that is minimum on level 3 of a fetch strategy is empty. This happens only if another collection in the same path is really empty.
• SharedFields: Synchronization of composite primary keys with more that one navigational member failing - In scenarios where navigational members share the columns with composite primary keys, the synchronization of these values threw an exception. Example setup: A class has the primary keys ID, ID2, ID3, ID4. The first reference uses ID, ID2, ID3. The second reference uses ID, ID2, ID4. Now the synchronization in such cases is working properly.

OpenAccess SDK

New Samples

• New Sample: Sofia Car Rental through Web API and Kendo UI - Added a new sample that demonstrates how to integrate Kendo UI and Web API. The new Sofia Car Rental Admin Panel web application features CRUD-enabled Kendo UI grid with pop-up editor and a modal pop-up Kendo Window

Deprecated Samples

• Sofia Car Rental MVC 3 Razor and Fluent Mapping - Fluent Mapping is now presented with MVC 4 in the updated MVC Forum application

Updated Samples

• All Telerik components are updated to version Q3 2012
  • KendoUI MVC Extensions (2012.3.1114)
  • RadControls for Silverlight (2012.3.1017)
  • RadControls for WPF (2012.3.1017)
  • RadControls for Windows Forms (2012.3.1017)
  • RadControls for ASP.NET (2012.3.1016)
• MVC Forum project is migrated to MVC4 and is now using Kendo UI MVC Extensions
• WCF Data Services with KendoUI sample migrated to Data Services v.5
• Sofia Car Rental - WCF Data Services sample migrated to Data Services v.5

SDK Browser Enhancements

• Visual Studio 2012 support is introduced for all samples - There is a separate Visual Studio 2012 solution file deployed with each of the samples.
• Various small improvements in the Create or Attach Database Dialog

SDK Browser Fixes

• SofiaCarRental21 database: Cars with duplicating tag numbers - Tag numbers for all the cars are now unique all over the database. Older databases might have to be recreated using the latest verstion of the script SofiaCarRental21.sql in order to avoid errors in the SofiaCarRental samples.
• Running SQL scripts for database creation was possible on older versions of MS SQL Server then required - SDK Browser's Database Management Tool dialog now filters the available database servers based on their version and the requirements of the current sample. For example instances of Microsoft SQL Server 2005 will not be shown if the example requires Spatial Support that was introduced in Microsoft SQL Server 2008.

Enhancements

• Multi-Diagrams support in Visual Designer - Support for multiple diagrams for a single Domain Model is added to the Visual Designer. Thus, large models can be split between separate diagrams allowing an easier management of complexity and a faster workflow.
• Data Streaming - Data streaming is now supported in OpenAccess ORM. It can be used for scenarios that involve reading and writing large data files to the database. A new data type BinaryStream is made available which optionally replaces the byte array in order to make use of the new streaming capabilities.
• Artificial Types: Context based Artificial Data API - New Context-level API for creating, querying and manipulating entities enhanced with artificial fields, artificial entities and also non-artificial entities.
• ASP.NET Dynamic Data wizard: Integration with RadControls - New option in the Dynamic Data wizard is implemented, allowing it to generate the List pages of a Dyanamic Data application using DynamicRadGrid instead of the default .NET GridView.
• Add OpenAccess Service: Improvements in generation of Data Services to support any version of Microsoft.Data.Services - The usage of Telerik.OpenAccess.DataServices assembly is now replaced by including the code files for Data Services in the target project. This way that can be used with any version of WCF Data Services that is supported by OpenAccess ORM without having to reference different assemblies.
• Context API: GUID Ranges configuration - New methods are added to the Context API to allow retrieving and modifying the client-side incremental GUID generation range
  • GetIncrementalGuidRange - Retrieves the range of the last generated incremental GUID value.
  • SetIncrementalGuidRange - Sets the range of the next generated incremental GUID value.
• Context API: ObjectConstructed event in OpenAccessContext.Events - A new event is raised each time OpenAccess runtime creates an instance of an entity type after the instance has been loaded from the database.
• Context API: Implement an OpenAccessContext API that resets the Incremental GUID - New method called ResetIncrementalGUID is provided for restarting the generated sequence of incremental GUID values.
• Convert From Entity Framework wizard: Convertion of database functions - Support for database functions automatic conversion is added to the wizard.
• Support for MySql 5.6 and Maria DB 10.0.1 Alpha - OpenAccess ORM is now tested with MySql 5.6 and Maria DB 10.0.1 Alpha.
• Validation Dialog: New model validation warning for nullable identity properties.
• Validation Dialog: New model validation warning for columns that are not mapped to properties

Changes

• Fluent Mapping Code Generation moved to a separate wizard - OpenAccess now provides an additional item template named "Telerik OpenAccess Fluent Model" which generates an OpenAccess model based on the Fluent mapping API without creating a rlinq file. This avoids the need to remove the rlinq file manually if the generated fluent mapping code should be customized.
  This functionality is available only for Visual Studio 2010 and 2012.
• Model Settings: ‘Keep Metrics for Profiler’ setting switched off by default - On the Tracking and Logging tab of the Model Settings dialog, the Keep Metrics for Profiler setting was checked by default. Now it is switched off by default.
• Stored procedures and functions icons updated - The icons for stored procedures and functions are updated in the Add New Item Wizard, Update From Database wizard and Model Schema Explorer

Fixes

• API : When using 'Attribute' mapping as the 'Code generation' mechanism the primary key fields of a persistent type did not reflect the settings made in the designer - When using 'Attribute' mapping as the 'Code generation' mechanism the primary key fields of a persistent type are calculated based on the 'Primary key' property of the column. If the column has the 'primarykey=false' value but the correspondig property in the domain class has the 'IsIdentity' property set to 'true', this was ignored and a default primary key was used for the type. This could lead to further metadata errors for fields that reference this class.
• Fluent Mapping: Defining artificial types that use horizontal inheritance - When trying to define artificial types that use horizontal inheritance, an exception was thrown complaining about wrong id specifications. Now the Artificial Types support horizontal inheritance scenarios.
• Fluent Mapping: Capability of configuring indexes for Multi-Table Entities - The possibility to specify indexes on secondary tables for Multi-Table entitites has been added to the FluentMapping API
• Metadata: Wrong detection of 1:1 associations when an identity column is implicitly mapped to the calculated column name - A 1:1 association was wrongly calculated for simple fields when the persistent class using Attributes mapping had no explicit IdentityField specification and the actual identity column was mapped to the automatically calculated column name.
• Model Settings: Class names wrongly capitalized in some cases - The treating of capital letters as word delimiters can now be turned off by setting the Treat Capital Letters as Word Delimiter in the Model Names tab. The Capitalize option will always make the first letter of a word capital and lower the rest.
• Multi-Table Entities: Data was not correctly updated after schema migration of Multi-Table entities - A newly added column value stored in a remote table was not inserted when an update on an existing object was done. An insert is needed since the value was added after the initial object was stored to the database.
• RIA Services: Changes to Master-Detail relationship not handled appropriately when submitting changes via a RIA domain service - RIA Services Domain Context now handles properly One-to-Many relations when changes are done to the parent entity.
• RIA Services: KeyStateManager.SetValue method could cause a StackOverflowException. - The method contained a loop which would not end under certain circumstances.
• Runtime : Artificial fields marked with LoadBehavior.Lazy were always loaded when the object is loaded. - Fields of a class can be marked with a LoadBehavior = Lazy to avoid loading them by default. This setting was ignored for artificial fields and the field was always loaded when the object is loaded.
• Runtime : Setting the value of a nullable integral field that is shared with a reference field to 0 results in a NullReferenceException - If a reference field and a nullable simple field are mapped to the same column and the simple field is set to 0, a NullReferenceException wss thrown when the object was added to the context.
• Runtime: Dangling reference caused a converter exception when a timestamp was used as concurrency member for Sql Azure - A exception was thrown in the EightBytes2LongConverter when a class was configured to have a timestamp as concurrency member and was referenced by another object. When trying to access the referenced object, Azure is reporting a byte[] with the size of 0 in the case the value should be null. That caused a "Expected 8 byte array but got array with length '0'" exception.
• Runtime: FetchPlan not used for simple fields - When simple fields were defined to get loaded lazily, an explicitly specified fetch strategy defined on the context was not taken into account for the simple field.
• Runtime: Recreating an object that is part of a 1:n association caused a exception - An object that was deleted an re-added to the context, where the N side has 1:1 association, and the collection on the 1 side is managed, caused the following exception. "Updates in 1:1 association scenarios are not supported. To update the reference, delete the referenced object, flush the context and reassign the reference. "
• SchemaMigration: Additional columns were dropped from a join table but CheckExtraColumns is set to false - A additional column was dropped from a join table even when the SchemaUpdateProperties were configured to CheckExtraColumns = false.
• Update Database From Model: Removed indexes shown in the 'Select Changes' page. - The removed indexes are not a change that is applied during the process of updating the database so now they are also not shown as a change in the wizard.