Data Access 2011.1316

Mar 15, 2011

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: 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
Have a feature request?

Post your feedback via the Data Access feedback portal or the public forums

What's new across all Telerik products?

See the updates feed

Next Steps

Download for free

Get your fully functional free copy of Data Access.

Get Data Access Sample Kit

Including demos and articles to get you started.

Suggest new features

Help us shape our roadmap.