go-xorm/xormArchived

Features

• CRUD Operations - Provides a high-level interface for performing standard create, read, update, and delete operations.
• Object-Relational Mapping - Provides a core mapping layer that converts relational database rows into native Go structures.
• Relational Database Integrations - Integrates Go applications with multiple relational databases including MySQL, PostgreSQL, SQLite, Oracle, and SQL Server.
• Automatic Table Synchronizers - Aligns database table structures and indexes with application data models automatically.
• Column Mappings - Defines column properties and constraints using structural tags on Go data objects.
• MySQL Connectors - Implements a specialized driver for translating object queries into MySQL-compatible SQL syntax.
• Oracle Connectors - Provides a specialized driver to execute compatible queries for Oracle relational databases.
• Database Dialects - Provides a multi-dialect driver layer supporting various database engines with specific syntax handling.
• Database Schema Managers - Automatically synchronizes database table structures and indexes with application data models.
• Fluent Query Construction - Offers a fluent programmatic interface for constructing complex SQL queries and joins.
• Fluent Query Builders - Implements a chainable fluent interface for constructing complex database queries.
• Query Condition Builders - Provides an API for constructing complex SQL WHERE clauses and filtering criteria.
• Raw SQL Execution - Supports executing custom raw SQL statements alongside high-level object-relational mapping.
• Read-Write Splitting - Routes database operations to different servers by splitting read requests to replicas and write requests to the primary.
• Read Load Balancers - Distributes read queries across multiple database replicas using random, round-robin, or weighted policies.
• Schema Synchronizers - Provides a tool to automatically align database schemas with application data models.
• Dialect-Specific SQL Generation - Translates abstract query operations into specific SQL syntax for MySQL, PostgreSQL, SQLite, Oracle, and SQL Server.
• SQL ORMs - Acts as a full-featured relational mapper translating Go structures into SQL queries and vice versa.
• Fluent Interfaces - Offers a fluent interface for constructing complex SQL statements through method chaining.
• Table Joining Operations - Combines data from multiple tables using various join types based on related columns.
• Structure-to-Table Synchronizers - Synchronizes Go application structures with database tables to ensure consistency between code and storage.
• Reflection-Based Mappings - Uses runtime reflection to map relational database rows to native Go structure fields.
• Struct Tags - Maps Go structs to database tables using configuration tags embedded in struct definitions.
• Cursor-Based Iteration - Traverses database records using a cursor to map rows into objects efficiently.
• Incremental Numeric Updates - Enables atomic increments and decrements of numeric columns directly in the database.
• Database Connection Managers - Provides utilities for managing persistent database connections and their lifecycles through sessions.
• Database Lifecycle Hooks - Triggers custom logic before or after database record operations using registered closures.
• Atomic Transactions - Groups multiple database operations into a single atomic unit to ensure data consistency.
• Connection Pool Managers - Manages database connection lifecycles and pool settings wrapped within operational sessions.
• Database Performance Optimizers - Provides performance optimizations including read-write splitting, query caching, and result streaming.
• Record Counting - Implements utilities to calculate the total number of database records matching specific search criteria.
• Concurrency Versioning - Prevents conflicting modifications by automatically incrementing a version field during updates.
• Indexes and Constraints - Includes utilities to create and drop unique constraints and indexes for query performance optimization.
• Read-Write Splitting - Routes modification requests to a primary database and read requests to replicas.
• Optimistic Locking - Prevents concurrent update conflicts by tracking version counts on model instances.
• Result Streaming - Retrieves database rows incrementally via cursors to handle large datasets without memory exhaustion.
• Hybrid Object-SQL Execution - Combines high-level object mapping operations with raw SQL statements within a single execution flow.
• Record Deletion - Provides utilities for removing records based on primary keys or filter conditions.
• Record Insertion - Provides standard interfaces for adding new data records to database tables.
• Record Updating - Provides methods for modifying existing data rows by mapping object fields to columns.
• Relation Loading Strategies - Retrieves associated records from linked tables in a single operation through cascade loading.
• Replica Load Balancers - Includes a manager that distributes read traffic across a pool of database replicas.
• Schema Management - Provides capabilities to programmatically create, drop, and verify the existence of tables and indexes.
• Single Record Retrievers - Offers optimized methods for fetching a single record based on provided object fields.
• Soft Deletion Mechanisms - Implements soft deletion by marking records with a timestamp instead of physical removal.
• Table Creations - Generates database table structures based on provided data models and specified storage engines.
• Table Data Retrieval - Provides mechanisms for retrieving multiple records from a table into slices or maps.
• Column Expression Updates - Allows assigning values to columns using SQL expressions or subqueries during updates.
• Partial Column Updates - Supports updating only designated columns to prevent accidental overwriting of other fields.
• Database Record Hooks - Provides interceptors that trigger custom logic automatically before and after database record operations.
• Database Query Cancellation - Implements database request cancellation and timeout management using Go contexts.
• Database Query Cancellations - Controls database request lifecycles using contexts to implement timeouts and query cancellation.
• Database Drivers and ORMs - Simple and powerful ORM for database operations.
• Database Tools - Versatile ORM supporting multiple relational database systems.
• ORM and Data Mapping - Simple and powerful ORM.

Istoric stele