awesome-repositories.com
© 2026 Bringes Technology SRL·VAT RO45896025·hello@bringes.io
MCPSitemapPrivacyTerms
Gorm | Awesome Repository
← All repositories

go-gorm/gorm

0
View on GitHub↗
39,602 stars·4,134 forks·Go·mit·0 viewsgorm.io↗

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 Access Layers - A collection of tools that manage connections, transaction lifecycles, and query execution across various relational database management systems.
  • Database Connection Pools - Connection pool management optimizes database performance by controlling active and idle connection counts and setting expiration limits for efficient resource usage.
  • 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

    • GORM is a developer-focused object-relational mapping library for Go that provides a comprehensive data persistence framework. It serves as a database access layer, allowing developers to map application structures to database tables and perform CRUD operations using a fluent, type-safe query builder instead of writing raw SQL.

    The library distinguishes itself through its association-aware persistence, which automatically tracks and synchronizes complex entity relationships during database operations. It utilizes a driver-agnostic interface to maintain consistent behavior across various storage engines and employs a reflection-based system to map programming language types to database schemas. Developers can further customize behavior using a callback-based hook system that executes logic at specific points in the operation lifecycle.

    Beyond core mapping, the project provides robust support for transaction management, connection pooling, and automated schema migrations. It handles complex relational modeling, including one-to-one, one-to-many, and many-to-many associations, while offering advanced features like eager loading, soft deletes, and conflict resolution strategies for upsert operations.

    The framework is designed for integration into Go applications, providing a unified interface for managing database connectivity and transactional integrity.