esentio/Yamo

Yamo is a .NET ORM library that provides a DbContext-based API for interacting with SQL Server and SQLite databases. It supports complex query construction with joins, subqueries, and set operators, alongside features like entity change tracking, soft deletes, and dialect-specific SQL generation. The system includes comprehensive test coverage and performance benchmarks against other ORMs, distributed as NuGet packages.

21 changes.

This period marks the initial creation of the Yamo ORM library, establishing its core infrastructure, metadata models, and SQL expression builders for SQL Server and SQLite. The work included reorganizing the solution structure for .NET Core compatibility and implementing comprehensive unit and integration tests to validate the new database interaction capabilities.

12 changes.

This period focused on establishing official NuGet package distribution and expanding the ORM's compatibility with SQLite and SQL Server through dialect-specific SQL generation. Comprehensive test suites were added for both databases to validate core operations and new type support, while sample projects were expanded to demonstrate advanced LINQ features and multi-language usage.

New batch scripts (pack.bat and push.bat) have been added to the Source/Nuget directory to streamline the build and distribution process. pack.bat now builds the Yamo, Yamo.SQLite, and Yamo.SqlServer projects in Release mode and outputs the resulting NuGet packages to the Setup directory. push.bat allows users to input an API key and push the generated packages (specifically version 0.10.1) to the NuGet.org feed.

Source/Nuget · high confidence

A new VB.NET playground sample (Source/Samples/Yamo.Playground.VB) has been added, demonstrating the library's support for join subqueries. The sample includes entity models for Blogs, Comments, Articles, and Labels, along with a DbContext configuration and a Test class that exercises various Where clause scenarios. Notably, the Program.vb file contains a query example using a subquery within a Join operation to filter Articles based on aggregated category counts, showcasing this specific expression enhancement.

Source/Samples/Yamo.Playground.VB · high confidence

The C\# playground sample project has been significantly expanded to demonstrate a wider range of Yamo ORM capabilities. New entity models have been added for Articles, Blogs, Categories, Users, and Persons, including complex relationships and property modification tracking. The context configuration now supports advanced features such as automatic timestamp handling for insert, update, and delete operations, and custom SQL dialect helpers for date functions. The sample code includes extensive test cases covering raw SQL execution, parameterized queries, transactions, and LINQ-style expression building.

Source/Samples/Yamo.Playground.CS · high confidence

The query builder in the Expressions namespace now supports SQL set operators (UNION, UNION ALL, EXCEPT, INTERSECT) on SELECT, DISTINCT, and custom select expressions, allowing users to combine result sets. Additionally, filtered select expressions now expose GroupBy, OrderBy, OrderByDescending, and Limit methods, enabling users to aggregate, sort, and restrict the number of rows returned by their queries directly through the fluent API.

Source/Source/Yamo/Expressions · high confidence

The library now supports SQLite as a database provider. This change introduces the core infrastructure components required to interact with SQLite, including a dialect provider, SQL formatter (configuring specific behaviors like string concatenation via \|\| and LIKE wildcard handling), and an entity SQL string provider factory that generates appropriate INSERT statements for SQLite's identity column handling.

Source/Source/Yamo.SQLite/Infrastructure · high confidence

This change introduces the core SQL expression builder components for the Yamo ORM, including \SelectSqlExpressionBuilder\, \InsertSqlExpressionBuilder\, \UpdateSqlExpressionBuilder\, and \DeleteSqlExpressionBuilder\. These classes provide the infrastructure for constructing SQL queries for standard database operations, supporting features such as table name overrides, table hints, soft deletes, and parameterized where clauses. The implementation also includes a base class \SqlExpressionBuilderBase\ for shared functionality and a \SqlExpressionBuilder\ for raw SQL execution, establishing the foundation for the library's query generation capabilities.

Source/Source/Yamo/Expressions/Builders · high confidence

This change introduces the internal metadata infrastructure for the Yamo ORM's query engine, establishing the foundational classes required to represent and process SQL statements. It adds specific models for SELECT, UPDATE, and DELETE operations, along with a base model hierarchy. The diff includes support for complex query structures such as joins (with types for inner, outer, and cross joins), subqueries, and set operators (UNION, EXCEPT, INTERSECT). It also enables ad-hoc and anonymous type projections in custom SELECT queries, allowing users to map results to non-model types, and provides the necessary entity and result metadata classes to handle column mapping, aliases, and relationship navigation during query execution.

Source/Source/Yamo/Internal/Query/Metadata · high confidence

This change introduces the Yamo ORM library, providing a DbContext-based API for database interactions. It includes configuration options for SQL dialects and connections, and supports executing raw SQL with parameters. The library enables building complex SELECT statements with joins (supporting up to 16 tables), filtering, sorting, and subqueries. It also features collection navigation filling behaviors, entity change tracking via IHasDbPropertyModifiedTracking, and lifecycle hooks through IInitializable and ISupportDbLoad interfaces.

Source/Source/Yamo · high confidence

This change introduces the core metadata classes for the Yamo ORM, including Entity, Property, Model, and relationship navigations (ReferenceNavigation and CollectionNavigation). These classes define the structure for mapping .NET entities to database tables, handling properties, keys, identity columns, and 1:1 or 1:N relationships. The Property class also introduces support for specifying a specific DbType for column values.

Source/Source/Yamo/Metadata · high confidence

Added a new SqlServerDialectProvider that enables the library to interact with Microsoft SQL Server databases. This provider configures the necessary SQL formatters, entity and value type readers, and registers dialect-specific helpers for expressions and DateTime operations, supporting both TOP and OFFSET FETCH row-limiting syntaxes.

Source/Source/Yamo.SqlServer/Infrastructure · high confidence

The metadata builder API in the Source/Source/Yamo/Metadata/Builders directory has been implemented, providing a fluent interface for defining database mappings. Users can now configure entity table names and schemas via EntityBuilder, and define property details such as column names, primary keys, identity columns, default values, nullability, and specific database types (DbType) using PropertyBuilder. Additionally, the API supports configuring entity relationships, allowing users to define both single-reference and collection-based navigations through ReferenceNavigationBuilder and CollectionNavigationBuilder.

Source/Source/Yamo/Metadata/Builders · high confidence

The Yamo SQL layer now includes dedicated helper classes that allow users to build more complex queries using expression-based syntax. The new Aggregate class provides methods for COUNT, SUM, AVG, STDEV, MIN, and MAX (including DISTINCT variants). The Exp class adds support for raw SQL injection (Raw), type casting (As), and conditional logic like COALESCE, ISNULL/IFNULL, NULLIF, and IIF. Additionally, the DateTime class offers helpers for retrieving current database dates and comparing datetime components (year, quarter, month, day, etc.). These helpers are integrated into the query builder infrastructure via the new SqlFormat and SqlHelper base classes.

Source/Source/Yamo/Sql · high confidence

The benchmarks project now includes a comprehensive set of performance tests comparing Yamo against Dapper and Entity Framework Core. The suite covers single-record retrieval, bulk selection of 1,000 records, and complex joins (one-to-one and one-to-many), with options to run against either SQL Server or SQLite. It also introduces a 'handcoded' baseline using raw ADO.NET DataReaders to establish a lower-bound performance reference.

Source/Benchmarks · high confidence

This change introduces the core database infrastructure for the Yamo ORM, adding the DatabaseFacade to manage connections and transactions, and a suite of factory classes (EntityReaderFactory, EntitySqlStringProviderFactory, EntityAutoFieldsGetterFactory, etc.) that use expression trees to generate high-performance SQL and object mapping logic. It also adds the LimitType enum to support row-limiting clauses and the PostProcessorFactory to handle post-load hooks for entities implementing IHasDbPropertyModifiedTracking and ISupportDbLoad.

Source/Source/Yamo/Infrastructure · high confidence

This change introduces \MaybeNullAttribute\ and \DisallowNullAttribute\ definitions for the NETSTANDARD2\_0 target to support nullable reference type analysis, and adds internal extension methods for \Expression\ (to extract property names and types) and \String\ (to retrieve values with defaults or handle null/empty/whitespace states). These are infrastructure improvements intended to aid static analysis and internal code safety rather than exposing new user-facing capabilities.

Source/Source/Yamo.SQLite, Source/Source/Yamo.SqlServer, Source/Source/Yamo/Internal/Extensions · high confidence

SQLite and SQL Server providers now include dedicated SQL helper classes that translate date/time comparison methods (such as SameYear, SameMonth, SameDay, and GetCurrentDateTime) and null-handling expressions (IsNull/IfNull) into the correct native SQL syntax for each database engine. This ensures that LINQ expressions involving date comparisons and null checks are compiled into valid, optimized SQL for the specific database being used.

Source/Source/Yamo.SQLite/Sql, Source/Source/Yamo.SqlServer/Sql · high confidence

The code generator in Yamo.CodeGenerator now produces additional overloads for join methods (Join, LeftJoin, RightJoin, FullJoin, CrossJoin) and the conditional If method. These generated methods support predicates targeting individual entities, all entities, or joined entity sets (IJoin), and accept raw SQL strings, FormattableStrings, and subqueries as join conditions. The If method now includes logic to handle optional otherwise branches and create result types when conditions are not met, improving the flexibility of conditional query building.

Source/Source/Yamo.CodeGenerator · high confidence

This change introduces a new set of internal helper classes within the Yamo framework to support advanced type inspection and expression generation. The \Types\ helper provides logic to identify and flatten ValueTuples (including nested and nullable variants), detect anonymous types, and check for nullable value access, enabling the ORM to handle complex query result shapes. The \Common\ helper adds mapping for join member names (T1–T25), supporting queries across up to 25 tables. Additionally, \Expressions\ provides utilities for creating debug write-line expressions, and \Text\ offers optimized string joining methods. These components form the underlying infrastructure for features like querying large value tuples and multi-table joins.

Source/Source/Yamo/Internal/Helpers · high confidence

The Yamo ORM now includes a suite of internal cache classes (EntityAutoFieldsGetterCache, EntityAutoFieldsSetterCache, EntityReaderCache, EntitySqlStringProviderCache, MemberCallerCache, MemberSetterCache, ModelCache, and PostProcessorCache) to optimize performance by caching delegates and metadata for entity reading, writing, and SQL generation. These changes support new expression handling capabilities, including ternary conditional and null-coalescing operators, bitwise and shift operators, and ad-hoc table name overrides, while also fixing issues with collection navigation property filling and boolean comparison expansion.

Source/Source/Yamo/Internal · high confidence

The internal query execution logic has been restructured to use a new set of result reader data classes (such as AutoModeSqlResultReaderData, EntitySqlResultReaderData, and AdHocTypeSqlResultReaderData) and a dedicated QueryExecutor. This change introduces a ChainKey structure for more robust grouping of related entities in complex queries and updates the QueryFirstOrDefault and QueryList methods to leverage this new infrastructure, improving how the library reads and maps SQL results to objects.

Source/Source/Yamo/Internal/Query · medium confidence

The Yamo solution file has been restructured to support the migration of test, playground, and benchmark projects to .NET Core. This change introduces a new solution layout that groups projects into Source, Test, Samples, Benchmarks, and Nuget folders, and adds new project references for the code generator and separate test suites for VB and C\#, aligning the build configuration with the updated .NET Core targets.

Source · high confidence

Added SQL Server test database initialization and cleanup scripts; Added SQL Server test infrastructure and configuration; Added SQL Server-specific test suite; Added SQLite test database schema scripts; Added SQLite-specific test coverage for DateOnly, TimeOnly, and Char column types; Added SQLite-specific test suite for Yamo ORM; Added expression translation tests for C\# and VB.NET; Added integration tests for Yamo ORM core operations; Added test helper utilities for data generation and comparison; Added test models and infrastructure for Yamo ORM; Added unit test infrastructure for Yamo.

The project has been upgraded to target .NET 10.0 across all projects, including the core library, database providers (SQLite, SQL Server), benchmarks, playgrounds, and test suites. This change updates the target framework to net10.0 and refreshes NuGet package references to compatible versions, such as Microsoft.EntityFrameworkCore 10.0.2, Microsoft.Data.SqlClient 6.1.4, Microsoft.Data.SQLite 10.0.2, and Microsoft.SourceLink.GitHub 10.0.102. The core Yamo library also now conditionally references Microsoft.Bcl.HashCode 1.1.1 for netstandard2.0 compatibility.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 41 → 41 (+0.1)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 70 → 70 (+0.0)
• Architecture 96 → 96 (+0.3)
• Maturity 46 → 46 (+0.0)
• Readiness 29 → 29 (+0.0)
• Security 42 → 42 (+0.3)
• Performance 75 → 75 (+0.0)

• Documentation: no contributor guidance (README.md)
• Documentation: no installation or build instructions (README.md)
• Documentation: no usage examples (README.md)

• Unchanged — 2 containers · 0 contexts · 0 edges

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

esentio/Yamo was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.