MySQL

Pentru a lucra cu MySQL vom folosi driverul Go MySQL Driver. În primul rând, trebuie să adăugăm acest driver la variabila $GOPATH. Pentru aceasta, executăm în linia de comandă / terminal următoarea comandă:

go get -u github.com/go-sql-driver/mysql

La început vom crea pe serverul MySQL o bază de date numită productdb și în ea un tabel products. Pentru aceasta se pot folosi următoarele expresii SQL.

create database productdb;
use productdb;
create table products (
    id int auto_increment primary key,
    model varchar(30) not null,
    company varchar(30) not null,
    price int not null
)

Adică, baza de date productdb conține un tabel products, care va stoca informații despre produse. Vor fi 4 coloane: id – identificatorul fiecărei înregistrări, model – denumirea produsului, company – producătorul produsului și price – prețul produsului.

Adăugarea datelor

Baza de date creată este goală, așa că vom adăuga în ea câteva date.

package main

import (
	"database/sql"
	"fmt"

	_ "github.com/go-sql-driver/mysql"
)

func main() {
	db, err := sql.Open("mysql", "root:password@/productdb") // Aici punem datele noastre de logare la baza de date MySQL

	if err != nil {
		panic(err)
	}
	defer db.Close()

	result, err := db.Exec("insert into productdb.Products (model, company, price) values (?, ?, ?)",
		"iPhone X", "Apple", 72000)
	if err != nil {
		panic(err)
	}
	fmt.Println(result.LastInsertId()) // id obiectului adăugat
	fmt.Println(result.RowsAffected()) // numarul rândurilor afectate
}

La început conectăm toate pachetele de care avem nevoie. Pentru a lucra cu o bază de date relațională este necesar pachetul "database/sql". Și deoarece folosim mysql, conectăm și pachetul "github.com/go-sql-driver/mysql", iar atenție, în fața lui se află caracterul de subliniere. Acest caracter permite inițializarea pachetului la încărcare prin apelul funcției init.

Apoi deschidem conexiunea cu funcția Open:

sql.Open("mysql", "root:password@/productdb")

Primul argument al funcției este numele driverului, în acest caz "mysql". Al doilea parametru are forma "utilizator:parolă@/bază_de_date". Utilizatorul și parola trebuie să fie cele care au fost specificate pentru mysql la instalare. În cazul meu, utilizatorul este root, iar parola este password. Numele bazei de date — productdb — este cea care a fost creată mai sus.

Această funcție returnează un obiect al bazei de date — DB. Iar pentru a adăuga date, asupra acestui obiect se apelează metoda Exec():

result, err := db.Exec("insert into productdb.Products (model, company, price) values (?, ?, ?)", 
        "iPhone X", "Apple", 72000)

Primul argument al funcției este expresia SQL care adaugă un rând în tabelul Products. Semnele de întrebare din această expresie reprezintă placeholder-e, în locul cărora sunt inserate valorile transmise prin al doilea, al treilea și următorii parametri. Adică, tabelul Products are patru coloane, însă una dintre ele este autogenerată — id. Prin urmare, transmitem trei valori — pentru coloanele model, company și price. De aceea, în expresie sunt trei semne de întrebare și, corespunzător, funcția primește trei parametri suplimentari. Toți parametrii suplimentari sunt transmiși expresiei SQL în locul placeholder-elor în ordinea poziției — primul parametru înlocuiește primul placeholder și așa mai departe.

Rezultatul execuției funcției este stocat în variabila result, care păstrează rezultatul operației efectuate asupra bazei de date. În special, prin metoda result.LastInsertId() putem obține id-ul ultimului obiect adăugat, iar cu ajutorul metodei result.RowsAffected() — numărul de rânduri adăugate.

La executarea acestui script vom obține următoarele rezultate:

Totodată, nu este obligatoriu ca toate datele adăugate să fie definite prin parametri — ele pot fi introduse direct în expresia SQL:

result, err := db.Exec("insert into productdb.Products (model, company, price) values ('Pixel 2', 'Google', 64000)")

Obținerea datelor

Acum vom obține datele adăugate anterior:

package main
import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)
 
type product struct{
    id int
    model string
    company string
    price int
}
func main() { 
    db, err := sql.Open("mysql", "root:password@/productdb")
     
    if err != nil {
        panic(err)
    } 
    defer db.Close()
    rows, err := db.Query("select * from productdb.Products")
    if err != nil {
        panic(err)
    }
    defer rows.Close()
    products := []product{}
     
    for rows.Next(){
        p := product{}
        err := rows.Scan(&p.id, &p.model, &p.company, &p.price)
        if err != nil{
            fmt.Println(err)
            continue
        }
        products = append(products, p)
    }
    for _, p := range products{
        fmt.Println(p.id, p.model, p.company, p.price)
    }
}

Pentru a lucra cu datele, aici a fost definită o structură product, care corespunde datelor din tabelul Products.

Pentru a obține datele, se apelează metoda Query():

rows, err := db.Query("select * from productdb.Products")

Această metodă primește ca parametru o expresie SQL SELECT pentru obținerea tuturor datelor din tabelul Products. Rezultatul interogării este stocat în variabila rows, care reprezintă un pointer către structura Rows. Iar cu ajutorul metodei rows.Next() putem parcurge secvențial toate rândurile din setul de date obținut:

for rows.Next(){
    p := product{}
    err := rows.Scan(&p.id, &p.model, &p.company, &p.price)
    if err != nil{
        fmt.Println(err)
        continue
    }
    products = append(products, p)
}

Tipul Rows definește metoda Scan, cu ajutorul căreia pot fi citite toate datele obținute în variabile. De exemplu, aici citim datele într-o structură Product și apoi o adăugăm într-un slice. Deoarece obținem toate datele — toate cele patru coloane — în Scan se transmit, corespunzător, adresele a patru variabile.

După ce datele au fost citite în slice, putem face orice dorim cu ele, de exemplu, le putem afișa în consolă:

Actualizare

Pentru actualizarea datelor se utilizează metoda Exec:

package main
import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)
 
func main() { 
    db, err := sql.Open("mysql", "root:password@/productdb")
     
    if err != nil {
        panic(err)
    } 
    defer db.Close()
    // обновляем строку с id=1
    result, err := db.Exec("update productdb.Products set price = ? where id = ?", 69000, 1)
    if err != nil{
        panic(err)
    }
    fmt.Println(result.LastInsertId())
    fmt.Println(result.RowsAffected())
}

Ștergere

Pentru ștergere se utilizează de asemenea metoda Exec:

package main
import (
    "database/sql"
    "fmt"
    _ "github.com/go-sql-driver/mysql"
)
 
func main() { 
    db, err := sql.Open("mysql", "root:password@/productdb")
     
    if err != nil {
        panic(err)
    } 
    defer db.Close()
    result, err := db.Exec("delete from productdb.Products where id = 1")
    if err != nil{
        panic(err)
    }
    fmt.Println(result.LastInsertId())  // id последнего удаленого объекта
    fmt.Println(result.RowsAffected())  // количество затронутых строк
}

Deci, am vorbit doar despre baza de date MySQL, dacă o să experimentați bine cu această baza de date, va fi foarte ușor sa treceți la alta, cum ar fi PostgresSQL, MongoDB sau altele. Dacă aici apar întrebări, nu ezitați să le puneți pe canalul nostur de discord!