dotnetcore/FreeSql

Features

• CRUD Operations - Performs standard create, read, update, and delete actions using parameterized SQL and dynamic conditions.
• Fluent Query Builders - Implements a chainable, functional interface for constructing complex database queries with joins and subqueries.
• Object-Relational Mapping - Provides a comprehensive system to map .NET objects to relational database records across multiple providers.
• Bulk Data Ingestion - Implements high-performance bulk data ingestion using provider-specific copy mechanisms and staging tables.
• Transactional Grouping - Bundles multiple repository actions into a single transaction to ensure atomic completion of data operations.
• Column Mappings - Provides configurations to map application class properties to specific database columns.
• Conditional Updates - Translates filtered queries into update statements to modify specific database records.
• Custom Type Handlers - Provides programmable handlers to translate complex application object types to and from database formats.
• Sharding Routing Logic - Directs data operations to specific shards using runtime naming patterns and dynamic table suffixes.
• Query Projections - Projects database query results directly into custom Data Transfer Objects to optimize data retrieval.
• Complex Data Type Mappings - Translates high-level .NET structures, such as arrays and JSON objects, into database-specific formats.
• Database Dialect Adapters - Interfaces with multiple relational databases by translating generic queries into engine-specific SQL syntax and dialects.
• Database Index Management - Creates and manages unique or non-unique indices on columns to optimize query performance.
• Database Connection Configurations - Configures connection strings, pools, factories, and read-replica slave databases for system connectivity.
• Database-Level Tenant Isolations - Provides database-level isolation by routing tenant-specific queries to dedicated database instances based on the active context.
• Fluent Query Builders - Offers a type-safe fluent API for constructing complex SQL queries with joins, subqueries, and window functions.
• Database Pagination Adapters - Implements offset and limit mechanisms to paginate large datasets across different database dialects.
• Database Provider Integrations - Interfaces with various third-party database drivers and custom provider implementations for cross-platform compatibility.
• Relational Record Fetching - Retrieves related records as nested collections within a single request for efficient relational data fetching.
• ORM Schema Synchronization - Automatically aligns database table and index structures with application-level entity definitions.
• Automated Table Sharding - Splits large datasets into multiple tables based on time intervals and column values.
• Shard Routing Logic - Implements logic to direct database queries and connections to specific shards to distribute load and manage data partitioning.
• Database Traffic Management - Distributes database load through integrated read-write splitting, dynamic table sharding, and tenant-based isolation.
• Primary Keys - Specifies unique identifiers for records, supporting composite keys and automatic ID generation.
• Entity CRUD Management - Manages the full CRUD lifecycle of entities and their related child objects.
• Lambda Expression Filters - Translates lambda expressions into SQL WHERE clauses to support complex filtering logic.
• Global Data Filters - Applies universal query constraints to automate data isolation, such as multi-tenancy or soft-deletion.
• JSON Persistence Mapping - Automatically serializes and deserializes complex objects to and from native JSON columns in the database.
• Related Data Loading Strategies - Provides diverse strategies for loading associated entities, including both eager and lazy loading.
• Read-Write Splitting - Routes read operations to replicas and write operations to a primary master database.
• Object-Relational Mappers - Functions as a .NET object-relational mapper translating object-oriented code into SQL for multiple database providers.
• Object-Relational Mapping Associations - Defines and manages associations and foreign key relationships between entities for automated joining and persistence.
• Lambda Querying - Provides the ability to retrieve records using lambda expressions for filtering, sorting, and pagination.
• Record Deletion - Removes records from the database using primary keys, object instances, or custom lambda expressions.
• Record Insertion - Adds records to database tables and retrieves auto-incremented identity values.
• Record Updating - Modifies existing rows using specified columns, lambda expressions, or raw SQL fragments.
• Read Load Balancers - Distributes read queries across multiple database replicas using weighted load balancing to improve throughput.
• Multi-Database Providers - Supports multiple database backends through a unified API, abstracting SQL dialects behind a common interface.
• Expression Tree Translation - Converts .NET lambda expressions and expression trees into database-specific SQL syntax via a customizable parsing engine.
• Entity Mappings - Provides rules and configurations for mapping application objects to database tables and columns using attributes and fluent APIs.
• Connection Management - Manages database connection strings, pooling, and custom connection factories to optimize connectivity.
• AOT-Compatible ORMs - Designed to function without runtime reflection to enable native ahead-of-time deployment for reduced memory and faster startup.
• Database Schema Migrations - Automatically generates and applies database schema updates based on entity definitions in the code.
• Database Traffic Routing - Routes read and write requests across distributed database nodes to manage traffic and load.
• Reflection-Free Runtime Execution - Optimizes runtime performance by replacing reflective lookups with direct method calls to support Native AOT.
• Audit Fields - Automatically populates record creation and modification timestamps and user IDs during database operations.
• Read-Only & Unknown Column Controls - Controls whether specific columns are treated as read-only or insert-only during database operations.
• Multi-Column Tuple Filters - Filters records by matching multiple columns simultaneously against a provided collection of value tuples.
• SQL Overrides - Allows overriding automatically generated SQL for specific columns to support specialized data types.
• Raw SQL Execution - Executes direct SQL queries and stored procedures with parameter binding.
• Raw SQL Update Operations - Runs raw SQL update statements with parameterized inputs for precise manual query control.
• JSON-to-SQL Filter Translation - Translates structured JSON objects into SQL filter clauses to enable frontend-driven querying.
• JSONb Path Querying - Provides the ability to execute queries against JSONB columns using lambda expressions for membership checks.
• Database Command Interceptors - Implements hooks to intercept and modify database commands for auditing, value modification, and expression parsing.
• Connection Object Extensions - Adds fluent CRUD capabilities directly to standard database connection and transaction objects.
• Dynamic Logic Filtering - Parses JSON-based filter definitions into SQL WHERE clauses to enable complex dynamic filtering.
• Complex Type Querying - Translates operations on arrays, dictionaries, and JSON objects into database-specific SQL functions.
• In-Memory Joins - Implements the capability to join local in-memory collections with remote database tables within a single query.
• Database Record Auditing - Records a detailed history of data mutations by capturing old and new property values during updates.
• Database Schema Inspection - Programmatically retrieves runtime metadata regarding database tables, columns, keys, and indexes from a live database.
• Distributed Database Clusters - Coordinates data access and transactions across multiple database instances using a registration system for horizontal scaling.
• SQL Rewriting - Intercepts and modifies generated SQL strings at runtime to handle custom type conversions.
• Event Interception - Triggers custom business logic before or after CRUD operations using AOP-driven event interception.
• Existence Subquery Generators - Generates SQL EXISTS clauses to restrict results based on the presence of a value in a subquery.
• Group-By Aggregations - Organizes results by specific columns and applies aggregation functions to calculate sums and counts.
• Bulk Data Ingestion - Provides high-throughput transfer of large data volumes using provider-specific native copy protocols.
• Bulk ORM Operations - Performs high-speed bulk inserts, updates, and deletes for millions of records using ORM-level batch operations.
• Object Relation Lazy Loading - Postpones the retrieval of related data objects until they are explicitly accessed in the application code.
• Local Change Tracking - Records additions and deletions on a local collection and persists them in a single atomic operation.
• Relationship Synchronization - Synchronizes one-to-many and many-to-many navigation collections by comparing current state with the database.
• Many-to-Many Relationship Managers - Synchronizes associations between entities via intermediate pivot tables by comparing current state with the database.
• Optimistic Concurrency Control - Prevents data loss by verifying version columns or timestamps before saving updates.
• Partial Entity Updates - Updates only modified properties of a database entity by comparing current values against an original state snapshot.
• Subquery Aggregations - Calculates scalar aggregate values from related records within a subquery for every row in a result set.
• Eager Loading - Retrieves related entities in a single query to prevent N+1 performance issues.
• Query-to-Update Conversions - Translates selection queries involving joins or navigation objects into update statements to modify records.
• Result Streaming - Fetches data in chunks using asynchronous streams to minimize memory consumption for large result sets.
• Dynamic Result Sorting - Orders query results using runtime strings that map to entity or navigation properties.
• Join-Wide Filters - Applies consistent filter conditions across all tables involved in a multi-table join.
• Raw SQL Execution - Runs custom SQL strings to retrieve entity lists or perform secondary queries.
• Parameterized SQL Snippets - Integrates parameterized SQL fragments into where, group by, and order by clauses.
• Raw SQL Result Mapping - Maps the output of arbitrary raw SQL strings directly into typed object entities.
• SQL-Based Subqueries - Integrates raw SQL strings or in-memory collections as data sources within the fluent query building process.
• SQL Snippet Embedding - Integrates custom query snippets into fluent chains to handle complex logic or unions.
• Read-Write Splitting - Implements routing strategies that separate read operations to replicas and write operations to a primary master database.
• Bulk Record Insertions - Inserts many model instances in one database query with managed batch sizing to prevent overflows.
• Upsert Operations - Inserts new records or updates existing ones based on unique key conflicts.
• Extension Method Mapping - Maps extension methods to specific database functions to support specialized syntax in queries.
• Graph Persistence - Persists a primary entity and its associated navigation objects across relationships in a single operation.
• Operation Performance Monitoring - Intercepts CRUD operations to log execution time and trigger performance alerts for database optimization.
• Dynamic Tuple and Table Retrieval - Returns query results as dynamic tables or tuples based on specified property names or raw SQL columns.
• Select-Based Insertions - Copies data from one table to another by executing an insert based on select results.
• Recursive CTE Queries - Retrieves parent-child relationship data as a tree structure using recursive Common Table Expressions (CTEs).
• Index Hints - Forces the database to use specific indexes for queries to optimize execution speed.
• SQL Execution Logging - Intercepts and logs executed SQL statements to facilitate debugging and performance tuning.
• SQL IN Clause Generation - Automatically constructs SQL IN clauses to filter records against a list of values while managing database limit constraints.
• Custom Method Mappings - Maps high-level programming methods to specific SQL strings tailored for different database providers.
• SQL Schema Generators - Generates the SQL statements required to align the database schema with current code definitions.
• SQL Translation Layers - Translates high-level .NET functional logic and operations into executable SQL queries for various database providers.
• Subquery Result Aggregations - Concatenates multiple rows from a subquery into a single delimited string for each record in the primary query.
• Join-Based Updates - Modifies data in one table based on matching values found in another related table through a join.
• Runtime Property Resolution - Resolves database table names and loading paths dynamically using property names at runtime.
• Time-Series Aggregations - Summarizes large datasets into homogeneous time blocks using specialized aggregation keywords.
• Time-Series SQL Querying - Provides SQL-based interfaces optimized for retrieving the most recent records from time-stamped datasets.
• Joined Bulk Updates - Streams large datasets into temporary tables and performs joined updates to process records efficiently.
• Upsert Operations - Provides atomic operations that either insert a new record or update an existing one based on a unique key.
• Window Functions - Supports SQL window functions to calculate rankings, row numbers, and aggregates over specific result set partitions.
• Temporary Table Staging - Streams high-volume data into ephemeral database tables to optimize high-volume merge or update operations.
• Modified Field Tracking - Generates SQL updates containing only modified fields by comparing objects against original snapshots.
• Entity Definition Generators - Generates strongly-typed .NET entity classes automatically from existing database schemas using templates.
• Delayed Task Scheduling - Triggers one-time tasks after a specified time delay without requiring an external database.
• Distributed Task Coordinators - Coordinates task execution across multiple application instances to prevent duplicate work using shared state.
• Recurring Job Scheduling - Creates persistent tasks that execute at fixed intervals using standard timing expressions.
• Database File Encryption - Protects data at rest using password-based symmetric encryption via specific database driver bundles.
• Role-Based Access Control - Assigns permissions for menus and buttons to users and roles through relational mapping.
• Batch Entity Updates - Updates multiple database records simultaneously by mapping a collection of objects to a table via primary keys.
• Distributed Transaction Management - Coordinates data consistency across distributed database instances using TCC and SAGA patterns.
• Database Schema Code Generators - Produces object-oriented entity classes and DTOs automatically based on database metadata and table structures.
• Automated Value Generation - Modifies property values during insertion or update to automate ID generation and timestamps.
• Unit of Work Patterns - Tracks object changes during a business transaction to commit or rollback all operations as one unit.
• Object Relational Mappers - Convenient ORM supporting a wide range of database providers.

Star-Verlauf