package main

import "fmt"

func main() {
    // Создание карты
    myMap := make(map[string]int)

    // Вставка значений
    myMap["Alice"] = 25
    myMap["Bob"] = 30

    // Поиск значений
    value, exists := myMap["Alice"]
    if exists {
        fmt.Println("Alice:", value) // Alice: 25
    } else {
        fmt.Println("Alice not found")
    }

    // Удаление значений
    delete(myMap, "Alice")
    _, exists = myMap["Alice"]
    if !exists {
        fmt.Println("Alice has been deleted") // Alice has been deleted
    }
}

type Person struct {
    Name string
    Age  int
}

func (p Person) Greet() {
    fmt.Printf("Hello, my name is %s\n", p.Name)
}

type Person struct {
    name string // неэкспортируемое поле
    Age  int    // экспортируемое поле
}

type Employee struct {
    Person
    Position string
}

type Greeter interface {
    Greet()
}

func SayHello(g Greeter) {
    g.Greet()
}

type Person struct {
    Name string
}

func (p Person) Greet() {
    fmt.Printf("Hello, my name is %s\n", p.Name)
}

func main() {
    p := Person{Name: "John"}
    SayHello(p)
}

type Greeter interface {
    Greet()
}

func SayHello(g Greeter) {
    g.Greet()
}

type Robot struct {
    ID string
}

func (r Robot) Greet() {
    fmt.Printf("Greetings, I am robot %s\n", r.ID)
}

func main() {
    p := Person{Name: "John"}
    r := Robot{ID: "XJ-9"}

    SayHello(p)
    SayHello(r)
}

SELECT u.name, sub.total
FROM users u
JOIN (
    SELECT user_id, total
    FROM orders
    WHERE total > 100
) AS sub ON u.id = sub.user_id;

type slice struct {
    ptr *ElementType // Указатель на базовый массив
    len int          // Длина
    cap int          // Емкость
}

package main

import "fmt"

func main() {
    arr := [5]int{1, 2, 3, 4, 5}
    slice := arr[1:4] // Слайс содержит элементы с индексами 1, 2, 3
    fmt.Println(slice) // [2 3 4]
}

package main

import "fmt"

func main() {
    slice := make([]int, 3, 5) // Слайс длиной 3 и емкостью 5
    fmt.Println(slice)         // [0 0 0]
}

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3, 4, 5}
    fmt.Println(slice[0]) // 1
    slice[1] = 10
    fmt.Println(slice)    // [1 10 3 4 5]
}

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3}
    slice = append(slice, 4, 5) // Добавляем элементы 4 и 5 в конец слайса
    fmt.Println(slice)          // [1 2 3 4 5]
}

package main

import "fmt"

func main() {
    slice := []int{1, 2, 3, 4, 5}
    subSlice := slice[1:4] // Слайс содержит элементы с индексами 1, 2, 3
    fmt.Println(subSlice)  // [2 3 4]
}

package main

import "fmt"

func main() {
    src := []int{1, 2, 3}
    dst := make([]int, len(src))
    copy(dst, src)
    fmt.Println(dst) // [1 2 3]
}

package main

import "fmt"

func main() {
    slice := make([]int, 3, 5)
    fmt.Println("Before append:", slice, "Len:", len(slice), "Cap:", cap(slice))

    slice = append(slice, 1, 2, 3)
    fmt.Println("After append:", slice, "Len:", len(slice), "Cap:", cap(slice))

    slice = append(slice, 4)
    fmt.Println("After another append:", slice, "Len:", len(slice), "Cap:", cap(slice))
}

   client := &http.Client{
       Timeout: 5 * time.Second, // Запрос не может длиться дольше 5 секунд
   }

   transport := &http.Transport{
       DialContext: (&net.Dialer{
           Timeout: 2 * time.Second, // 2 секунды на подключение
       }).DialContext,
   }
   client := &http.Client{Transport: transport}

   transport := &http.Transport{
       ResponseHeaderTimeout: 3 * time.Second, // 3 секунды на заголовки
   }

package main

import "fmt"

func main() {
    str := "Привет"
    
    fmt.Println(str[0])           // 208 (байт, не символ!)
    fmt.Printf("%c\n", str[0])    // П (символ, представленный первым байтом UTF-8)
}

package main

import "fmt"

func main() {
    arr := [5]int{10, 20, 30, 40, 50}
    
    fmt.Println(arr[2]) // 30
    
    // Изменение значения по индексу
    arr[2] = 100
    fmt.Println(arr) // [10 20 100 40 50]
}

package main

import "fmt"

func main() {
    nums := []int{10, 20, 30, 40, 50}
    
    for i, v := range nums {
        fmt.Printf("Индекс: %d, Значение: %d\n", i, v)
    }
}

package main

import "fmt"

func main() {
    str := "Привет, Мир!"
    
    fmt.Println(str[8:12]) // Мир
}

   package main

   func main() {
       nums := []int{1, 2, 3}
       fmt.Println(nums[5]) // panic: runtime error: index out of range
   }
   

newSlice := originalSlice[start:end]

package main

import "fmt"

func main() {
    original := []int{1, 2, 3, 4, 5}
    newSlice := original[1:4] // Элементы с индексами 1, 2 и 3
    fmt.Println(newSlice) // [2 3 4]
}

      package main

   import "fmt"

   func main() {
       original := []int{1, 2, 3, 4, 5}
       
       // Это вызовет панику: runtime error: slice bounds out of range
       // newSlice := original[1:6]
       
       // Правильное использование
       newSlice := original[1:5]
       fmt.Println(newSlice) // [2 3 4 5]
   }
   

      package main

   import "fmt"

   func main() {
       original := []int{1, 2, 3, 4, 5}
       newSlice := original[1:4]
       newSlice[0] = 20
       fmt.Println("Original:", original) // [1 20 3 4 5]
       fmt.Println("New Slice:", newSlice) // [20 3 4]
   }
   

      package main

   import "fmt"

   func main() {
       original := []int{1, 2, 3, 4, 5}
       newSlice := original[1:4]
       fmt.Println("New Slice Length:", len(newSlice)) // 3
       fmt.Println("New Slice Capacity:", cap(newSlice)) // 4
   }
   

      package main

   import "fmt"

   func main() {
       original := []int{1, 2, 3, 4, 5}
       newSlice := make([]int, 3)
       copy(newSlice, original[1:4])
       newSlice[0] = 20
       fmt.Println("Original:", original) // [1 2 3 4 5]
       fmt.Println("New Slice:", newSlice) // [20 3 4]
   }
   

newSlice := original[start:end:max

      package main

   import "fmt"

   func main() {
       original := []int{1, 2, 3, 4, 5}
       newSlice := original[1:3:4]
       fmt.Println("New Slice:", newSlice) // [2 3]
       fmt.Println("New Slice Capacity:", cap(newSlice)) // 3
   }
   

      func readFile(filename string) (string, error) {
       f, err := os.Open(filename)
       if err != nil {
           return "", err
       }
       defer f.Close()  // Гарантирует, что файл будет закрыт при выходе из функции.

       data, err := ioutil.ReadAll(f)
       if err != nil {
           return "", err
       }
       return string(data), nil
   }
   

var mu sync.Mutex

func process() {
    mu.Lock()
    defer mu.Unlock()  // Гарантирует, что мьютекс будет разблокирован

    // выполняем некоторые операции, которые могут вызвать панику или вернуть ошибку
}

CREATE TABLE orders_log (
    id SERIAL PRIMARY KEY,
    order_id INT,
    old_status TEXT,
    new_status TEXT,
    changed_at TIMESTAMP DEFAULT now()
);

CREATE OR REPLACE FUNCTION log_order_update()
RETURNS TRIGGER AS $$
BEGIN
    INSERT INTO orders_log (order_id, old_status, new_status)
    VALUES (OLD.id, OLD.status, NEW.status);
    RETURN NEW;
END;
$$ LANGUAGE plpgsql;

CREATE TRIGGER order_status_change
AFTER UPDATE ON orders
FOR EACH ROW
WHEN (OLD.status IS DISTINCT FROM NEW.status)
EXECUTE FUNCTION log_order_update();