LLBLGen Pro v5.5 beta has been released!

Last Friday we’ve released LLBLGen Pro v5.5 beta! We expect to release the RTM in a week or two. Below is the list of what’s new in this release. I’ll describe some of the new features in more detail in articles in the coming weeks. The main focus was on our own ORM framework, the LLBLGen Pro Runtime Framework, this time around.

What’s new in the LLBLGen Pro Runtime Framework?

New functionality / changes

  • Insert / update query batching (Adapter). The runtime now supports batching of insert and update queries into single DbCommand objects which great helps with performance, especially when using a database over a connection with high latency, like a cloud database. Available for Adapter, on the databases SQL Server, PostgreSQL and Oracle. More information
  • Window specification support (OVER() clause)). The LLBLGen Pro Runtime Framework now comes with support for the SQL OVER() clause, which is used with window functions. OVER() allows aggregates and specific window functions to define a window in the resultset. This support is two fold: existing aggregate functions can be extended with an OVER() clause in the SQL query and new window functions like RANK() and FIRST_VALUE() are supported and can be specified directly in an LLBLGen Pro query together with an OVER() clause. More information.
  • Union / Union All support in Linq and QuerySpec. The LLBLGen Pro Runtime Framework finally gets support for a feature that has been requested for many times: support for UNION and UNION ALL in queries. For Linq, there's now full support for .Union() and .Concat() (the Linq equivalent for UNION ALL). For QuerySpec, the support comes in the form of two new methods: Union() and UnionAll(). More information: Linq, QuerySpec
  • Oracle is now supported on .NET Standard. Oracle has finally released a .NET Standard 2.0 compliant ADO.NET provider, and you can use the LLBLGen Pro Runtime Framework now with Oracle on .NET Standard supporting platforms like .NET Core 2.x. More information
  • Function mappings of functions with no arguments for Linq. Mapping a function which has no arguments, e.g. GetDate() is now supported for Linq (QuerySpec already did support this). This allows you to map a .NET method which doesn't accept any database originating elements to a database function. More information
  • Query / Optimizer hints for Linq / QuerySpec. It's now possible to specify a query hint or optimizer hint to help a database optimizer with a choice to make when optimizing a given query. Available for SQL Server, Oracle and MySQL. More information Linq, QuerySpec.

Small changes

  • IEntityCollectionCore.Clear(bool) has been added, where if the boolean argument is set to true, the entities in the collection are added to the RemovalEntitiesTracker collection of the IEntityCollectionCore instance (if present).
  • An EntityView(2) no longer issues a Reset with the ListChanged event when a field of an entity in the view changes however it has no effect on the order of the entities in the view. It only issues a Reset with the ListChanged event if the order changed due to the change of the entity field.
  • The BooleanNumeric type converter now supports float and double values as well for boolean. This means that a conversion from boolean will result in 1.0 and a conversion to boolean will be using Convert.ToBoolean(value).
  • An implicit conversion between Enum and string is now supported, besides the already supported implicit conversion between Enum and a numeric value (int/byte etc.). This means you can map an enum typed field onto a string based database field without a type converter. The conversion will use the ToString() method on the Enum instance to produce the string value when persisting an entity to the database.
  • Implicit numeric conversions between fields of type byte, sbyte, short, int, long, float, double, decimal are now supported without a type converter.
  • Introduced object name creation caching to avoid string concatenations which are repeated a lot of times per query. This both saves memory and some query creation performance.
  • ISortClause now has two new command chaining methods: SetCaseSensitiveCollation(bool) and SetEmitAliasForExpressionAggregateField(bool) which set resp. the CaseSensitiveCollation and EmitAliasForExpressionAggregateField flags and return the ISortClause instance again for command chaining.
  • ISortClause and ISortExpression now have an extension method ThenBy() which accepts an ISortClause and which is appended to the object it's called on. The ThenBy() method is in the QuerySpec namespace.
  • The Oracle DQEs for ODP.NET and MS Oracle now have a static flag, DynamicQueryEngine.AlwaysUseRowNumBasedPaging, which is set to false by default. If true, and compatibility is set to 12c, a paging query will use the classic rownum approach instead of the FETCH NEXT / OFFSET approach. The latter can be up to 40 times slower than the rownum approach (see: the JOOQ blog) so the classic rownum approach might be more efficient in your application than the new approach.
  • The Firebird DQE now has function mappings for DateTime properties Year, Month, Day, Hour, Minute, Second, MilliSecond, DayOfYear, DayOfWeek and the DateTime methods AddYears, AddMonths, AddDays, AddHours, AddMinutes, AddSeconds, AddMilliSeconds.
  • When a retrieval query is forced to perform client side paging, distinct filtering or limiting, it will now append resp. "Requires client side paging", "Requires client side distinct filtering" or "Requires client side limiting" when the ORMQueryExecution tracer is enabled and the level is set to 'verbose' (4).

What’s new in the Designer?

Major changes / fixes / new features

  • Major performance improvements across the board, especially for larger models (250+ entities).
  • Support for implicit numeric conversions. The designer can now deal with implicit numeric conversions between model fields and mapped target fields, without the need for a type converter. This feature is supported on frameworks which allow implicit numeric conversions without a type converter: Entity Framework Core 2.1+ and LLBLGen Pro Runtime Framework v5.5+
  • Support for Entity Framework Core 2.1 has been added.

Minor changes / fixes / new features

  • The designer now supports implicit conversions between Enum and String. It already supported implicit conversions between Enum and a numeric value (int, short etc.). The implicit conversions are supported on target frameworks which support these implicit conversions as well. There's no value length check validation.
  • The TDL statement <[If HasTypeConverterDefined]> now returns true as well if the field mapping's property RequiresImplicitNumericConversionAtRuntime returns true, to make sure TDL can deal with this new feature without a new statement.
  • The TDL statement <[TypeConverterFullName]> will now also return the type converter name for implicit numeric conversions if no type converter is specified but the field mapping's property RequiresImplicitNumericConversionAtRuntime returns true. It will do so for C# and VB.NET.
  • PostgreSQL: The provider type for timestamptz fields is now TimestampTz instead of TimestampTZ. This change makes generated code require an Npgsql version of 3.2 or higher. This is done as TimestampTZ is marked deprecated and causing warnings during compilation. There's no change in functionality.
  • The designer now uses v18.1.6 of the DevExpress controls, which give a nice performance increase across the board.
  • The Visual Studio integration now hides the toolwindows if there's no longer a project loaded.
  • Several additional system type converters were added: ByteArrayStringConverter, DateTimeOffsetBinaryConverter, DateTimeOffsetByteArrayConverter, DateTimeOffsetStringConverter, DateTimeBinaryConverter, DateTimeInt64Converter, DateTimeStringConverter, StringByteArrayConverter, TimeSpanInt64Converter and TimeSpanStringConverter.

As always, v5.5 is free for people with an active subscription.

No Comments