go version

package main
 
import "fmt"
 
func main() {
    fmt.Println("Hello world")
}

// JavaScript needs you to call main()
function main() {
  console.log("Hello world");
}
main();
 
// Go automatically runs main()

go run main.go

# Build executable
go build main.go
 
# Run it
./main        # Mac/Linux
main.exe      # Windows

go mod init github.com/yourusername/project-name

module github.com/yourusername/project-name
 
go 1.21
 
require (
    github.com/gin-gonic/gin v1.9.1
)

package main
 
import "fmt"
 
func main() {
    // Explicit type declaration
    var name string = "John"
    var age int = 25
    var price float64 = 99.99
    var isActive bool = true
 
    // Type inference (Go guesses the type)
    var city = "New York"
 
    // Short declaration (most common)
    country := "USA"
 
    fmt.Println(name, age, price, isActive, city, country)
}

// JavaScript (loosely typed)
let name = "John";
let age = 25;
let price = 99.99;
let isActive = true;

const birthYear = 1993
const pi = 3.14159
 
// Cannot be changed later
// birthYear = 1995  // ERROR!

// Fixed size - cannot change
var numbers [5]int = [5]int{1, 2, 3, 4, 5}

// Dynamic size - can grow/shrink
names := []string{"JB", "Jane", "Gerald"}
 
// Add items
names = append(names, "Alice")
 
// Access items
fmt.Println(names[0])  // "JB"
 
// Length
fmt.Println(len(names))  // 4

// JavaScript arrays are always dynamic
const names = ["JB", "Jane", "Gerald"];
names.push("Alice");
console.log(names[0]);
console.log(names.length);

func greet(name string) string {
    return "Hello, " + name
}
 
// Usage
message := greet("John")
fmt.Println(message)

func getUser() (string, int) {
    return "John", 25
}
 
// Usage
name, age := getUser()
fmt.Println(name, age)  // John 25

// JavaScript needs array or object
function getUser() {
  return ["John", 25];
}
const [name, age] = getUser();

func calcAge() {
    const birthYear = 1993
    var currentYear = 2025
    var result = currentYear - birthYear
    var names = []string{"JB", "Jane", "Gerald"}
 
    printItems(names)
    fmt.Println(result, names)
}
 
func printItems(items []string) {
    for index, item := range items {
        fmt.Printf("%d. %s\n", index+1, item)
    }
}

// Standard for loop
for i := 0; i < 5; i++ {
    fmt.Println(i)
}
 
// While-style loop
i := 0
for i < 5 {
    fmt.Println(i)
    i++
}
 
// Infinite loop
for {
    // runs forever
    break  // use break to exit
}
 
// Range loop (like forEach)
names := []string{"JB", "Jane", "Gerald"}
for index, name := range names {
    fmt.Printf("%d. %s\n", index+1, name)
}
 
// Ignore index with underscore
for _, name := range names {
    fmt.Println(name)
}

// For loop
for (let i = 0; i < 5; i++) {
  console.log(i);
}
 
// While loop
let i = 0;
while (i < 5) {
  console.log(i);
  i++;
}
 
// forEach
names.forEach((name, index) => {
  console.log(`${index + 1}. ${name}`);
});

age := 25
 
if age >= 18 {
    fmt.Println("Adult")
} else if age >= 13 {
    fmt.Println("Teenager")
} else {
    fmt.Println("Child")
}
 
// Short statement before condition
if age := getAge(); age >= 18 {
    fmt.Println("Adult")
}

day := "Monday"
 
switch day {
case "Monday":
    fmt.Println("Start of week")
case "Friday":
    fmt.Println("Almost weekend!")
case "Saturday", "Sunday":
    fmt.Println("Weekend!")
default:
    fmt.Println("Midweek")
}

// Define a struct (like a class or type)
type Person struct {
    Name string
    Age  int
    City string
}
 
// Create instance
john := Person{
    Name: "John",
    Age:  25,
    City: "New York",
}
 
// Access fields
fmt.Println(john.Name)  // "John"
 
// Modify fields
john.Age = 26

// JavaScript object
const john = {
  name: "John",
  age: 25,
  city: "New York",
};
 
console.log(john.name);
john.age = 26;

x := 42
p := &x  // p is a pointer to x
fmt.Println(*p)  // prints 42 (dereference to get the value)
*p = 21  // changes x to 21

func tryToModify(x int) {
    x = 100  // Changes only the LOCAL copy
}
 
func main() {
    age := 25
    tryToModify(age)
    fmt.Println(age)  // Still 25! ❌
}

func modifyWithPointer(x *int) {
    *x = 100  // Changes the ORIGINAL value
}
 
func main() {
    age := 25
    modifyWithPointer(&age)
    fmt.Println(age)  // Now 100! ✅
}

age := 25
ptr := &age  // ptr now holds the address of age
fmt.Println(ptr)   // Prints something like: 0xc0000120a0

age := 25
ptr := &age       // ptr points to age
 
fmt.Println(*ptr) // Prints: 25 (value at that address)
*ptr = 100        // Changes the value at that address
fmt.Println(age)  // Prints: 100

func main() {
    // Create a variable
    score := 50
 
    // Get its address
    scorePtr := &score
 
    fmt.Println("Value:", score)        // 50
    fmt.Println("Address:", scorePtr)   // 0xc000012080 (example)
    fmt.Println("Value via pointer:", *scorePtr)  // 50
 
    // Modify through pointer
    *scorePtr = 75
 
    fmt.Println("New value:", score)    // 75
}

type Person struct {
    Name string
    Age  int
}
 
// Won't work - receives a copy
func birthdayCopy(p Person) {
    p.Age++
}
 
// Works - receives address, modifies original
func birthdayPointer(p *Person) {
    p.Age++  // Note: Go auto-dereferences, same as (*p).Age++
}
 
func main() {
    person := Person{Name: "Alice", Age: 25}
 
    birthdayCopy(person)
    fmt.Println(person.Age)  // Still 25
 
    birthdayPointer(&person)
    fmt.Println(person.Age)  // Now 26
}

func getUser(id int) (*User, error) {
    if id < 0 {
        return nil, errors.New("invalid ID")  // Can return nil pointer
    }
    user := User{ID: id, Name: "John"}
    return &user, nil  // Return pointer to user
}

type LargeStruct struct {
    data [1000]int
}
 
// Inefficient - copies 8000 bytes
func processCopy(s LargeStruct) { }
 
// Efficient - passes 8 bytes
func processPointer(s *LargeStruct) { }

type Config struct {
    timeout int
}
 
cfg := &Config{timeout: 30}
server := NewServer(cfg)
client := NewClient(cfg)
// Both share the same config

type User struct {
    name string
    age  int
}
 
// Pointer receiver - can modify the struct
func (u *User) HaveBirthday() {
    u.age++
}
 
// Value receiver - read-only operations
func (u User) IsAdult() bool {
    return u.age >= 18
}

// Don't do this - int is small, copy is fine
func add(a, b *int) int {
    return *a + *b
}
 
// Do this instead
func add(a, b int) int {
    return a + b
}
 
// Don't pass pointer to slice - slice header already references underlying array
func processSlice(items *[]string) { }  // Wrong
 
func processSlice(items []string) { }   // Correct

func (u *User) GetName() string {
    if u == nil {
        return "unknown"
    }
    return u.name
}

// Regular variable
age := 25
 
// Pointer to age
agePointer := &age
 
// Get value from pointer
fmt.Println(*agePointer)  // 25
 
// Modify via pointer
*agePointer = 26
fmt.Println(age)  // 26

func incrementAge(age *int) {
    *age = *age + 1
}
 
age := 25
incrementAge(&age)
fmt.Println(age)  // 26

import "fmt"
 
// Print without newline
fmt.Print("Hello")
fmt.Print("World")  // HelloWorld
 
// Print with newline
fmt.Println("Hello")
fmt.Println("World")
// Hello
// World
 
// Formatted print (like template literals)
name := "John"
age := 25
fmt.Printf("Name: %s, Age: %d\n", name, age)
// Name: John, Age: 25

// JavaScript template literals
const name = "John";
const age = 25;
console.log(`Name: ${name}, Age: ${age}`);

import "strings"
 
text := "Hello, World!"
 
// Convert to lowercase/uppercase
lower := strings.ToLower(text)      // "hello, world!"
upper := strings.ToUpper(text)      // "HELLO, WORLD!"
 
// Check if contains
contains := strings.Contains(text, "World")  // true
 
// Split string
parts := strings.Split("a,b,c", ",")  // ["a", "b", "c"]
 
// Join strings
joined := strings.Join([]string{"a", "b"}, "-")  // "a-b"
 
// Replace
replaced := strings.Replace(text, "World", "Go", -1)  // "Hello, Go!"
 
// Trim whitespace
trimmed := strings.TrimSpace("  hello  ")  // "hello"

const text = "Hello, World!";
const lower = text.toLowerCase();
const upper = text.toUpperCase();
const contains = text.includes("World");
const parts = "a,b,c".split(",");
const joined = ["a", "b"].join("-");
const replaced = text.replace("World", "Go");
const trimmed = "  hello  ".trim();

// Create a map
ages := make(map[string]int)
ages["John"] = 25
ages["Jane"] = 30
 
// Or create with initial values
scores := map[string]int{
    "John": 95,
    "Jane": 87,
}
 
// Access value
johnScore := scores["John"]  // 95
 
// Check if key exists
score, exists := scores["Alice"]
if exists {
    fmt.Println("Alice scored:", score)
} else {
    fmt.Println("Alice not found")
}
 
// Delete key
delete(scores, "John")
 
// Iterate over map
for name, score := range scores {
    fmt.Printf("%s: %d\n", name, score)
}

// JavaScript object
const scores = {
  John: 95,
  Jane: 87,
};
 
const johnScore = scores["John"];
 
// Check if exists
if ("Alice" in scores) {
  console.log("Alice scored:", scores.Alice);
}
 
delete scores.John;
 
// Iterate
for (const [name, score] of Object.entries(scores)) {
  console.log(`${name}: ${score}`);
}

import (
    "errors"
    "fmt"
)
 
// Function that returns error
func divide(a, b float64) (float64, error) {
    if b == 0 {
        return 0, errors.New("cannot divide by zero")
    }
    return a / b, nil
}
 
// Usage - always check errors!
result, err := divide(10, 0)
if err != nil {
    fmt.Println("Error:", err)
    return
}
fmt.Println("Result:", result)

// JavaScript uses try/catch
function divide(a, b) {
  if (b === 0) {
    throw new Error("cannot divide by zero");
  }
  return a / b;
}
 
try {
  const result = divide(10, 0);
  console.log("Result:", result);
} catch (err) {
  console.log("Error:", err.message);
}

import (
    "encoding/json"
    "fmt"
)
 
type Person struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
    City string `json:"city"`
}
 
func main() {
    person := Person{
        Name: "John",
        Age:  25,
        City: "New York",
    }
 
    // Convert to JSON
    jsonData, err := json.Marshal(person)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
 
    fmt.Println(string(jsonData))
    // {"name":"John","age":25,"city":"New York"}
}

func main() {
    jsonStr := `{"name":"John","age":25,"city":"New York"}`
 
    var person Person
    err := json.Unmarshal([]byte(jsonStr), &person)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
 
    fmt.Printf("%+v\n", person)
    // {Name:John Age:25 City:New York}
}

// JavaScript
const person = { name: "John", age: 25, city: "New York" };
 
// To JSON
const jsonStr = JSON.stringify(person);
 
// From JSON
const parsed = JSON.parse(jsonStr);

import (
    "encoding/json"
    "fmt"
    "io"
    "net/http"
)
 
type Post struct {
    UserID int    `json:"userId"`
    ID     int    `json:"id"`
    Title  string `json:"title"`
    Body   string `json:"body"`
}
 
func fetchPost() {
    url := "https://jsonplaceholder.typicode.com/posts/1"
 
    // Make GET request
    resp, err := http.Get(url)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
 
    // Check status code
    if resp.StatusCode != 200 {
        fmt.Println("Error: Status", resp.StatusCode)
        return
    }
 
    // Read response body
    body, err := io.ReadAll(resp.Body)
    if err != nil {
        fmt.Println("Error reading body:", err)
        return
    }
 
    // Parse JSON
    var post Post
    err = json.Unmarshal(body, &post)
    if err != nil {
        fmt.Println("Error parsing JSON:", err)
        return
    }
 
    fmt.Printf("%+v\n", post)
}

import (
    "bytes"
    "encoding/json"
    "fmt"
    "net/http"
)
 
func createPost() {
    url := "https://jsonplaceholder.typicode.com/posts"
 
    // Create request data
    newPost := Post{
        UserID: 1,
        Title:  "My Post",
        Body:   "This is the content",
    }
 
    // Convert to JSON
    jsonData, err := json.Marshal(newPost)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
 
    // Make POST request
    resp, err := http.Post(
        url,
        "application/json",
        bytes.NewBuffer(jsonData),
    )
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
    defer resp.Body.Close()
 
    fmt.Println("Status:", resp.Status)
}

// JavaScript Fetch API
async function fetchPost() {
  const response = await fetch("https://jsonplaceholder.typicode.com/posts/1");
  const post = await response.json();
  console.log(post);
}
 
async function createPost() {
  const response = await fetch("https://jsonplaceholder.typicode.com/posts", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({
      userId: 1,
      title: "My Post",
      body: "This is the content",
    }),
  });
  const data = await response.json();
  console.log(data);
}

import (
    "fmt"
    "os"
)
 
func readFile() {
    // Read entire file
    data, err := os.ReadFile("config.txt")
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
 
    fmt.Println(string(data))
}

func writeFile() {
    content := []byte("Hello, World!")
 
    err := os.WriteFile("output.txt", content, 0644)
    if err != nil {
        fmt.Println("Error:", err)
        return
    }
 
    fmt.Println("File written successfully")
}

import (
    "fmt"
    "os"
)
 
func main() {
    // Get environment variable
    dbURL := os.Getenv("DATABASE_URL")
 
    if dbURL == "" {
        fmt.Println("DATABASE_URL not set")
        return
    }
 
    fmt.Println("Database URL:", dbURL)
 
    // Set environment variable (for current process)
    os.Setenv("APP_ENV", "development")
}

import (
    "fmt"
    "time"
)
 
func fetchUser() {
    time.Sleep(2 * time.Second)
    fmt.Println("User fetched")
}
 
func fetchPosts() {
    time.Sleep(1 * time.Second)
    fmt.Println("Posts fetched")
}
 
func main() {
    // Run concurrently (like Promise.all)
    go fetchUser()
    go fetchPosts()
 
    // Wait for goroutines to finish
    time.Sleep(3 * time.Second)
    fmt.Println("Done")
}

async function fetchUser() {
  await new Promise((resolve) => setTimeout(resolve, 2000));
  console.log("User fetched");
}
 
async function fetchPosts() {
  await new Promise((resolve) => setTimeout(resolve, 1000));
  console.log("Posts fetched");
}
 
// Run concurrently
Promise.all([fetchUser(), fetchPosts()]).then(() => {
  console.log("Done");
});

// Define interface
type Animal interface {
    Speak() string
}
 
// Implement interface (implicit)
type Dog struct {
    Name string
}
 
func (d Dog) Speak() string {
    return "Woof!"
}
 
type Cat struct {
    Name string
}
 
func (c Cat) Speak() string {
    return "Meow!"
}
 
// Use interface
func makeAnimalSpeak(a Animal) {
    fmt.Println(a.Speak())
}
 
func main() {
    dog := Dog{Name: "Buddy"}
    cat := Cat{Name: "Whiskers"}
 
    makeAnimalSpeak(dog)  // Woof!
    makeAnimalSpeak(cat)  // Meow!
}

interface Animal {
  speak(): string;
}
 
class Dog implements Animal {
  name: string;
 
  speak(): string {
    return "Woof!";
  }
}
 
function makeAnimalSpeak(animal: Animal) {
  console.log(animal.speak());
}

# Create project directory
mkdir go-crud-api
cd go-crud-api
 
# Initialize Go module
go mod init github.com/yourusername/go-crud-api

# Install Gin (Web framework)
go get -u github.com/gin-gonic/gin
 
# Install GORM (ORM)
go get -u gorm.io/gorm
 
# Install Database Driver (PostgreSQL)
go get -u gorm.io/driver/postgres
 
# Install for Environment Variables
go get github.com/joho/godotenv
 
# Install Hot Reload (Development)
go get github.com/githubnemo/CompileDaemon
go install github.com/githubnemo/CompileDaemon

DATABASE_URL="host=your-host user=your-user password=your-password dbname=your-db port=5432 sslmode=require"
PORT=8080

package initializers
 
import (
    "log"
    "github.com/joho/godotenv"
)
 
func LoadEnvVariables() {
    err := godotenv.Load()
    if err != nil {
        log.Fatal("Error loading .env file")
    }
}

package initializers
 
import (
    "fmt"
    "log"
    "os"
 
    "gorm.io/driver/postgres"
    "gorm.io/gorm"
)
 
var DB *gorm.DB
 
func ConnectToDB() {
    var err error
    dsn := os.Getenv("DATABASE_URL")
 
    DB, err = gorm.Open(postgres.Open(dsn), &gorm.Config{})
    if err != nil {
        log.Fatal("Failed to connect to database:", err)
    }
 
    fmt.Println("✅ Successfully connected to database!")
}

package models
 
import "gorm.io/gorm"
 
type Category struct {
    gorm.Model
    Title       string `gorm:"uniqueIndex;not null"`
    Slug        string `gorm:"uniqueIndex;not null"`
    Description string
}

package main
 
import (
    "github.com/yourusername/go-crud-api/initializers"
    "github.com/yourusername/go-crud-api/models"
)
 
func init() {
    initializers.LoadEnvVariables()
    initializers.ConnectToDB()
}
 
func main() {
    initializers.DB.AutoMigrate(&models.Category{})
}

go run migrate/migrate.go

package dtos
 
// Request DTOs
type CreateCategoryRequest struct {
    Title       string `json:"title" binding:"required,min=3,max=100"`
    Description string `json:"description" binding:"max=500"`
    Slug        string `json:"slug" binding:"required,min=3,max=100"`
}
 
type UpdateCategoryRequest struct {
    Title       string `json:"title" binding:"omitempty,min=3,max=100"`
    Description string `json:"description" binding:"omitempty,max=500"`
    Slug        string `json:"slug" binding:"omitempty,min=3,max=100"`
}
 
// Response DTOs
type SuccessResponse struct {
    Success bool        `json:"success"`
    Data    interface{} `json:"data,omitempty"`
    Message string      `json:"message,omitempty"`
}
 
type ErrorResponse struct {
    Success bool   `json:"success"`
    Error   string `json:"error"`
}

package controllers
 
import (
    "errors"
    "strings"
 
    "github.com/yourusername/go-crud-api/dtos"
    "github.com/yourusername/go-crud-api/initializers"
    "github.com/yourusername/go-crud-api/models"
    "github.com/gin-gonic/gin"
    "gorm.io/gorm"
)
 
// CREATE
func CreateCategory(c *gin.Context) {
    var req dtos.CreateCategoryRequest
 
    // Validate request
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(200, dtos.SuccessResponse{
        Success: true,
        Data:    categories,
    })
}
 
// READ ONE
func GetCategory(c *gin.Context) {
    id := c.Param("id")
    var category models.Category
 
    result := initializers.DB.First(&category, id)
 
    if result.Error != nil {
        if errors.Is(result.Error, gorm.ErrRecordNotFound) {
            c.JSON(404, dtos.ErrorResponse{
                Success: false,
                Error:   "Category not found",
            })
            return
        }
 
        c.JSON(500, dtos.ErrorResponse{
            Success: false,
            Error:   "Database error",
        })
        return
    }
 
    c.JSON(200, dtos.SuccessResponse{
        Success: true,
        Data:    category,
    })
}
 
// UPDATE
func UpdateCategory(c *gin.Context) {
    id := c.Param("id")
    var req dtos.UpdateCategoryRequest
 
    // Validate request
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(400, dtos.ErrorResponse{
            Success: false,
            Error:   "Invalid input: " + err.Error(),
        })
        return
    }
 
    // Find existing category
    var category models.Category
    result := initializers.DB.First(&category, id)
 
    if result.Error != nil {
        if errors.Is(result.Error, gorm.ErrRecordNotFound) {
            c.JSON(404, dtos.ErrorResponse{
                Success: false,
                Error:   "Category not found",
            })
            return
        }
 
        c.JSON(500, dtos.ErrorResponse{
            Success: false,
            Error:   "Database error",
        })
        return
    }
 
    // Update fields
    updates := models.Category{
        Title:       req.Title,
        Slug:        req.Slug,
        Description: req.Description,
    }
 
    if err := initializers.DB.Model(&category).Updates(updates).Error; err != nil {
        if strings.Contains(err.Error(), "duplicate") {
            c.JSON(409, dtos.ErrorResponse{
                Success: false,
                Error:   "Category with this slug already exists",
            })
            return
        }
 
        c.JSON(500, dtos.ErrorResponse{
            Success: false,
            Error:   "Failed to update category",
        })
        return
    }
 
    // Fetch updated data
    initializers.DB.First(&category, id)
 
    c.JSON(200, dtos.SuccessResponse{
        Success: true,
        Data:    category,
    })
}
 
// DELETE
func DeleteCategory(c *gin.Context) {
    id := c.Param("id")
 
    // Check if exists
    var category models.Category
    result := initializers.DB.First(&category, id)
 
    if result.Error != nil {
        if errors.Is(result.Error, gorm.ErrRecordNotFound) {
            c.JSON(404, dtos.ErrorResponse{
                Success: false,
                Error:   "Category not found",
            })
            return
        }
 
        c.JSON(500, dtos.ErrorResponse{
            Success: false,
            Error:   "Database error",
        })
        return
    }
 
    // Delete
    if err := initializers.DB.Delete(&category).Error; err != nil {
        c.JSON(500, dtos.ErrorResponse{
            Success: false,
            Error:   "Failed to delete category",
        })
        return
    }
 
    c.JSON(200, dtos.SuccessResponse{
        Success: true,
        Message: "Category deleted successfully",
    })
}

package main
 
import (
    "github.com/yourusername/go-crud-api/controllers"
    "github.com/yourusername/go-crud-api/initializers"
    "github.com/gin-gonic/gin"
)
 
func init() {
    initializers.LoadEnvVariables()
    initializers.ConnectToDB()
}
 
func main() {
    // Initialize router
    router := gin.Default()
 
    // API v1 group (versioning)
    v1 := router.Group("/api/v1")
    {
        // Category routes
        categories := v1.Group("/categories")
        {
            categories.POST("", controllers.CreateCategory)
            categories.GET("", controllers.ListCategories)
            categories.GET("/:id", controllers.GetCategory)
            categories.PUT("/:id", controllers.UpdateCategory)
            categories.DELETE("/:id", controllers.DeleteCategory)
        }
    }
 
    // Health check
    router.GET("/health", func(c *gin.Context) {
        c.JSON(200, gin.H{
            "status":  "ok",
            "message": "Server is running",
        })
    })
 
    // Start server
    router.Run() // Default :8080
}

CompileDaemon -command="./go-crud-api"

go run main.go

go build
./go-crud-api

curl -X POST http://localhost:8080/api/v1/categories \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Electronics",
    "slug": "electronics",
    "description": "Electronic products and gadgets"
  }'

curl http://localhost:8080/api/v1/categories

curl http://localhost:8080/api/v1/categories/1

curl -X PUT http://localhost:8080/api/v1/categories/1 \
  -H "Content-Type: application/json" \
  -d '{
    "title": "Consumer Electronics",
    "description": "Updated description"
  }'

curl -X DELETE http://localhost:8080/api/v1/categories/1

// Single record
user := models.User{Name: "John", Age: 25}
result := db.Create(&user)
 
// Check error
if result.Error != nil {
    // Handle error
}
 
// Get ID of created record
fmt.Println(user.ID)
 
// Create multiple records
users := []models.User{
    {Name: "John", Age: 25},
    {Name: "Jane", Age: 30},
}
db.Create(&users)

// Get single record by primary key
var user models.User
db.First(&user, 1) // WHERE id = 1
 
// Get single record with condition
db.First(&user, "name = ?", "John")
 
// Get all records
var users []models.User
db.Find(&users)
 
// Get first record (ordered by primary key)
db.First(&user)
 
// Get last record
db.Last(&user)

// Update single field
db.Model(&user).Update("name", "John Doe")
 
// Update multiple fields (struct)
db.Model(&user).Updates(models.User{
    Name: "John",
    Age:  26,
})
 
// Update multiple fields (map)
db.Model(&user).Updates(map[string]interface{}{
    "name": "John",
    "age":  26,
})
 
// Update all records
db.Model(&models.User{}).Where("age < ?", 18).Update("status", "minor")

// Delete single record
db.Delete(&user, 1)
 
// Delete with condition
db.Where("age < ?", 18).Delete(&models.User{})
 
// Soft delete (if using gorm.Model)
db.Delete(&user) // Sets DeletedAt
 
// Permanent delete
db.Unscoped().Delete(&user)

// Simple where
db.Where("name = ?", "John").Find(&users)
 
// Multiple conditions
db.Where("name = ? AND age >= ?", "John", 18).Find(&users)
 
// OR condition
db.Where("name = ?", "John").Or("name = ?", "Jane").Find(&users)
 
// NOT condition
db.Not("name = ?", "John").Find(&users)
 
// IN clause
db.Where("name IN ?", []string{"John", "Jane", "Bob"}).Find(&users)
 
// LIKE
db.Where("name LIKE ?", "%John%").Find(&users)
 
// Between
db.Where("age BETWEEN ? AND ?", 18, 30).Find(&users)

// Struct conditions (only non-zero fields)
db.Where(&models.User{Name: "John", Age: 0}).Find(&users)
// WHERE name = 'John' (Age ignored because it's 0)
 
// Map conditions (all fields)
db.Where(map[string]interface{}{
    "name": "John",
    "age":  0,
}).Find(&users)
// WHERE name = 'John' AND age = 0

// Select specific columns
var users []models.User
db.Select("name", "age").Find(&users)
 
// Select with custom query
db.Select("name, age, DATE(created_at) as date").Find(&users)
 
// Omit columns
db.Omit("password").Find(&users)
 
// Select into custom struct
type Result struct {
    Name string
    Age  int
}
var results []Result
db.Model(&models.User{}).Select("name", "age").Find(&results)

// Order by
db.Order("age desc").Find(&users)
db.Order("age desc, name").Find(&users)
 
// Limit
db.Limit(10).Find(&users)
 
// Offset
db.Offset(5).Limit(10).Find(&users)
 
// Pagination
page := 2
pageSize := 10
db.Offset((page - 1) * pageSize).Limit(pageSize).Find(&users)

// Count
var count int64
db.Model(&models.User{}).Where("age > ?", 18).Count(&count)
 
// Sum
var total int
db.Model(&models.Order{}).Select("sum(amount)").Scan(&total)
 
// Average
var avgAge float64
db.Model(&models.User{}).Select("avg(age)").Scan(&avgAge)
 
// Min/Max
var minAge, maxAge int
db.Model(&models.User{}).Select("min(age)").Scan(&minAge)
db.Model(&models.User{}).Select("max(age)").Scan(&maxAge)

// Models
type User struct {
    gorm.Model
    Name  string
    Posts []Post // Has many posts
}
 
type Post struct {
    gorm.Model
    Title  string
    UserID uint
    User   User // Belongs to user
}
 
// Create with association
user := User{
    Name: "John",
    Posts: []Post{
        {Title: "Post 1"},
        {Title: "Post 2"},
    },
}
db.Create(&user)
 
// Preload associations
var users []User
db.Preload("Posts").Find(&users)
 
// Find user with posts
var user User
db.Preload("Posts").First(&user, 1)

// Models
type User struct {
    gorm.Model
    Name  string
    Roles []Role `gorm:"many2many:user_roles;"`
}
 
type Role struct {
    gorm.Model
    Name  string
    Users []User `gorm:"many2many:user_roles;"`
}
 
// Create with association
user := User{
    Name: "John",
    Roles: []Role{
        {Name: "Admin"},
        {Name: "User"},
    },
}
db.Create(&user)
 
// Preload many-to-many
var users []User
db.Preload("Roles").Find(&users)
 
// Append association
var user User
var role Role
db.First(&user, 1)
db.First(&role, 1)
db.Model(&user).Association("Roles").Append(&role)
 
// Remove association
db.Model(&user).Association("Roles").Delete(&role)
 
// Clear all associations
db.Model(&user).Association("Roles").Clear()

type User struct {
    gorm.Model
    Name    string
    Profile Profile
}
 
type Profile struct {
    gorm.Model
    UserID uint
    Bio    string
}
 
// Create with association
user := User{
    Name: "John",
    Profile: Profile{Bio: "Software Developer"},
}
db.Create(&user)
 
// Preload
var user User
db.Preload("Profile").First(&user, 1)

type User struct {
    gorm.Model
    Name string
}
 
func (User) TableName() string {
    return "custom_users"
}

type User struct {
    gorm.Model
    Name  string `gorm:"index"`                    // Regular index
    Email string `gorm:"uniqueIndex"`              // Unique index
    Code  string `gorm:"index:idx_code,unique"`   // Named unique index
}

type User struct {
    gorm.Model
    Name   string
    Status string `gorm:"default:active"`
    Age    int    `gorm:"default:18"`
}

type User struct {
    gorm.Model
    Name  string `gorm:"not null"`
    Email string `gorm:"uniqueIndex;not null"`
    Age   int    `gorm:"check:age >= 18"`
}

type User struct {
    gorm.Model
    Name     string
    Settings datatypes.JSON
}
 
// Usage
settings := map[string]interface{}{
    "theme": "dark",
    "notifications": true,
}
user := User{
    Name:     "John",
    Settings: datatypes.JSON(settings),
}
db.Create(&user)

// Manual transaction
tx := db.Begin()
 
user := models.User{Name: "John"}
if err := tx.Create(&user).Error; err != nil {
    tx.Rollback()
    return err
}
 
post := models.Post{Title: "My Post", UserID: user.ID}
if err := tx.Create(&post).Error; err != nil {
    tx.Rollback()
    return err
}
 
tx.Commit()
 
// Transaction with function
err := db.Transaction(func(tx *gorm.DB) error {
    if err := tx.Create(&user).Error; err != nil {
        return err
    }
 
    if err := tx.Create(&post).Error; err != nil {
        return err
    }
 
    return nil
})