Release History

By product

Data Access Free 2011.31116

November 15, 2011

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.


  • 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=, 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.


  • 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.