go-gorm/gorm

Features

• Database Transactions - Provides a structured API for executing atomic database operations to ensure data consistency and integrity.
• Object-Relational Mappers - // Get all recordsresult := db.Find(&users)// SELECT FROM users;result.RowsAffected // returns found records count, equals len(users)result.Error // returns error
• Object-Relational Mapping - Manages complex object relationships by automatically tracking and synchronizing linked records during create, update, and delete operations.
• Query Builders - A fluent interface for constructing complex SQL statements programmatically while maintaining type safety and preventing common injection vulnerabilities.
• Database Abstraction Layers - Provides a unified abstraction over various database dialects to ensure consistent query execution across different underlying storage engines.
• Database Transaction Management - GORM perform write (create/update/delete) operations run inside a transaction to ensure data consistency, you can disable it during initialization if it is not required, you will gain about 30%+ performance improvement a
• Batch Data Processing - To efficiently insert large number of records, pass a slice to the Create method. GORM will generate a single SQL statement to insert all the data and backfill primary key values, hook methods will be invoked too. It w
• Connection Managers - Database connection management establishes secure links to external storage systems by initializing drivers with connection strings and configuration settings for reliable communication.
• Object-Relational Mapping Associations - GORM automates the saving of associations and their references when creating or updating records, using an upsert technique that primarily updates foreign key references for existing associations. ### Auto-Saving Associa
• Persistence Frameworks - A structured environment for defining database schemas as code and automating the synchronization of application state with storage.
• Query Condition Builders - String Conditions // Get first matched recorddb.Where("name = ?", "jinzhu").First(&user)// SELECT FROM users WHERE name = 'jinzhu' ORDER BY id LIMIT 1;// Get all matched recordsdb.Where("name <> ?", "jinzhu").Find(
• Transaction Management - Wraps database operations within atomic units of work to maintain data integrity and ensure consistent state across multiple queries.
• Transaction Managers - Ensuring data integrity by grouping multiple database operations into atomic units that either succeed or fail together.
• Database Tools - Object-Relational Mapper for Go.
• Databases and Storage - Developer-friendly ORM library.
• Object Relational Mappers - Feature-rich and developer-friendly ORM.
• Object Relational Mapping - Feature-rich and developer-friendly ORM.
• Persistence Frameworks - Popular object-relational mapping library for Go.
• Database Access Layers - A collection of tools that manage connections, transaction lifecycles, and query execution across various relational database management systems.
• Eager Loading Strategies - GORM automates the saving of associations and their references when creating or updating records, using an upsert technique that primarily updates foreign key references for existing associations. ### Auto-Saving Associa
• Schema Modelers - Database schema modeling allows defining application objects that map to database tables, supporting custom data types, null-value handling, and persistent storage structures.
• Single Record Retrievers - GORM provides First, Take, Last methods to retrieve a single object from the database, it adds LIMIT 1 condition when querying the database, and it will return the error ErrRecordNotFound if no record is found.
• Migration Tools - Synchronizing application data structures with database table schemas to ensure consistent and reliable storage across different environments.
• Schema Mapping Tools - Uses runtime type inspection to automatically map programming language structures to database tables and manage field-level data persistence.
• Soft Deletion Mechanisms - If your model includes a gorm.DeletedAt field (which is included in gorm.Model), it will get soft delete ability automatically! When calling Delete, the record WON’T be removed from the database, but GORM will set
• Upsert Strategies - GORM provides compatible Upsert support for different databases import "gorm.io/gorm/clause"// Do nothing on conflictdb.Clauses(clause.OnConflict{DoNothing: true}).Create(&user)// Update columns to default value on id
• Connection Pools - Managing a collection of reusable database connections to improve application performance and resource efficiency under high traffic loads.
• Data Modeling Tools - Defining complex relationships between data entities such as one-to-one, one-to-many, and many-to-many associations within an application.
• Database Deletion Utilities - When deleting a record, the deleted value needs to have primary key or it will trigger a Batch Delete, for example: ### Generics API ctx := context.Background()// Delete by IDerr := gorm.GEmail.Where("id = ?", 10).Delete
• Database Lifecycle Hooks - GORM allows user defined hooks to be implemented for BeforeSave, BeforeCreate, AfterSave, AfterCreate. These hook method will be called when creating a record, refer Hooks for details on the lifecycle func (u *Us
• Lifecycle Hooks - Executes user-defined logic at specific points in the database operation lifecycle to enable custom data validation and transformation.
• Relational Join Mappers - Specify Joins conditions type result struct { Name string Email string}db.Model(&User{}).Select("users.name, emails.email").Joins("left join emails on emails.user_id = users.id").Scan(&result{})// SELECT users.name, emai

Star history