This post originated from an RSS feed registered with .NET Buzz
by Frans Bouma.
Original Post: Major upgrade of LLBLGen Pro released!
Feed Title: Frans Bouma's blog
Feed URL: http://www.asp.net/err404.htm?aspxerrorpath=/fbouma/Rss.aspx
Feed Description: Generator.CreateCoolTool();
After 3 months of hard work, today, a major upgrade of one of the leading O/R mappers for .NET, LLBLGen Pro, has been released! . A large amount of new features are added to the new runtime libraries and templates, among them: MS Access 2000/XP/2003 support, prefetch paths, paging in entity collections and lists, aggregate function support and sql expression support and much more. Below is the full list of new things.
This upgrade is of course free for our customers .
Runtime Libraries
Added
Adapter/SelfServicing: MS Access support.
Adapter/SelfServicing:entityCollection.Sort(fieldIndex), to sort the collection in memory.
Adapter/SelfServicing: GroupByCollection support for typed lists/typed views and datatable fetched dynamic lists
Adapter/SelfServicing: HAVING Clause support to the GroupByCollection
Adapter/SelfServicing: Aggregate function support on IEntityField(2) objects (entity/typedlist/typedview). An IEntityField(2) instance can have an aggregate function applied to it, which is added to the field's SQL at runtime in Selects. Not all aggregate functions defined are supported on all supported database types.
SelfServicing:entityCollection.GetDbCount() (overloaded) to retrieve the amount of entities in the database of a given entity type and optionally with a given filter
Adapter/SelfServicing: GetScalar() (overloaded) method to retrieve a scalar value from the database without the necessity of creating an entity or typed list. Adapter users should use GetScalar to get the equivalent of GetDbCount()
Adapter/SelfServicing, SqlServer specific: SET ARITHABORT ON/OFF setting so inserts can be done in tables which are part of indexed views.
Adapter: COM+ support. See ComPlusAdapterContext class in the database specific project for more information.
Adapter/SelfServicing: SQL Expression support for field values. An IEntityField(2) instance now has a property which can be set to an Expression instance. This will make the field be replaced by the SQL representation of the expression. You can use this to create a field value for an entity or typed list or typed view be set to the result of an SQL Expression instead of the actual field value. This also works for updates done directly on the database.
Adapter/SelfServicing: Paging support for collections/typed lists/typed views. Paging support is added to the fetch routines and various overloads of these fetch routines. Specify the page size and page number to retrieve a subset of the entities to retrieve.
Adapter/SelfServicing: IEntityField(2).IsForeignKey has been added.
Adapter/SelfServicing: IEntityField(2).DbValue has been added. This is the value the field had when it was read from the database. You can use this property in your Optimistic concurrency predicates.
Adapter/SelfServicing: UnitOfWork(2) class. You can use this class to collect work to be done (on a single database, for multiple database actions, use a UnitOfWork(2) object per database)
Adapter/SelfServicing: SavePoint support for ADO.NET transactions. Use this to save a transaction under a given name, so a rollback can be done to the state at the time the transaction was saved.
Adapter, Oracle specific: Schema name overwrite logic implemented like SqlServer has for Catalog names.
Adapter/SelfServicing: Prefetch paths. Various fetch routines (and entity instantiation constructors (selfservicing)) support Prefetch paths. A prefetch path is a graph definition of related entities to fetch together with the actual entity / entities to fetch. Prefetch paths form an efficient way to pull related data out of the database without the requirement to create a query per entity. Prefetch paths support filtering, sorting and support limitation on the amount of objects to return per parent entity. Prefetch paths result in 1 query per entity type, so fetching all orders with their related customers, will result in 2 queries, which are merged by the runtime library code. All relation types are supported, intermediate entities are not prefetched.
Adapter/SelfServicing: Multi-level versioning of entity fields. You can now save an entity's fields under a name inside the entity and roll back to that state later.
Adapter/SelfServicing, SqlServer specific: FieldFullTextSearchPredicate, to perform full text searches on SqlServer databases which have Full text search enabled.
Adapter/SelfServicing: FieldCompareExpressionPredicate. This predicate can formulate field operator value/expression/field or value/expression/field operator field or value/expression/field operator expression/field filters.
Adapter/SelfServicing: FieldCompareSetPredicate. This predicate allows you to formulate field operator (subquery) filters. Operators include IN/comparison operators/EXISTS, ALL/ANY operators and all negative equivalents. Field can contain an expression / aggregate as well which is applied at runtime to the field.
Adapter/SelfServicing: entities can be joined multiple times to a join set. An alias for the entity has to be specified with the specification of the relation when it is added to a RelationCollection (or RelationPredicateBucket). The alias can also be specified with predicate instances to make filters work on a particular instance of the joined entity in the join list.
Adapter/SelfServicing: entities can be joined with self. This is the result of the multiple times an entity can be joined to a join set.
Adapter/SelfServicing: A JoinHint can now be specified when relations are added to a RelationCollection, for more fine grained control over what to use: left/right/inner joins.
Changed
Adapter: When a new entity is saved and the entity has a sequenced PK field and the entity isn't refetched, the new value for the PK is retrievable, despite the fact that the entity itself is marked OutOfSync.
Adapter/SelfServicing: For non-new entities: when a field is set to the value the field already has, the field is not marked changed if the field wasn't marked changed already.
Adapter/SelfServicing: All custom exception classes are now derived from ORMException which derives from ApplicationException.
Adapter/SelfServicing: PK fields of non-new entities can now be changed to a new value. This is not true for sequenced PK fields, these stay read-only.
Adapter/SelfServicing: Like predicates can now do case insensitive comparisons when it is necessary to do so. A case insensitive compare compares the UPPERCASE variant of the field with the pattern specified.
Templates
Added
SelfServicing: Entity classes now have a flag MappedFieldOnRelationReturnsNewIfNotFound. This flag, default set to true, can be used to signal lazy loading code to return null / Nothing when a related entity is not found in the database (m:1, 1:1 relations). Before, always a new, empty entity was returned when the related entity was not found. The flag is set to true by default to prevent code breakage.
SelfServicing: GeneralEntityFactory class, which generates an EntityFactory instance for the entity type specified.
SelfServicing: DbUtils now has the property ActualConnectionString, which can be set at runtime to overwrite the connection string to use. This setting is global and is used by all calls in the application.
SelfServicing: Stored procedure calls can now be done in an active transaction.
Changed
Adapter / SelfServicing Template set structures are changed, all shared templates are now stored in a SharedTemplates folder.
SelfServicing: When GetMultiManyToOne() is called with solely null / Nothing values for the related entities, GetMulti() is called instead.
Adapter/SelfServicing: RelationsetFields is updated to support aliases for entities as well as aggregates and expressions
Adapter: DataAccessAdapter methods which call stored procedures are made virtual.
SelfServicing:entityFactory.Create()'s internal contents is now an included template. This opens the door for more customized instantiation of entities during multi-entity fetches.
Adapter/SelfServicing: Typed lists / typed views now return the default value for the type of the field if that field's value is NULL
Adapter/SelfServicing: When an FK field is set to a different value, the referenced entity by that FK value is set to null/Nothing
Previous Topic
. A large amount of new features are added to the new runtime libraries and templates, among them: MS Access 2000/XP/2003 support, prefetch paths, paging in entity collections and lists, aggregate function support and sql expression support and much more. Below is the full list of new things.