Symbiotic_Micro_ORM_Net_Standard_x64 3.1.0-rc

This is a prerelease version of Symbiotic_Micro_ORM_Net_Standard_x64.
There is a newer version of this package available.
See the version list below for details.
dotnet add package Symbiotic_Micro_ORM_Net_Standard_x64 --version 3.1.0-rc                
NuGet\Install-Package Symbiotic_Micro_ORM_Net_Standard_x64 -Version 3.1.0-rc                
This command is intended to be used within the Package Manager Console in Visual Studio, as it uses the NuGet module's version of Install-Package.
<PackageReference Include="Symbiotic_Micro_ORM_Net_Standard_x64" Version="3.1.0-rc" />                
For projects that support PackageReference, copy this XML node into the project file to reference the package.
paket add Symbiotic_Micro_ORM_Net_Standard_x64 --version 3.1.0-rc                
#r "nuget: Symbiotic_Micro_ORM_Net_Standard_x64, 3.1.0-rc"                
#r directive can be used in F# Interactive and Polyglot Notebooks. Copy this into the interactive tool or source code of the script to reference the package.
// Install Symbiotic_Micro_ORM_Net_Standard_x64 as a Cake Addin
#addin nuget:?package=Symbiotic_Micro_ORM_Net_Standard_x64&version=3.1.0-rc&prerelease

// Install Symbiotic_Micro_ORM_Net_Standard_x64 as a Cake Tool
#tool nuget:?package=Symbiotic_Micro_ORM_Net_Standard_x64&version=3.1.0-rc&prerelease                

Supported databases: Sql Server, Sql Azure, My Sql, Sqlite, Oracle, PostgreSql, DB2\LUW, Firebird.
Fast, small and simple, and very little code needed to perform database actions.
Ability to write and run all code unchanged on multiple database vendors.
No configuration, no mapping files, no inheritance requirements, no object tracking or caching, just objects and code.
Supports writes, updates, or upserts with out the need to write sql, just write your queries for the parent objects.
Totally disconnected writes, they can move across application boundaries.
Write your own queries, the orm just maps the results.
Full transaction support, make multiple calls inside a single transaction.
Error tracking, extensive commitment to helping developers understand all exceptions thrown, extensive detailed error messages are provide when possible.
Supports change tracking, so the database is only involved when you decide it's necessary.
Encryption, allows data to be encrypted prior to writes, and allows un-encryption with loads.
Validation support, extensive support for System.ComponentModel.DataAnnotations with the ability to extend and create custom validation with enforcement from the orm.
Processing Intercept Support, do special work prior to insert, update, or delete, or after load.
Parallel support, run multiple queries in parallel to increase performance.
Debugging, all sql is traced out with the parameters and values to aid trouble-shooting. Queries can contain locators which are provided in exceptions.
Developer control, all the object creates are overidable, and most methods can be overridden.
Supports mutable flat, pure immutable types or hierarchical objects, or objects with children or child properties.
Interface abstraction by allowing you to query and retrieve interface types while loading concretes types. you don't need to sacrifice your abstraction design.
Concurrency support, prevent stale writes and the ability to catch exceptions.

Product Compatible and additional computed target framework versions.
.NET net5.0 was computed.  net5.0-windows was computed.  net6.0 was computed.  net6.0-android was computed.  net6.0-ios was computed.  net6.0-maccatalyst was computed.  net6.0-macos was computed.  net6.0-tvos was computed.  net6.0-windows was computed.  net7.0 was computed.  net7.0-android was computed.  net7.0-ios was computed.  net7.0-maccatalyst was computed.  net7.0-macos was computed.  net7.0-tvos was computed.  net7.0-windows was computed.  net8.0 was computed.  net8.0-android was computed.  net8.0-browser was computed.  net8.0-ios was computed.  net8.0-maccatalyst was computed.  net8.0-macos was computed.  net8.0-tvos was computed.  net8.0-windows was computed. 
.NET Core netcoreapp2.0 is compatible.  netcoreapp2.1 was computed.  netcoreapp2.2 was computed.  netcoreapp3.0 was computed.  netcoreapp3.1 was computed. 
.NET Standard netstandard2.0 is compatible.  netstandard2.1 was computed. 
.NET Framework net461 is compatible.  net462 is compatible.  net463 was computed.  net47 was computed.  net471 is compatible.  net472 is compatible.  net48 was computed.  net481 was computed. 
MonoAndroid monoandroid was computed. 
MonoMac monomac was computed. 
MonoTouch monotouch was computed. 
Tizen tizen40 was computed.  tizen60 was computed. 
Xamarin.iOS xamarinios was computed. 
Xamarin.Mac xamarinmac was computed. 
Xamarin.TVOS xamarintvos was computed. 
Xamarin.WatchOS xamarinwatchos was computed. 
Compatible target framework(s)
Included target framework(s) (in package)
Learn more about Target Frameworks and .NET Standard.

NuGet packages

This package is not used by any NuGet packages.

GitHub repositories

This package is not used by any popular GitHub repositories.

Version Downloads Last updated
3.2.1 1,513 1/29/2022
3.2.0-rc 1,125 10/20/2021
3.1.0 1,628 8/31/2020
3.1.0-rc 1,399 8/23/2020
3.0.0 1,958 1/15/2019
3.0.0-rc 1,600 1/13/2019
2.1.6 1,906 8/18/2018
2.1.5 1,984 8/8/2018
2.0.4 2,033 1/3/2018
2.0.2 2,065 9/12/2017

Release 3.1.0

There is significant changes in this release, so caution should be taken when moving to this release.
The current set of unit test for the existing and new functionality passed.

Most of the features in this release center around supporting true Immutable types,
all creations are done using the constructor including the returned objects to provide the primary key updates and timestamps.
The immutable portion of the new code-base does have some upfront costs, so consideration should be taken before using them.
With the current design it is possible to use both approaches Non Immutable types and Immutable types for the same schema and take advantage of both scenarios.

The new Immutable writer API is a bit different as it uses request objects, this reduces the baggage of overloading
and I plan to create a new write API for the non immutable types to match.

There has been some refactoring, bug fixes and minor feature enhancements also.

Support for IDatabaseDefineSupport was removed as the instance is no longer used to perform reflection and it now uses the type.
This was done to reduce and eliminate the need to create unneeded instances in various parts of the code-base.
I don't think IDatabaseDefineSupport feature is used by developers. If you are using this let me know and I will figure-out a
possible work-around; The developer can override IDatabaseTypesFactory.CreateObjectDatabaseMapper
and create a custom IObjectDatabaseMapper, the current implementation ObjectDatabaseMapper just wraps the ObjectReflector to allow developer overrides.

Reviewed/Modified data providers to default to a data type of string for unknown database vendors data type mappings, instead of throwing exception.
This fix is for Symbiotic Helper. Not used by the ORM.
Fixed an issue for MySql data provider where it was returning Tables/Columns from all databases. Thanks Ned S.

Added ParallelOptions to DatabaseActionParallelList to allow developers to control the parallel settings.

Thinking about possibilities of automatic relationships with-out the need for any attributes.

Working on support for population by constructors to allow support for immutable objects.
Constructor must be decorated with the PopulationConstructor Attribute.

I have had immutable flat objects support working for a week or more. Currently researching hierarchical immutable objects support.
During the progress of immutable objects support I refactored the reflections code to avoid creation of objects that are to be persisted or loaded, this will reduce unnecessary object creations.

Had a user who wanted to use a binary column. Added support using a Byte array property type. The Sql Server column type used for testing was varbinary(max).
Seems to be working but more testing is need on other databases.

Refactored the DataReaderHelper class usage, there is now a IDataReaderHelper interface which can be overridden from IDatabaseTypesFactory.CreateDataReaderHelper() method.
This allows then developer to override setting the property values from the database values. There is also a method to allow overriding specific property updates by overriding the IDataReaderHelper.CheckOvrridePropertyUpdate() method.

Refactored Sql validation into a set of ISqlValidationRule derived classes.
This allows the developer to create new sql validation rules and then add them to the current working set.
The rules are obtained from IDatabaseTypesFactory.ObtainSqlValidationRules() method and then added to the ISqlQuery.ValidationRules to use when validating the sql.
Still working on Flat Immutable types, adding support for existing various feature interfaces.

Have RowVersions working for immutable types, what a pain. Doesn't help that the Visual Studio visualizers don't show UTC & Local views.
Added { RowVersionLocal={RowVersion.ToLocalTime()} to the DebuggerDisplay attribute on the poco, that helps.

Have change tracking support working for immutable types, uses a new immutable interface IImmutableChangeTrackingSupport.

Have Guid primary keys working for immutable types.

Adding support for Parallel loads for immutable types.

Parallel loads for immutable types are working.
Improved performance tracking descriptions.

Added support for Parallel Load Abstract Items, and Load Abstract Items for immutable types.
Added support for Insert Update Immutable and IEnumerable collections.

Refactored IImmutableObjectLoader and IImmutableObjectWriter to remove IDatabaseTypesFactory parameters, it's not needed as it's provided in the constructor.
Code Analysis cleanups.

Added encryption support for immutable objects.

Refactored the IImmutableObjecttWriter and implements. Created request interfaces to improve caller options and reduce overloads.

Re-worked the performance tracking for immutable types. The ORM now adds the IPerformanceItem data to the ISqlQuery and Request objects.

Re-visiting Immutable Hierarchy support to see if I can add support in this release.

Working on Immutable Hierarchy support, very close to having reads working.

Immutable Hierarchy reads seems to be working, needs more testing and some code refactoring. Seems to be about 100 milliseconds fatser than mutable objects.
Return order is different due to threading, but I think I can resort them based on row order to maintain the query order.

Fixed the Immutable Hierarchy return order.

Refactoring Immutable Hierarchy load code.
Fixed bug for missing data on non list child object loads, no data issue.

Working on Immutable Hierarchy writes.

Basic functionality of Immutable Hierarchy writes are working. Related child id updates working also.
Immutable Hierarchy deletes still need to be built.

working on Immutable Hierarchy deletes.

Immutable Hierarchy deletes are working.
Working on individual Child delete support.

Individual child delete test working for relation tables. Need to verify in database.
Other relationship types need unit tests.

Verified the the child was deleted and also the relationship.
Improved unit test to check relationship is deleted.
Started building unit tests for other relationship types.

Writing tests for GUID relationshipts.

Finished Immutable guid hierarchy Relation Table tests
Finished Immutable guid primary key (flat objects) tests
Finished Immutable guid hierarchy Relations One To Many test

Featured Wanted: Ability to use interfaces and provide concrete types.
So the list type can be an interface but gets populated with concrete types implementing the interface.

Bug Found a when using relationships One To Many (DatabaseRelationOneToMany), in some case will return extra child records due to multiple primary keys, depends on the reflection order return of the attribute.
Working on a fix. I also improve the unit tests to check child records.
Was found when writing unit tests for Immutable version, re-checked non-Immutable functionality and discovered it existed there also.

Fixed bug Found a when using relationships One To Many (DatabaseRelationOneToMany)
Added a overload to the DatabaseColumn attribute. Child properties must include IsChildPrimaryKey = true.
<DatabaseColumn("ChildId", IsPrimaryKey:=True, IsIdentityColumn:=False, IsChildPrimaryKey:=True)>
Finished Immutable indentity hierarchy Relations One To Many tests.

Started working on Immutable Hierarchy Guid Relation One To One

Fixed a concurrency bug in Hierarchy parent deletes for relationship types that do not have relationship records.
RelationshipType.OneToMany, RelationshipType.OneToOne, RelationshipType.SingleObject

Improving unit tests, adding more confirmation code of changes, and more delete and update changes.

Improved exception handling for ImmutableObjectWriter, ObjectHierarchyWriter and ObjectWriter for consistant handling for IErrorFeedbackSupport and transaction rollbacks and close.
Finished tests for Immutable Hierarchy Guid Relation One To One relationships.

Finished tests for Immutable Hierarchy Identity One To One relationships.

Looking at support for interface abstraction, and including collection of abstracted types.

Added support for interface abstraction. Needs more tests.

Writing tests for interface abstraction.

Writing tests for interface abstraction.
Reviewing create instance code and reviewing related existing api.

Created IDeprecationManager to abstract the DeprecationManager to allow developers to create a custom or derrived IDeprecationManager.

Testing interface abstraction. Found and fixing a few issues related to hierarchy objects.

Interface abstraction loads are now working for hierarchy objects.

Created IDataTypeMap to abstract the DataTypeMap to allow developers to create a custom or derrived IDataTypeMap.
Refactored IDatabaseTypesFactory.PropertyTypeToDatabaseType method to use the DataTypeMap/IDataTypeMap interface implementation.

Working on Nuget package