{"id":16829966,"url":"https://github.com/rtfb/gorm-named-fields-experiments","last_synced_at":"2025-09-13T07:13:53.812Z","repository":{"id":19477128,"uuid":"22722610","full_name":"rtfb/gorm-named-fields-experiments","owner":"rtfb","description":null,"archived":false,"fork":false,"pushed_at":"2014-08-30T17:43:57.000Z","size":836,"stargazers_count":3,"open_issues_count":0,"forks_count":1,"subscribers_count":3,"default_branch":"master","last_synced_at":"2025-01-24T08:22:42.148Z","etag":null,"topics":[],"latest_commit_sha":null,"homepage":null,"language":"Go","has_issues":true,"has_wiki":null,"has_pages":null,"mirror_url":null,"source_name":null,"license":null,"status":null,"scm":"git","pull_requests_enabled":true,"icon_url":"https://github.com/rtfb.png","metadata":{"files":{"readme":"README.md","changelog":null,"contributing":null,"funding":null,"license":null,"code_of_conduct":null,"threat_model":null,"audit":null,"citation":null,"codeowners":null,"security":null,"support":null}},"created_at":"2014-08-07T13:40:36.000Z","updated_at":"2021-01-27T04:54:40.000Z","dependencies_parsed_at":"2022-08-30T14:30:28.435Z","dependency_job_id":null,"html_url":"https://github.com/rtfb/gorm-named-fields-experiments","commit_stats":null,"previous_names":[],"tags_count":0,"template":false,"template_full_name":null,"repository_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rtfb%2Fgorm-named-fields-experiments","tags_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rtfb%2Fgorm-named-fields-experiments/tags","releases_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rtfb%2Fgorm-named-fields-experiments/releases","manifests_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories/rtfb%2Fgorm-named-fields-experiments/manifests","owner_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners/rtfb","download_url":"https://codeload.github.com/rtfb/gorm-named-fields-experiments/tar.gz/refs/heads/master","host":{"name":"GitHub","url":"https://github.com","kind":"github","repositories_count":244117655,"owners_count":20400743,"icon_url":"https://github.com/github.png","version":null,"created_at":"2022-05-30T11:31:42.601Z","updated_at":"2022-07-04T15:15:14.044Z","host_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub","repositories_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repositories","repository_names_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/repository_names","owners_url":"https://repos.ecosyste.ms/api/v1/hosts/GitHub/owners"}},"keywords":[],"created_at":"2024-10-13T11:36:48.196Z","updated_at":"2025-03-17T22:07:53.860Z","avatar_url":"https://github.com/rtfb.png","language":"Go","funding_links":[],"categories":[],"sub_categories":[],"readme":"# GORM\n\nThe fantastic ORM library for Golang, aims to be developer friendly.\n\n## Overview\n\n* Chainable API\n* Relations\n* Callbacks (before/after create/save/update/delete/find)\n* Soft Deletes\n* Auto Migrations\n* Transactions\n* Customizable Logger\n* Iteration Support via [Rows](#row--rows)\n* Scopes\n* sql.Scanner support\n* Every feature comes with tests\n* Convention Over Configuration\n* Developer Friendly\n\n## Conventions\n\n* Table name is the plural of struct name's snake case, you can disable pluralization with `db.SingularTable(true)`, or [Specifying The Table Name For A Struct Permanently With TableName](#specifying-the-table-name-for-a-struct-permanently-with-tablename)\n\n```go\n// E.g finding an existing User\nvar user User\n// Gorm will know to use table \"users\" (\"user\" if pluralisation has been disabled) for all operations.\ndb.First(\u0026user)\n\n// creating a new User\nDB.Save(\u0026User{Name: \"xxx\"}) // table \"users\"\n```\n\n* Column name is the snake case of field's name\n* Use `Id` field as primary key\n* Use tag `sql` to change field's property, change the tag name with `db.SetTagIdentifier(new_name)`\n* Use `CreatedAt` to store record's created time if field exists\n* Use `UpdatedAt` to store record's updated time if field exists\n* Use `DeletedAt` to store record's deleted time if field exists [Soft Delete](#soft-delete)\n\n# Getting Started\n\n## Install\n\n```\ngo get -u github.com/jinzhu/gorm\n```\n\n## Define Models (Structs)\n\n```go\ntype User struct {\n    Id           int64\n    Birthday     time.Time\n    Age          int64\n    Name         string  `sql:\"size:255\"`\n    CreatedAt    time.Time\n    UpdatedAt    time.Time\n    DeletedAt    time.Time\n\n    Emails            []Email         // Embedded structs (has many)\n    BillingAddress    Address         // Embedded struct (has one)\n    BillingAddressId  sql.NullInt64   // Foreign key of BillingAddress\n    ShippingAddress   Address         // Embedded struct (has one)\n    ShippingAddressId int64           // Foreign key of ShippingAddress\n    IgnoreMe          int64 `sql:\"-\"` // Ignore this field\n    Languages         []Language `gorm:\"many2many:user_languages;\"` // Many To Many, user_languages is the join table\n}\n\ntype Email struct {\n    Id         int64\n    UserId     int64   // Foreign key for User (belongs to)\n    Email      string  `sql:\"type:varchar(100);\"` // Set field's type\n    Subscribed bool\n}\n\ntype Address struct {\n    Id       int64\n    Address1 string         `sql:\"not null;unique\"` // Set field as not nullable and unique\n    Address2 string         `sql:\"type:varchar(100);unique\"`\n    Post     sql.NullString `sql:not null`\n}\n\ntype Language struct {\n    Id   int64\n    Name string\n}\n```\n\n## Initialize Database\n\n```go\n\nimport (\n    \"github.com/jinzhu/gorm\"\n    _ \"github.com/lib/pq\"\n    _ \"github.com/go-sql-driver/mysql\"\n    _ \"github.com/mattn/go-sqlite3\"\n)\n\ndb, err := gorm.Open(\"postgres\", \"user=gorm dbname=gorm sslmode=disable\")\n// db, err := gorm.Open(\"mysql\", \"gorm:gorm@/gorm?charset=utf8\u0026parseTime=True\")\n// db, err := gorm.Open(\"sqlite3\", \"/tmp/gorm.db\")\n\n// Get database connection handle [*sql.DB](http://golang.org/pkg/database/sql/#DB)\ndb.DB()\n\n// Then you could invoke `*sql.DB`'s functions with it\ndb.DB().Ping()\ndb.DB().SetMaxIdleConns(10)\ndb.DB().SetMaxOpenConns(100)\n\n// Disable table name's pluralization\ndb.SingularTable(true)\n```\n\n## Migration\n\n```go\n// Create table\ndb.CreateTable(User{})\n\n// Drop table\ndb.DropTable(User{})\n\n// Automating Migration\ndb.AutoMigrate(User{})\n\n// Feel free to change your struct, AutoMigrate will keep your database up-to-date.\n// Fyi, AutoMigrate will only *add new columns*, it won't update column's type or delete unused columns, to make sure your data is safe.\n// If the table is not existing, AutoMigrate will create the table automatically.\n\n// Add index\ndb.Model(User{}).AddIndex(\"idx_user_name\", \"name\")\n\n// Multiple column index\ndb.Model(User{}).AddIndex(\"idx_user_name_age\", \"name\", \"age\")\n\n// Add unique index\ndb.Model(User{}).AddUniqueIndex(\"idx_user_name\", \"name\")\n\n// Multiple column unique index\ndb.Model(User{}).AddUniqueIndex(\"idx_user_name_age\", \"name\", \"age\")\n\n// Remove index\ndb.Model(User{}).RemoveIndex(\"idx_user_name\")\n```\n\n# Basic CRUD\n\n## Create Record\n\n```go\nuser := User{Name: \"Jinzhu\", Age: 18, Birthday: time.Now()}\n\n// returns true if record hasn’t been saved (primary key `Id` is blank)\ndb.NewRecord(user) // =\u003e true\n\ndb.Create(\u0026user)\n\n// will ruturn false after `user` created\ndb.NewRecord(user) // =\u003e false\n\n// You could use `Save` to create record also if its primary key is null\ndb.Save(\u0026user)\n\n// Associations will be saved automatically when insert the record\nuser := User{\n        Name:            \"jinzhu\",\n        BillingAddress:  Address{Address1: \"Billing Address - Address 1\"},\n        ShippingAddress: Address{Address1: \"Shipping Address - Address 1\"},\n        Emails:          []Email{{Email: \"jinzhu@example.com\"}, {Email: \"jinzhu-2@example@example.com\"}},\n        Languages:       []Language{{Name: \"ZH\"}, {Name: \"EN\"}},\n}\n\ndb.Create(\u0026user)\n//// BEGIN TRANSACTION;\n//// INSERT INTO \"addresses\" (address1) VALUES (\"Billing Address - Address 1\");\n//// INSERT INTO \"addresses\" (address1) VALUES (\"Shipping Address - Address 1\");\n//// INSERT INTO \"users\" (name,billing_address_id,shipping_address_id) VALUES (\"jinzhu\", 1, 2);\n//// INSERT INTO \"emails\" (user_id,email) VALUES (111, \"jinzhu@example.com\");\n//// INSERT INTO \"emails\" (user_id,email) VALUES (111, \"jinzhu-2@example.com\");\n//// INSERT INTO \"languages\" (\"name\") VALUES ('ZH');\n//// INSERT INTO user_languages (\"user_id\",\"language_id\") VALUES (111, 1);\n//// INSERT INTO \"languages\" (\"name\") VALUES ('EN');\n//// INSERT INTO user_languages (\"user_id\",\"language_id\") VALUES (111, 2);\n//// COMMIT;\n```\n\nRefer [Associations](#associations) for how to works with associations\n\n## Query\n\n```go\n// Get the first record\ndb.First(\u0026user)\n//// SELECT * FROM users ORDER BY id LIMIT 1;\n\n// Get the last record\ndb.Last(\u0026user)\n//// SELECT * FROM users ORDER BY id DESC LIMIT 1;\n\n// Get all records\ndb.Find(\u0026users)\n//// SELECT * FROM users;\n\n// Get record with primary key\ndb.First(\u0026user, 10)\n//// SELECT * FROM users WHERE id = 10;\n```\n\n### Query With Where (Plain SQL)\n\n```go\n// Get the first matched record\ndb.Where(\"name = ?\", \"jinzhu\").First(\u0026user)\n//// SELECT * FROM users WHERE name = 'jinzhu' limit 1;\n\n// Get all matched records\ndb.Where(\"name = ?\", \"jinzhu\").Find(\u0026users)\n//// SELECT * FROM users WHERE name = 'jinzhu';\n\ndb.Where(\"name \u003c\u003e ?\", \"jinzhu\").Find(\u0026users)\n\n// IN\ndb.Where(\"name in (?)\", []string{\"jinzhu\", \"jinzhu 2\"}).Find(\u0026users)\n\n// LIKE\ndb.Where(\"name LIKE ?\", \"%jin%\").Find(\u0026users)\n\n// AND\ndb.Where(\"name = ? and age \u003e= ?\", \"jinzhu\", \"22\").Find(\u0026users)\n```\n\n### Query With Where (Struct \u0026 Map)\n\n```go\n// Struct\ndb.Where(\u0026User{Name: \"jinzhu\", Age: 20}).First(\u0026user)\n//// SELECT * FROM users WHERE name = \"jinzhu\" AND age = 20 LIMIT 1;\n\n// Map\ndb.Where(map[string]interface{}{\"name\": \"jinzhu\", \"age\": 20}).Find(\u0026users)\n//// SELECT * FROM users WHERE name = \"jinzhu\" AND age = 20;\n\n// Slice of primary keys\ndb.Where([]int64{20, 21, 22}).Find(\u0026users)\n//// SELECT * FROM users WHERE id IN (20, 21, 22);\n```\n\n### Query With Not\n\n```go\ndb.Not(\"name\", \"jinzhu\").First(\u0026user)\n//// SELECT * FROM users WHERE name \u003c\u003e \"jinzhu\" LIMIT 1;\n\n// Not In\ndb.Not(\"name\", []string{\"jinzhu\", \"jinzhu 2\"}).Find(\u0026users)\n//// SELECT * FROM users WHERE name NOT IN (\"jinzhu\", \"jinzhu 2\");\n\n// Not In slice of primary keys\ndb.Not([]int64{1,2,3}).First(\u0026user)\n//// SELECT * FROM users WHERE id NOT IN (1,2,3);\n\ndb.Not([]int64{}).First(\u0026user)\n//// SELECT * FROM users;\n\n// Plain SQL\ndb.Not(\"name = ?\", \"jinzhu\").First(\u0026user)\n//// SELECT * FROM users WHERE NOT(name = \"jinzhu\");\n\n// Struct\ndb.Not(User{Name: \"jinzhu\"}).First(\u0026user)\n//// SELECT * FROM users WHERE name \u003c\u003e \"jinzhu\";\n```\n\n### Query With Inline Condition\n\n```go\n// Get by primary key\ndb.First(\u0026user, 23)\n//// SELECT * FROM users WHERE id = 23 LIMIT 1;\n\n// Plain SQL\ndb.Find(\u0026user, \"name = ?\", \"jinzhu\")\n//// SELECT * FROM users WHERE name = \"jinzhu\";\n\ndb.Find(\u0026users, \"name \u003c\u003e ? AND age \u003e ?\", \"jinzhu\", 20)\n//// SELECT * FROM users WHERE name \u003c\u003e \"jinzhu\" AND age \u003e 20;\n\n// Struct\ndb.Find(\u0026users, User{Age: 20})\n//// SELECT * FROM users WHERE age = 20;\n\n// Map\ndb.Find(\u0026users, map[string]interface{}{\"age\": 20})\n//// SELECT * FROM users WHERE age = 20;\n```\n\n### Query With Or\n\n```go\ndb.Where(\"role = ?\", \"admin\").Or(\"role = ?\", \"super_admin\").Find(\u0026users)\n//// SELECT * FROM users WHERE role = 'admin' OR role = 'super_admin';\n\n// Struct\ndb.Where(\"name = 'jinzhu'\").Or(User{Name: \"jinzhu 2\"}).Find(\u0026users)\n//// SELECT * FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2';\n\n// Map\ndb.Where(\"name = 'jinzhu'\").Or(map[string]interface{}{\"name\": \"jinzhu 2\"}).Find(\u0026users)\n```\n\n### Query Chains\n\nGorm has a chainable API, you could use it like this\n\n```go\ndb.Where(\"name \u003c\u003e ?\",\"jinzhu\").Where(\"age \u003e= ? and role \u003c\u003e ?\",20,\"admin\").Find(\u0026users)\n//// SELECT * FROM users WHERE name \u003c\u003e 'jinzhu' AND age \u003e= 20 AND role \u003c\u003e 'admin';\n\ndb.Where(\"role = ?\", \"admin\").Or(\"role = ?\", \"super_admin\").Not(\"name = ?\", \"jinzhu\").Find(\u0026users)\n```\n\n## Update\n\n```go\n// Update an existing struct\ndb.First(\u0026user)\nuser.Name = \"jinzhu 2\"\nuser.Age = 100\ndb.Save(\u0026user)\n//// UPDATE users SET name='jinzhu 2', age=100, updated_at = '2013-11-17 21:34:10' WHERE id=111;\n\n// Update an attribute if it is changed\ndb.Model(\u0026user).Update(\"name\", \"hello\")\n//// UPDATE users SET name='hello', updated_at = '2013-11-17 21:34:10' WHERE id=111;\n\ndb.First(\u0026user, 111).Update(\"name\", \"hello\")\n//// SELECT * FROM users LIMIT 1;\n//// UPDATE users SET name='hello', updated_at = '2013-11-17 21:34:10' WHERE id=111;\n\n// Update multiple attributes if they are changed\ndb.Model(\u0026user).Updates(User{Name: \"hello\", Age: 18})\n//// UPDATE users SET name='hello', age=18, updated_at = '2013-11-17 21:34:10' WHERE id = 111;\n```\n\n### Update Without Callbacks\n\nBy default, update will call BeforeUpdate, AfterUpdate callbacks, if you want to update w/o callbacks:\n\n```go\ndb.Model(\u0026user).UpdateColumn(\"name\", \"hello\")\n//// UPDATE users SET name='hello' WHERE id = 111;\n\ndb.Model(\u0026user).UpdateColumns(User{Name: \"hello\", Age: 18})\n//// UPDATE users SET name='hello', age=18 WHERE id = 111;\n```\n\n### Batch Updates\n\n```go\ndb.Table(\"users\").Where(\"id = ?\", 10).Updates(map[string]interface{}{\"name\": \"hello\", \"age\": 18})\n//// UPDATE users SET name='hello', age=18 WHERE id = 10;\n\ndb.Model(User{}).Updates(User{Name: \"hello\", Age: 18})\n//// UPDATE users SET name='hello', age=18;\n\n// Callbacks won't be run when do batch updates\n\n// You may would like to know how many records updated when do batch updates\n// You could get it with `RowsAffected`\ndb.Model(User{}).Updates(User{Name: \"hello\", Age: 18}).RowsAffected\n```\n\n## Delete\n\n```go\n// Delete an existing record\ndb.Delete(\u0026email)\n// DELETE from emails where id=10;\n```\n\n### Batch Delete\n\n```go\ndb.Where(\"email LIKE ?\", \"%jinzhu%\").Delete(Email{})\n// DELETE from emails where email LIKE \"%jinhu%\";\n```\n\n### Soft Delete\n\nIf struct has `DeletedAt` field, it will get soft delete ability automatically!\nThen it won't be deleted from database permanently when call `Delete`.\n\n```go\ndb.Delete(\u0026user)\n//// UPDATE users SET deleted_at=\"2013-10-29 10:23\" WHERE id = 111;\n\n// Batch Delete\ndb.Where(\"age = ?\", 20).Delete(\u0026User{})\n//// UPDATE users SET deleted_at=\"2013-10-29 10:23\" WHERE age = 20;\n\n// Soft deleted records will be ignored when query them\ndb.Where(\"age = 20\").Find(\u0026user)\n//// SELECT * FROM users WHERE age = 20 AND (deleted_at IS NULL AND deleted_at \u003c= '0001-01-02');\n\n// Find soft deleted records with Unscoped\ndb.Unscoped().Where(\"age = 20\").Find(\u0026users)\n//// SELECT * FROM users WHERE age = 20;\n\n// Delete record permanently with Unscoped\ndb.Unscoped().Delete(\u0026order)\n// DELETE FROM orders WHERE id=10;\n```\n\n## Associations\n\n### Has One\n\n```go\n// User has one address\ndb.Model(\u0026user).Related(\u0026address)\n//// SELECT * FROM addresses WHERE id = 123; // 123 is user's foreign key AddressId\n\n// Specify the foreign key\ndb.Model(\u0026user).Related(\u0026address1, \"BillingAddressId\")\n//// SELECT * FROM addresses WHERE id = 123; // 123 is user's foreign key BillingAddressId\n```\n\n### Belongs To\n\n```go\n// Email belongs to user\ndb.Model(\u0026email).Related(\u0026user)\n//// SELECT * FROM users WHERE id = 111; // 111 is email's foreign key UserId\n\n// Specify the foreign key\ndb.Model(\u0026email).Related(\u0026user, \"ProfileId\")\n//// SELECT * FROM users WHERE id = 111; // 111 is email's foreign key ProfileId\n```\n\n### Has Many\n\n```go\n// User has many emails\ndb.Model(\u0026user).Related(\u0026emails)\n//// SELECT * FROM emails WHERE user_id = 111;\n// user_id is the foreign key, 111 is user's primary key's value\n\n// Specify the foreign key\ndb.Model(\u0026user).Related(\u0026emails, \"ProfileId\")\n//// SELECT * FROM emails WHERE profile_id = 111;\n// profile_id is the foreign key, 111 is user's primary key's value\n```\n\n### Many To Many\n\n```go\n// User has many languages and belongs to many languages\ndb.Model(\u0026user).Related(\u0026languages, \"Languages\")\n//// SELECT * FROM \"languages\" INNER JOIN \"user_languages\" ON \"user_languages\".\"language_id\" = \"languages\".\"id\" WHERE \"user_languages\".\"user_id\" = 111\n// `Languages` is user's column name, this column's tag defined join table like this `gorm:\"many2many:user_languages;\"`\n```\n\nThere is also a mode used to handle many to many relations easily\n\n```go\n// Query\ndb.Model(\u0026user).Association(\"Languages\").Find(\u0026languages)\n// same as `db.Model(\u0026user).Related(\u0026languages, \"Languages\")`\n\ndb.Where(\"name = ?\", \"ZH\").First(\u0026languageZH)\ndb.Where(\"name = ?\", \"EN\").First(\u0026languageEN)\n\n// Append\ndb.Model(\u0026user).Association(\"Languages\").Append([]Language{languageZH, languageEN})\ndb.Model(\u0026user).Association(\"Languages\").Append([]Language{{Name: \"DE\"}})\ndb.Model(\u0026user).Association(\"Languages\").Append(Language{Name: \"DE\"})\n\n// Delete\ndb.Model(\u0026user).Association(\"Languages\").Delete([]Language{languageZH, languageEN})\ndb.Model(\u0026user).Association(\"Languages\").Delete(languageZH, languageEN)\n\n// Replace\ndb.Model(\u0026user).Association(\"Languages\").Replace([]Language{languageZH, languageEN})\ndb.Model(\u0026user).Association(\"Languages\").Replace(Language{Name: \"DE\"}, languageEN)\n\n// Count\ndb.Model(\u0026user).Association(\"Languages\").Count()\n// Return the count of languages the user has\n\n// Clear\ndb.Model(\u0026user).Association(\"Languages\").Clear()\n// Remove all relations between the user and languages\n```\n\n## Advanced Usage\n\n## FirstOrInit\n\nGet the first matched record, or initialize a record with search conditions.\n\n```go\n// Unfound\ndb.FirstOrInit(\u0026user, User{Name: \"non_existing\"})\n//// user -\u003e User{Name: \"non_existing\"}\n\n// Found\ndb.Where(User{Name: \"Jinzhu\"}).FirstOrInit(\u0026user)\n//// user -\u003e User{Id: 111, Name: \"Jinzhu\", Age: 20}\ndb.FirstOrInit(\u0026user, map[string]interface{}{\"name\": \"jinzhu\"})\n//// user -\u003e User{Id: 111, Name: \"Jinzhu\", Age: 20}\n```\n\n### Attrs\n\nIgnore some values when searching, but use them to initialize the struct if record is not found.\n\n```go\n// Unfound\ndb.Where(User{Name: \"non_existing\"}).Attrs(User{Age: 20}).FirstOrInit(\u0026user)\n//// SELECT * FROM USERS WHERE name = 'non_existing';\n//// user -\u003e User{Name: \"non_existing\", Age: 20}\n\ndb.Where(User{Name: \"noexisting_user\"}).Attrs(\"age\", 20).FirstOrInit(\u0026user)\n//// SELECT * FROM USERS WHERE name = 'non_existing';\n//// user -\u003e User{Name: \"non_existing\", Age: 20}\n\n// Found\ndb.Where(User{Name: \"Jinzhu\"}).Attrs(User{Age: 30}).FirstOrInit(\u0026user)\n//// SELECT * FROM USERS WHERE name = jinzhu';\n//// user -\u003e User{Id: 111, Name: \"Jinzhu\", Age: 20}\n```\n\n### Assign\n\nIgnore some values when searching, but assign it to the result regardless it is found or not.\n\n```go\n// Unfound\ndb.Where(User{Name: \"non_existing\"}).Assign(User{Age: 20}).FirstOrInit(\u0026user)\n//// user -\u003e User{Name: \"non_existing\", Age: 20}\n\n// Found\ndb.Where(User{Name: \"Jinzhu\"}).Assign(User{Age: 30}).FirstOrInit(\u0026user)\n//// SELECT * FROM USERS WHERE name = jinzhu';\n//// user -\u003e User{Id: 111, Name: \"Jinzhu\", Age: 30}\n```\n\n## FirstOrCreate\n\nGet the first matched record, or create with search conditions.\n\n```go\n// Unfound\ndb.FirstOrCreate(\u0026user, User{Name: \"non_existing\"})\n//// INSERT INTO \"users\" (name) VALUES (\"non_existing\");\n//// user -\u003e User{Id: 112, Name: \"non_existing\"}\n\n// Found\ndb.Where(User{Name: \"Jinzhu\"}).FirstOrCreate(\u0026user)\n//// user -\u003e User{Id: 111, Name: \"Jinzhu\"}\n```\n\n### Attrs\n\nIgnore some values when searching, but use them to create the struct if record is not found. like `FirstOrInit`\n\n```go\n// Unfound\ndb.Where(User{Name: \"non_existing\"}).Attrs(User{Age: 20}).FirstOrCreate(\u0026user)\n//// SELECT * FROM users WHERE name = 'non_existing';\n//// INSERT INTO \"users\" (name, age) VALUES (\"non_existing\", 20);\n//// user -\u003e User{Id: 112, Name: \"non_existing\", Age: 20}\n\n// Found\ndb.Where(User{Name: \"jinzhu\"}).Attrs(User{Age: 30}).FirstOrCreate(\u0026user)\n//// SELECT * FROM users WHERE name = 'jinzhu';\n//// user -\u003e User{Id: 111, Name: \"jinzhu\", Age: 20}\n```\n\n### Assign\n\nIgnore some values when searching, but assign it to the record regardless it is found or not, then save back to database. like `FirstOrInit`\n\n```go\n// Unfound\ndb.Where(User{Name: \"non_existing\"}).Assign(User{Age: 20}).FirstOrCreate(\u0026user)\n//// SELECT * FROM users WHERE name = 'non_existing';\n//// INSERT INTO \"users\" (name, age) VALUES (\"non_existing\", 20);\n//// user -\u003e User{Id: 112, Name: \"non_existing\", Age: 20}\n\n// Found\ndb.Where(User{Name: \"jinzhu\"}).Assign(User{Age: 30}).FirstOrCreate(\u0026user)\n//// SELECT * FROM users WHERE name = 'jinzhu';\n//// UPDATE users SET age=30 WHERE id = 111;\n//// user -\u003e User{Id: 111, Name: \"jinzhu\", Age: 30}\n```\n\n## Select\n\n```go\ndb.Select(\"name, age\").Find(\u0026users)\n//// SELECT name, age FROM users;\n```\n\n## Order\n\n```go\ndb.Order(\"age desc, name\").Find(\u0026users)\n//// SELECT * FROM users ORDER BY age desc, name;\n\n// Multiple orders\ndb.Order(\"age desc\").Order(\"name\").Find(\u0026users)\n//// SELECT * FROM users ORDER BY age desc, name;\n\n// ReOrder\ndb.Order(\"age desc\").Find(\u0026users1).Order(\"age\", true).Find(\u0026users2)\n//// SELECT * FROM users ORDER BY age desc; (users1)\n//// SELECT * FROM users ORDER BY age; (users2)\n```\n\n## Limit\n\n```go\ndb.Limit(3).Find(\u0026users)\n//// SELECT * FROM users LIMIT 3;\n\n// Cancel limit condition with -1\ndb.Limit(10).Find(\u0026users1).Limit(-1).Find(\u0026users2)\n//// SELECT * FROM users LIMIT 10; (users1)\n//// SELECT * FROM users; (users2)\n```\n\n## Offset\n\n```go\ndb.Offset(3).Find(\u0026users)\n//// SELECT * FROM users OFFSET 3;\n\n// Cancel offset condition with -1\ndb.Offset(10).Find(\u0026users1).Offset(-1).Find(\u0026users2)\n//// SELECT * FROM users OFFSET 10; (users1)\n//// SELECT * FROM users; (users2)\n```\n\n## Count\n\n```go\ndb.Where(\"name = ?\", \"jinzhu\").Or(\"name = ?\", \"jinzhu 2\").Find(\u0026users).Count(\u0026count)\n//// SELECT * from USERS WHERE name = 'jinzhu' OR name = 'jinzhu 2'; (users)\n//// SELECT count(*) FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2'; (count)\n\ndb.Model(User{}).Where(\"name = ?\", \"jinzhu\").Count(\u0026count)\n//// SELECT count(*) FROM users WHERE name = 'jinzhu'; (count)\n\ndb.Table(\"deleted_users\").Count(\u0026count)\n//// SELECT count(*) FROM deleted_users;\n```\n\n## Pluck\n\nGet selected attributes as map\n\n```go\nvar ages []int64\ndb.Find(\u0026users).Pluck(\"age\", \u0026ages)\n\nvar names []string\ndb.Model(\u0026User{}).Pluck(\"name\", \u0026names)\n\ndb.Table(\"deleted_users\").Pluck(\"name\", \u0026names)\n\n// Requesting more than one column? Do it like this:\ndb.Select(\"name, age\").Find(\u0026users)\n```\n\n## Raw SQL\n\n```go\ndb.Exec(\"DROP TABLE users;\")\ndb.Exec(\"UPDATE orders SET shipped_at=? WHERE id IN (?)\", time.Now, []int64{11,22,33})\n```\n\n## Row \u0026 Rows\n\nYou are even possible to get query result as `*sql.Row` or `*sql.Rows`\n\n```go\nrow := db.Table(\"users\").Where(\"name = ?\", \"jinzhu\").Select(\"name, age\").Row() // (*sql.Row)\nrow.Scan(\u0026name, \u0026age)\n\nrows, err := db.Model(User{}).Where(\"name = ?\", \"jinzhu\").Select(\"name, age, email\").Rows() // (*sql.Rows, error)\ndefer rows.Close()\nfor rows.Next() {\n  ...\n  rows.Scan(\u0026name, \u0026age, \u0026email)\n  ...\n}\n\n// Raw SQL\nrows, err := db.Raw(\"select name, age, email from users where name = ?\", \"jinzhu\").Rows() // (*sql.Rows, error)\ndefer rows.Close()\nfor rows.Next() {\n  ...\n  rows.Scan(\u0026name, \u0026age, \u0026email)\n  ...\n}\n```\n\n## Scan\n\nScan results into another struct.\n\n```go\ntype Result struct {\n\tName string\n\tAge  int\n}\n\nvar result Result\ndb.Table(\"users\").Select(\"name, age\").Where(\"name = ?\", 3).Scan(\u0026result)\n\n// Raw SQL\ndb.Raw(\"SELECT name, age FROM users WHERE name = ?\", 3).Scan(\u0026result)\n```\n\n## Group \u0026 Having\n\n```go\nrows, err := db.Table(\"orders\").Select(\"date(created_at) as date, sum(amount) as total\").Group(\"date(created_at)\").Rows()\nfor rows.Next() {\n  ...\n}\n\nrows, err := db.Table(\"orders\").Select(\"date(created_at) as date, sum(amount) as total\").Group(\"date(created_at)\").Having(\"sum(amount) \u003e ?\", 100).Rows()\nfor rows.Next() {\n  ...\n}\n\ntype Result struct {\n\tDate  time.Time\n\tTotal int64\n}\ndb.Table(\"orders\").Select(\"date(created_at) as date, sum(amount) as total\").Group(\"date(created_at)\").Having(\"sum(amount) \u003e ?\", 100).Scan(\u0026results)\n```\n\n## Joins\n\n```go\nrows, err := db.Table(\"users\").Select(\"users.name, emails.email\").Joins(\"left join emails on emails.user_id = users.id\").Rows()\nfor rows.Next() {\n  ...\n}\n\ndb.Table(\"users\").Select(\"users.name, emails.email\").Joins(\"left join emails on emails.user_id = users.id\").Scan(\u0026results)\n```\n\n## Transactions\n\nAll individual save and delete operations are run in a transaction by default.\n\n```go\n// begin\ntx := db.Begin()\n\n// rollback\ntx.Rollback()\n\n// commit\ntx.Commit()\n```\n\n## Scopes\n\n```go\nfunc AmountGreaterThan1000(db *gorm.DB) *gorm.DB {\n  return db.Where(\"amount \u003e ?\", 1000)\n}\n\nfunc PaidWithCreditCard(db *gorm.DB) *gorm.DB {\n  return db.Where(\"pay_mode_sign = ?\", \"C\")\n}\n\nfunc PaidWithCod(db *gorm.DB) *gorm.DB {\n  return db.Where(\"pay_mode_sign = ?\", \"C\")\n}\n\nfunc OrderStatus(status []string) func (db *gorm.DB) *gorm.DB {\n  return func (db *gorm.DB) *gorm.DB {\n     return db.Scopes(AmountGreaterThan1000).Where(\"status in (?)\", status)\n  }\n}\n\ndb.Scopes(AmountGreaterThan1000, PaidWithCreditCard).Find(\u0026orders)\n// Find all credit card orders and amount greater than 1000\n\ndb.Scopes(AmountGreaterThan1000, PaidWithCod).Find(\u0026orders)\n// Find all COD orders and amount greater than 1000\n\ndb.Scopes(OrderStatus([]string{\"paid\", \"shipped\"})).Find(\u0026orders)\n// Find all paid, shipped orders\n```\n\n## Callbacks\n\nCallbacks are methods defined on the pointer of struct.\nIf any callback returns an error, gorm will stop future operations and rollback all changes.\n\nHere is the list of all available callbacks:\n(listed in the same order in which they will get called during the respective operations)\n\n### Creating An Object\n\n```go\nBeforeSave\nBeforeCreate\n// save before associations\n// save self\n// save after associations\nAfterCreate\nAfterSave\n```\n### Updating An Object\n\n```go\nBeforeSave\nBeforeUpdate\n// save before associations\n// save self\n// save after associations\nAfterUpdate\nAfterSave\n```\n\n### Destroying An Object\n\n```go\nBeforeDelete\n// delete self\nAfterDelete\n```\n\n### After Find\n\n```go\n// load data from database\nAfterFind\n```\n\n### Example\n\n```go\nfunc (u *User) BeforeUpdate() (err error) {\n    if u.readonly() {\n        err = errors.New(\"read only user\")\n    }\n    return\n}\n\n// Rollback the insertion if user's id greater than 1000\nfunc (u *User) AfterCreate() (err error) {\n    if (u.Id \u003e 1000) {\n        err = errors.New(\"user id is already greater than 1000\")\n    }\n    return\n}\n```\n\nAs you know, save/delete operations in gorm are running in a transaction,\nThis is means if changes made in the transaction is not visiable unless it is commited,\nSo if you want to use those changes in your callbacks, you need to run SQL in same transaction.\nFortunately, gorm support pass transaction to callbacks as you needed, you could do it like this:\n\n```go\nfunc (u *User) AfterCreate(tx *gorm.DB) (err error) {\n    tx.Model(u).Update(\"role\", \"admin\")\n    return\n}\n```\n\n## Specifying The Table Name\n\n```go\n// Create `deleted_users` table with struct User's definition\ndb.Table(\"deleted_users\").CreateTable(\u0026User{})\n\nvar deleted_users []User\ndb.Table(\"deleted_users\").Find(\u0026deleted_users)\n//// SELECT * FROM deleted_users;\n\ndb.Table(\"deleted_users\").Where(\"name = ?\", \"jinzhu\").Delete()\n//// DELETE FROM deleted_users WHERE name = 'jinzhu';\n```\n\n### Specifying The Table Name For A Struct Permanently with TableName\n\n```go\ntype Cart struct {\n}\n\nfunc (c Cart) TableName() string {\n    return \"shopping_cart\"\n}\n\nfunc (u User) TableName() string {\n    if u.Role == \"admin\" {\n        return \"admin_users\"\n    } else {\n        return \"users\"\n    }\n}\n```\n\n## Error Handling\n\n```go\nquery := db.Where(\"name = ?\", \"jinzhu\").First(\u0026user)\nquery := db.First(\u0026user).Limit(10).Find(\u0026users)\n// query.Error will return the last happened error\n\n// So you could do error handing in your application like this:\nif err := db.Where(\"name = ?\", \"jinzhu\").First(\u0026user).Error; err != nil {\n  // error handling...\n}\n\n// RecordNotFound\n// If no record found when you query data, gorm will return RecordNotFound error, you could check it like this:\ndb.Where(\"name = ?\", \"hello world\").First(\u0026User{}).Error == gorm.RecordNotFound\n// Or use the shortcut method\ndb.Where(\"name = ?\", \"hello world\").First(\u0026user).RecordNotFound()\n\nif db.Model(\u0026user).Related(\u0026credit_card).RecordNotFound() {\n  // no credit card found error handling\n}\n```\n\n## Logger\n\nGorm has built-in logger support\n\n```go\n// Enable Logger\ndb.LogMode(true)\n\n// Diable Logger\ndb.LogMode(false)\n\n// Debug a single operation\ndb.Debug().Where(\"name = ?\", \"jinzhu\").First(\u0026User{})\n```\n\n![logger](https://raw.github.com/jinzhu/gorm/master/images/logger.png)\n\n### Customize Logger\n\n```go\n// Refer gorm's default logger for how to: https://github.com/jinzhu/gorm/blob/master/logger.go#files\ndb.SetLogger(gorm.Logger{revel.TRACE})\ndb.SetLogger(log.New(os.Stdout, \"\\r\\n\", 0))\n```\n\n## Existing Schema\n\nIf you have an existing database schema, and the primary key field is different from `id`, you can add a tag to the field structure to specify that this field is a primary key.\n\n```go\ntype Animal struct {\n    AnimalId     int64 `gorm:\"primary_key:yes\"`\n    Birthday     time.Time\n    Age          int64\n}\n```\n\nIf your column names differ from the struct fields, you can specify them like this:\n\n```go\ntype Animal struct { // animals\n    AnimalId     int64     `gorm:\"column:beast_id; primary_key:yes\"`\n    Birthday     time.Time `gorm:\"column:day_of_the_beast\"`\n    Age          int64     `gorm:\"column:age_of_the_beast\"`\n}\n```\n\nNote that if your primary key has a custom column name, you will still have to\nspecify `primary_key`, even if your struct field is named `Id`:\n\n```go\ntype Foo struct {\n    Id int64 `gorm:\"column:foo_id; primary_key:yes\"`\n}\n```\n\n\n## More examples with query chain\n\n```go\ndb.First(\u0026first_article).Count(\u0026total_count).Limit(10).Find(\u0026first_page_articles).Offset(10).Find(\u0026second_page_articles)\n//// SELECT * FROM articles LIMIT 1; (first_article)\n//// SELECT count(*) FROM articles; (total_count)\n//// SELECT * FROM articles LIMIT 10; (first_page_articles)\n//// SELECT * FROM articles LIMIT 10 OFFSET 10; (second_page_articles)\n\n\ndb.Where(\"created_at \u003e ?\", \"2013-10-10\").Find(\u0026cancelled_orders, \"state = ?\", \"cancelled\").Find(\u0026shipped_orders, \"state = ?\", \"shipped\")\n//// SELECT * FROM orders WHERE created_at \u003e '2013/10/10' AND state = 'cancelled'; (cancelled_orders)\n//// SELECT * FROM orders WHERE created_at \u003e '2013/10/10' AND state = 'shipped'; (shipped_orders)\n\n\n// Use variables to keep query chain\ntodays_orders := db.Where(\"created_at \u003e ?\", \"2013-10-29\")\ncancelled_orders := todays_orders.Where(\"state = ?\", \"cancelled\")\nshipped_orders := todays_orders.Where(\"state = ?\", \"shipped\")\n\n\n// Search with shared conditions for different tables\ndb.Where(\"product_name = ?\", \"fancy_product\").Find(\u0026orders).Find(\u0026shopping_carts)\n//// SELECT * FROM orders WHERE product_name = 'fancy_product'; (orders)\n//// SELECT * FROM carts WHERE product_name = 'fancy_product'; (shopping_carts)\n\n\n// Search with shared conditions from different tables with specified table\ndb.Where(\"mail_type = ?\", \"TEXT\").Find(\u0026users1).Table(\"deleted_users\").Find(\u0026users2)\n//// SELECT * FROM users WHERE mail_type = 'TEXT'; (users1)\n//// SELECT * FROM deleted_users WHERE mail_type = 'TEXT'; (users2)\n\n\n// FirstOrCreate example\ndb.Where(\"email = ?\", \"x@example.org\").Attrs(User{RegisteredIp: \"111.111.111.111\"}).FirstOrCreate(\u0026user)\n//// SELECT * FROM users WHERE email = 'x@example.org';\n//// INSERT INTO \"users\" (email,registered_ip) VALUES (\"x@example.org\", \"111.111.111.111\")  // if record not found\n```\n\n## TODO\n* db.RegisterFuncation(\"Search\", func() {})\n  db.Model(\u0026[]User{}).Limit(10).Do(\"Search\", \"search func's argument\")\n  db.Mode(\u0026User{}).Do(\"EditForm\").Get(\"edit_form_html\")\n  DefaultValue, DefaultTimeZone, R/W Splitting, Validation\n* Getter/Setter\n  share or not? transaction?\n* Github Pages\n* Includes\n* AlertColumn, DropColumn\n\n# Author\n\n**jinzhu**\n\n* \u003chttp://github.com/jinzhu\u003e\n* \u003cwosmvp@gmail.com\u003e\n* \u003chttp://twitter.com/zhangjinzhu\u003e\n\n## License\n\nReleased under the [MIT License](http://www.opensource.org/licenses/MIT).\n\n[![GoDoc](https://godoc.org/github.com/jinzhu/gorm?status.png)](http://godoc.org/github.com/jinzhu/gorm)\n","project_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Frtfb%2Fgorm-named-fields-experiments","html_url":"https://awesome.ecosyste.ms/projects/github.com%2Frtfb%2Fgorm-named-fields-experiments","lists_url":"https://awesome.ecosyste.ms/api/v1/projects/github.com%2Frtfb%2Fgorm-named-fields-experiments/lists"}