Symbiotic_Micro_ORM_Net_Standard_x64 3.1.0

.NET Core 2.0 .NET Standard 2.0 .NET Framework 4.6.1
There is a newer version of this package available.
See the version list below for details.
Install-Package Symbiotic_Micro_ORM_Net_Standard_x64 -Version 3.1.0
dotnet add package Symbiotic_Micro_ORM_Net_Standard_x64 --version 3.1.0
<PackageReference Include="Symbiotic_Micro_ORM_Net_Standard_x64" Version="3.1.0" />
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
The NuGet Team does not provide support for this client. Please contact its maintainers for support.
#r "nuget: Symbiotic_Micro_ORM_Net_Standard_x64, 3.1.0"
#r directive can be used in F# Interactive, C# scripting and .NET Interactive. 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

// Install Symbiotic_Micro_ORM_Net_Standard_x64 as a Cake Tool
#tool nuget:?package=Symbiotic_Micro_ORM_Net_Standard_x64&version=3.1.0
The NuGet Team does not provide support for this client. Please contact its maintainers for support.

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.
Read and Write isolation, you must use different object for reads and writes.
Built in history and performance tracking support.
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.

Product Versions
.NET net5.0 net5.0-windows net6.0 net6.0-android net6.0-ios net6.0-maccatalyst net6.0-macos net6.0-tvos net6.0-windows
.NET Core netcoreapp2.0 netcoreapp2.1 netcoreapp2.2 netcoreapp3.0 netcoreapp3.1
.NET Standard netstandard2.0 netstandard2.1
.NET Framework net461 net462 net463 net47 net471 net472 net48
MonoAndroid monoandroid
MonoMac monomac
MonoTouch monotouch
Tizen tizen40 tizen60
Xamarin.iOS xamarinios
Xamarin.Mac xamarinmac
Xamarin.TVOS xamarintvos
Xamarin.WatchOS xamarinwatchos
Compatible target framework(s)
Additional computed target framework(s)
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 161 1/29/2022
3.2.0-rc 128 10/20/2021
3.1.0 402 8/31/2020
3.1.0-rc 325 8/23/2020
3.0.0 690 1/15/2019
3.0.0-rc 504 1/13/2019
2.1.6 707 8/18/2018
2.1.5 787 8/8/2018
2.0.4 820 1/3/2018
2.0.2 892 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 return 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 test

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 abtracted 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

Published Release Candidate

Fixed spelling error in IDataReaderHelper.CheckOverridePropertyUpdate.

Working on nuget release package.

Published release nuget package.