// Query the first record based on the primary key
db.First(&user)
SELECT * FROM users ORDER BY id LIMIT 1;
// Get a record at random
db.Take(&user)
SELECT * FROM users LIMIT 1;
// Queries the last record based on the primary key
db.Last(&user)
SELECT * FROM users ORDER BY id DESC LIMIT 1;
// Query all records
db.Find(&users)
SELECT * FROM users;
// Query for a specified record (available only if the primary key is an integer)
db.First(&user, 10)
SELECT * FROM users WHERE id = 10;

// Get the first matching record
db.Where("name = ?" , "jinzhu").First(&user)
SELECT * FROM users WHERE name = 'jinzhu' limit 1;
// Get all matched records
db.Where("name = ?" , "jinzhu").Find(&users)
SELECT * FROM users WHERE name = 'jinzhu';
// <>
db.Where("name <> ?" , "jinzhu").Find(&users)
SELECT * FROM users WHERE name <> 'jinzhu';
// IN
db.Where("name IN (?) ", []string{"jinzhu", "jinzhu 2"}).Find(&users)
SELECT * FROM users WHERE name in ('jinzhu','jinzhu 2');
// LIKE
db.Where("name LIKE ?" , "%jin%").Find(&users)
SELECT * FROM users WHERE name LIKE '%jin%';
// AND
db.Where("name = ?  AND age >= ?" , "jinzhu", "22").Find(&users)
SELECT * FROM users WHERE name = 'jinzhu' AND age >= 22;
// Time
db.Where("updated_at > ?" , lastWeek).Find(&users)
SELECT * FROM users WHERE updated_at > '2000-01-01 00:00:00';
// BETWEEN
db.Where("created_at BETWEEN ?  AND ?" , lastWeek, today).Find(&users)
SELECT * FROM users WHERE created_at BETWEEN '2000-01-01 00:00:00' AND '2000-01-08 00:00:00';

// Struct
db.Where(&User{Name: "jinzhu", Age: 20}).First(&user)
SELECT * FROM users WHERE name = "jinzhu" AND age = 20 ORDER BY id LIMIT 1;
// Map
db.Where(map[string]interface{}{"name": "jinzhu", "age": 20}).Find(&users)
SELECT * FROM users WHERE name = "jinzhu" AND age = 20;
// Primary key slice
db.Where([]int64{20, 21, 22}).Find(&users)
SELECT * FROM users WHERE id IN (20, 21, 22);

db.Not("name", "jinzhu").First(&user)
SELECT * FROM users WHERE name <> "jinzhu" ORDER BY id LIMIT 1;
// Not In
db.Not("name", []string{"jinzhu", "jinzhu 2"}).Find(&users)
SELECT * FROM users WHERE name NOT IN ("jinzhu", "jinzhu 2");
// Not in the primary key slice
Db. The Not (int64 [] {1, 2, 3}). The First (and user)
SELECT * FROM users WHERE ID NOT IN (1,2,3) ORDER BY ID LIMIT 1;
db.Not([]int64{}).First(&user)
SELECT * FROM users ORDER BY id LIMIT 1;
/ / common SQL
db.Not("name = ?" , "jinzhu").First(&user)
SELECT * FROM users WHERE NOT(name = "jinzhu") ORDER BY id LIMIT 1;
// Struct
db.Not(User{Name: "jinzhu"}).First(&user)
SELECT * FROM users WHERE name <> "jinzhu" ORDER BY id LIMIT 1;

db.Where("role = ?", "admin").Or("role = ?", "super_admin").Find(&users)
 SELECT * FROM users WHERE role = 'admin' OR role = 'super_admin';
// Struct
db.Where("name = 'jinzhu'").Or(User{Name: "jinzhu 2"}).Find(&users)
 SELECT * FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2';
// Map
db.Where("name = 'jinzhu'").Or(map[string]interface{}{"name": "jinzhu 2"}).Find(&users)
 SELECT * FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2';

// Get by primary key (integer primary key only)
db.First(&user, 23)
SELECT * FROM users WHERE id = 23;
// If it is a non-integer type, it is fetched by the primary key
db.First(&user, "id = ?" , "string_primary_key")
SELECT * FROM users WHERE id = 'string_primary_key';
// Plain SQL
db.Find(&user, "name = ?" , "jinzhu")
SELECT * FROM users WHERE name = "jinzhu";
db.Find(&users, "name <> ?  AND age > ?" , "jinzhu", 20)
SELECT * FROM users WHERE name <> "jinzhu" AND age > 20;
// Struct
db.Find(&users, User{Age: 20})
SELECT * FROM users WHERE age = 20;
// Map
db.Find(&users, map[string]interface{}{"age": 20})
SELECT * FROM users WHERE age = 20;
db.Where("name = ?", "jinzhu").Or("name = ?", "jinzhu 2").Find(&users).Count(&count)
 SELECT * from USERS WHERE name = 'jinzhu' OR name = 'jinzhu 2'; (users)
 SELECT count(*) FROM users WHERE name = 'jinzhu' OR name = 'jinzhu 2'; (count)
db.Model(&User{}).Where("name = ?", "jinzhu").Count(&count)
 SELECT count(*) FROM users WHERE name = 'jinzhu'; (count)
db.Table("deleted_users").Count(&count)
 SELECT count(*) FROM deleted_users;
db.Table("deleted_users").Select("count(distinct(name))").Count(&count)
 SELECT count( distinct(name) ) FROM deleted_users; (count)

rows, err := db.Table("users").Select("users.name,  emails.email").Joins("left join emails on emails.user_id = users.id").Rows()
for rows.Next() {
.
}
db.Table("users").Select("users.name,  emails.email").Joins("left join emails on emails.user_id = users.id").Scan(&results)
// Multiple connections and parameters
db.Joins("JOIN emails ON emails.user_id = users.id AND emails.email = ?" , "jinzhu@example.org").Joins("JOIN credit_cards ON credit_cards.user_id = users.id").Where("credit_cards.number = ?",  "411111111111").Find(&user)

var ages []int64
db.Find(&users).Pluck("age", &ages)
var names []string
db.Model(&User{}).Pluck("name", &names)
db.Table("deleted_users").Pluck("name", &names)
// Want to query multiple fields? To do this:
db.Select("name, age").Find(&users)

// Update a single attribute if it changes
db.Model(&user).Update("name", "hello")
UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE id=111;
// Updates a single attribute based on a given condition
db.Model(&user).Where("active = ?" , true).Update("name", "hello")
UPDATE users SET name='hello', updated_at='2013-11-17 21:34:10' WHERE id=111 AND active=true;
// Using map to update multiple attributes will only update those that have changed
db.Model(&user).Updates(map[string]interface{}{"name": "hello", "age": 18, "actived": false})
UPDATE users SET name='hello', age=18, actived=false, updated_at='2013-11-17 21:34:10' WHERE id=111;
// Using struct to update multiple attributes only updates the fields that have changed and have nonzero values
db.Model(&user).Updates(User{Name: "hello", Age: 18})
UPDATE users SET name='hello', age=18, updated_at = '2013-11-17 21:34:10' WHERE id = 111;
// Warning: When using struct updates, GORM will update only those fields with non-zero values
// For the following operations, no updates occur, "", 0, and false are zeros of their type
db.Model(&user).Updates(User{Name: "", Age: 0, Actived: false})

// Delete the existing record
db.Delete(&email)
DELETE from emails where id=10;
// Add additional SQL operations for deleting SQL
db.Set("gorm:delete_option", "OPTION (OPTIMIZE FOR UNKNOWN)").Delete(&email)
DELETE from emails where id=10 OPTION (OPTIMIZE FOR UNKNOWN);

// The Unscoped method can physically delete records
db.Unscoped().Delete(&order)
DELETE FROM orders WHERE id=10;