Smart Select Fields
GORM에서는, Select
메소드를 사용하여 특정 필드를 효율적으로 선택할 수 있습니다. 이는 특히 대규모 모델을 다룰 때 모델의 일부 필드만 필요한 경우에 API 응답에서 특히 유용합니다.
type User struct { |
NOTE
QueryFields 모드
에서는 모든 모델 필드가 그들의 이름에 따라 선택됩니다.
db, err := gorm.Open(sqlite.Open("gorm.db"), &gorm.Config{ |
Locking
GORM 은 다른 종류의 lock을 지원합니다.
// Basic FOR UPDATE lock |
위의 명령문은 트랜잭션이 진행되는 동안 선택된 행을 잠그게 됩니다. 이는 행을 업데이트하기 전에 다른 트랜잭션이 해당 행을 수정하지 못하도록 원한다면 사용될 수 있습니다.
강도(Strength)
는 SHARE
로 설정될 수 있으며, 이는 다른 트랜잭션이 잠긴 행을 읽을 수 있지만 수정할 수는 없도록 행을 잠근다는 의미입니다.
db.Clauses(clause.Locking{ |
테이블(Table)
옵션은 특정 테이블을 잠그는데 사용될 수 있습니다. 여러 테이블을 조인하고, 그 중 하나만 잠그려고 할 때 유용할 수 있습니다.
옵션(Options) 에는 NOWAIT
을 사용할 수 있습니다. 이는 lock을 획득하려고 시도하고 lock이 사용될 수 없는 경우 즉시 오류가 발생합니다. 다른 트랜잭션이 lock을 풀 때까지 기다리는 것을 방지합니다.
db.Clauses(clause.Locking{ |
다른 옵션으로는 SKIP LOCKED
을 사용할 수 있습니다. 이는 다른 트랜잭션에 의해 이미 잠겨 있는 행을 건너뛰게 됩니다. 이는 다른 트랜잭션에 의해 현재 잠겨 있지 않은 행을 처리하고자 하는 높은 동시성 상황에서 유용합니다.
잠금 전략들에 대한 더 상세한 정보를 원한다면 Raw SQL and SQL Builder를 참고해주세요.
SubQuery
Subqueries are a powerful feature in SQL, allowing nested queries. GORM can generate subqueries automatically when using a *gorm.DB object as a parameter.
// Simple subquery |
From SubQuery
GORM allows the use of subqueries in the FROM clause, enabling complex queries and data organization.
// Using subquery in FROM clause |
Group Conditions (그룹화 조건)
Group Conditions in GORM provide a more readable and maintainable way to write complex SQL queries involving multiple conditions.
// Complex SQL query using Group Conditions |
IN with multiple columns
GORM supports the IN clause with multiple columns, allowing you to filter data based on multiple field values in a single query.
// Using IN with multiple columns |
Named Argument
GORM enhances the readability and maintainability of SQL queries by supporting named arguments. This feature allows for clearer and more organized query construction, especially in complex queries with multiple parameters. Named arguments can be utilized using either sql.NamedArg
or map[string]interface{}{}
, providing flexibility in how you structure your queries.
// Example using sql.NamedArg for named arguments |
For more examples and details, see Raw SQL and SQL Builder
Find To Map
GORM provides flexibility in querying data by allowing results to be scanned into a map[string]interface{}
or []map[string]interface{}
, which can be useful for dynamic data structures.
When using Find To Map
, it’s crucial to include Model
or Table
in your query to explicitly specify the table name. This ensures that GORM understands which table to query against.
// Scanning the first result into a map with Model |
FirstOrInit
GORM’s FirstOrInit
method is utilized to fetch the first record that matches given conditions, or initialize a new instance if no matching record is found. This method is compatible with both struct and map conditions and allows additional flexibility with the Attrs
and Assign
methods.
// If no User with the name "non_existing" is found, initialize a new User |
Using Attrs
for Initialization
When no record is found, you can use Attrs
to initialize a struct with additional attributes. These attributes are included in the new struct but are not used in the SQL query.
// If no User is found, initialize with given conditions and additional attributes |
Using Assign
for Attributes
The Assign
method allows you to set attributes on the struct regardless of whether the record is found or not. These attributes are set on the struct but are not used to build the SQL query and the final data won’t be saved into the database.
// Initialize with given conditions and Assign attributes, regardless of record existence |
FirstOrInit
, along with Attrs
and Assign
, provides a powerful and flexible way to ensure a record exists and is initialized or updated with specific attributes in a single step.
FirstOrCreate
FirstOrCreate
in GORM is used to fetch the first record that matches given conditions or create a new one if no matching record is found. This method is effective with both struct and map conditions. The RowsAffected
property is useful to determine the number of records created or updated.
// Create a new record if not found |
Using Attrs
with FirstOrCreate
Attrs
can be used to specify additional attributes for the new record if it is not found. These attributes are used for creation but not in the initial search query.
// Create a new record with additional attributes if not found |
Using Assign
with FirstOrCreate
The Assign
method sets attributes on the record regardless of whether it is found or not, and these attributes are saved back to the database.
// Initialize and save new record with `Assign` attributes if not found |
Optimizer/Index Hints
GORM includes support for optimizer and index hints, allowing you to influence the query optimizer’s execution plan. This can be particularly useful in optimizing query performance or when dealing with complex queries.
Optimizer hints are directives that suggest how a database’s query optimizer should execute a query. GORM facilitates the use of optimizer hints through the gorm.io/hints package.
import "gorm.io/hints" |
Index Hints
Index hints provide guidance to the database about which indexes to use. They can be beneficial if the query planner is not selecting the most efficient indexes for a query.
import "gorm.io/hints" |
These hints can significantly impact query performance and behavior, especially in large databases or complex data models. For more detailed information and additional examples, refer to Optimizer Hints/Index/Comment in the GORM documentation.
Iteration
GORM supports the iteration over query results using the Rows
method. This feature is particularly useful when you need to process large datasets or perform operations on each record individually.
You can iterate through rows returned by a query, scanning each row into a struct. This method provides granular control over how each record is handled.
rows, err := db.Model(&User{}).Where("name = ?", "jinzhu").Rows() |
This approach is ideal for complex data processing that cannot be easily achieved with standard query methods.
FindInBatches
FindInBatches
allows querying and processing records in batches. This is especially useful for handling large datasets efficiently, reducing memory usage and improving performance.
With FindInBatches
, GORM processes records in specified batch sizes. Inside the batch processing function, you can apply operations to each batch of records.
// Processing records in batches of 100 |
FindInBatches
is an effective tool for processing large volumes of data in manageable chunks, optimizing resource usage and performance.
Query Hooks
GORM offers the ability to use hooks, such as AfterFind
, which are triggered during the lifecycle of a query. These hooks allow for custom logic to be executed at specific points, such as after a record has been retrieved from the database.
This hook is useful for post-query data manipulation or default value settings. For more detailed information and additional hook types, refer to Hooks in the GORM documentation.
func (u *User) AfterFind(tx *gorm.DB) (err error) { |
Pluck
The Pluck
method in GORM is used to query a single column from the database and scan the result into a slice. This method is ideal for when you need to retrieve specific fields from a model.
If you need to query more than one column, you can use Select
with Scan or Find instead.
// Retrieving ages of all users |
Scopes
Scopes
in GORM are a powerful feature that allows you to define commonly-used query conditions as reusable methods. These scopes can be easily referenced in your queries, making your code more modular and readable.
Defining Scopes
Scopes
are defined as functions that modify and return a gorm.DB
instance. You can define a variety of conditions as scopes based on your application’s requirements.
// Scope for filtering records where amount is greater than 1000 |
Applying Scopes in Queries
You can apply one or more scopes to a query by using the Scopes
method. This allows you to chain multiple conditions dynamically.
// Applying scopes to find all credit card orders with an amount greater than 1000 |
Scopes
are a clean and efficient way to encapsulate common query logic, enhancing the maintainability and readability of your code. For more detailed examples and usage, refer to Scopes in the GORM documentation.
Count
The Count
method in GORM is used to retrieve the number of records that match a given query. It’s a useful feature for understanding the size of a dataset, particularly in scenarios involving conditional queries or data analysis.
Getting the Count of Matched Records
You can use Count
to determine the number of records that meet specific criteria in your queries.
var count int64 |
Count with Distinct and Group
GORM also allows counting distinct values and grouping results.
// Counting distinct names |