PostgreSQL, ofta helt enkelt kallat Postgres, är ett kraftfullt objektrelationellt databassystem med öppen källkod. Med mer än 30 år av aktiv utveckling har den fått ett starkt rykte för sin robusthet, avancerade funktioner och betydande standardefterlevnad.
Den är utformad för att hantera omfattande arbetsbelastningar, från enstaka maskiner till datalager eller webbtjänster med många samtidiga användare. Det ger transaktionsintegritet och hållbarhet och stöder olika avancerade datatyper och kraftfullt, flexibelt datamanipuleringsspråk.
Denna handledning lär oss hur man konfigurerar och ansluter en PostgreSQL-server med en Go-applikation.
Krav:
Gå till programmeringsspråk – Det säkerställer att Go-kompilatorn är installerad på din maskin.
PostgreSQL-databas – Du måste också ha PostgreSQL installerad. Du kan installera den direkt på din maskin eller använda en Docker-behållare för en enklare installation.
Utvecklings verktyg – En integrerad utvecklingsmiljö (IDE) som stöder Go som Visual Studio Code, GoLand, etc.
Grundläggande kunskaper i SQL och Go – För att interagera med PostgreSQL-databasen måste du förstå SQL och de olika frågor som du behöver utföra. Du behöver också en grundläggande förståelse för Go-språket.
Med de givna kraven uppfyllda kan vi gå vidare till följande steg.
Projektuppställning
Låt oss börja med att sätta upp vår projektkatalogstruktur. Skapa huvudkatalogen där du behöver lagra projektets källkod.
$ mkdir golang_postgresNavigera in i katalogen och initiera en ny Go-modul.
$ CD golang_postgres && go mod init mainInstallera de nödvändiga drivrutinerna
För att kunna interagera med PostgreSQL-databasen behöver vi en PostgreSQL-drivrutin för programmeringsspråket Go.
För den här handledningen använder vi pq-drivrutinen som erbjuder ett brett utbud av funktioner för att arbeta med PostgreSQL-databasen.
Du kan installera det genom att köra följande kommando:
skaffa github.com / lib / pqSkapa en databas
Nästa steg är att skapa en ny PostgreSQL-databas. Återigen, vi kan göra detta i PostgreSQL-skalet.
$ psql -I postgresDetta kommando uppmanar dig att ange lösenordet för postgres. När du har loggat in, kör kommandot 'skapa databas' för att initiera en ny databas:
postgres=# skapa databas golang;SKAPA DATABAS
Det givna kommandot skapar en ny databas som heter 'golang'. Byt gärna ut databasnamnet med ditt önskade namn.
Du kan sedan verifiera att databasen har skapats framgångsrikt genom att ansluta till den.
postgres=# \c golang;Du är nu ansluten till databasen 'golang' som användare 'postgres'.
Ställ sedan upp tabellen där du vill lagra data. Vi skapar en enkel tabell för denna handledning som lagrar sessionsinformationen.
SKAPA TABELL db_clients (ID SERIELL PRIMÄRNYCKEL,
namn VARCHAR(100) NOT NULL,
session_time TIMESTAMP INTE NULL,
antal_av_frågor INT DEFAULT 0,
active_state BOOLEAN DEFAULT FALSE
);
Den givna frågan ska skapa en ny tabell som heter 'db_clients' som lagrar information om de klienter som är inloggade på en given databasserver.
Anslut Go-appen med PostgreSQL
När vi väl har ställt in databasen och databastabellen kan vi fortsätta och lära oss hur vi ansluter vår Go-applikation med PostgreSQL-servern.
Börja med att skapa en 'main.go'-fil i roten av ditt projekt:
$ Rör main.goRedigera sedan filen med din valda textredigerare:
$ därför att main.goI filen 'main.go', lägg till källkoden som visas i följande:
huvudpaketetimportera (
'databas/sql'
'fmt'
'logga'
_ 'github.com/lib/pq'
)
func huvud ( ) {
connStr := 'postgres://postgres:password@localhost/golang?sslmode=disable'
db, err := sql.Open ( 'postgres' , connStr )
om fela ! = noll {
log.Dödlig ( fela )
}
om fel = db.Ping ( ) ; fela ! = noll {
log.Dödlig ( fela )
}
fmt.Println ( 'Ansluten till databas' )
}
I föregående kod börjar vi med att importera de nödvändiga modulerna. Vi definierar sedan huvudfunktionen. Slutligen, i huvudfunktionen, definierar vi anslutningssträngen som tillåter oss att specificera målvärden, databasanvändaren, databaslösenordet och den faktiska måldatabasen.
Modulen stöder följande parametrar i anslutningssträngen:
- dbname – Namnet på databasen att ansluta till.
- användare – Användaren att logga in som.
- lösenord – Användarens lösenord.
- värd – Värden att ansluta till. Värdena som börjar med '/' är för Unix-domänsockets (standard är localhost).
- port – Porten att binda till (standard är 5432).
- sslmode – Huruvida SSL ska användas eller inte (standarden är nödvändig, detta är inte standard för libpq).
- fallback_application_name – Ett application_name att falla tillbaka till om ett inte tillhandahålls.
- connect_timeout – Den maximala väntetiden på anslutning i sekunder. Noll eller ej specificerad betyder att vänta på obestämd tid.
- sslcert – Cert-filens plats. Filen måste innehålla PEM-kodade data.
- sslkey – Nyckelfilens plats. Filen måste innehålla PEM-kodade data.
- sslrootcert – Platsen för rotcertifikatfilen. Filen måste innehålla PEM-kodade data.
Du kan konfigurera dina målanslutningsegenskaper efter behov. För att konfigurera SSL och de accepterade SSLMode-parametrarna, kolla vår handledning på https://linuxhint.com/postgres-sslmode .
När du är nöjd med anslutningsegenskaperna kan du köra föregående kod för att testa om anslutningen är upprättad.
gå springa .\main.goVid anslutning bör du få följande utdata:
Ansluten till databasenPostgreSQL Infoga data i tabellen
Nästa steg är att infoga exempeldata i tabellen som vi skapade tidigare. Vi kan göra detta genom att definiera infogningsfrågorna som en bokstavlig sträng och sedan använda funktionen db.Exec() för att köra målfrågan.
Koden är som följer:
---insertStatement := `INSERT INTO db_clients (namn, session_time, number_of_queries, active_state)
VÄRDEN
('psql', '2023-05-26 10:15:00', 10, sant),
('datagrip', '2023-05-26 09:30:00', 5, sant),
('dbeaver', '2023-05-26 11:00:00', 20, sant),
('workbench', '2023-05-26 14:45:00', 15, false),
('fjärr', '2023-05-26 13:20:00', 8, sant);'
_, err = db.Exec(insertStatement)
om fel != noll {
log.Fatal(err)
}
Om du kör den föregående koden bör den infoga de angivna posterna i måltabellen.
PostgreSQL-frågedata
För att fråga raderna från tabellen kan vi definiera select-satsen som en sträng och använda db.Query() för att köra den. Vi kan iterera över tabellraderna med hjälp av Next()-funktionen och skriva ut dem som visas i följande:
rader, err := db.Query ( 'VÄLJ * FRÅN db_clients' )om fela ! = noll {
log.Dödlig ( fela )
}
skjuta upp rader.Stäng ( )
för rader.Nästa ( ) {
var id int
var namnsträng
var sessionTime time.Time
var numberOfQueries int
var activeState bool
err := rader.Skanna ( & id , & namn, & sessionTime, & numberOfQueries, & activeState )
om fela ! = noll {
log.Dödlig ( fela )
}
fmt.Printf ( 'ID: %d, Namn: %s, Sessionstid: %s, Antal frågor: %d, Aktivt tillstånd: %t \n ' , id , namn, sessionTime, numberOfQueries, activeState )
}
om err = rader.Err ( ) ; fela ! = noll {
log.Dödlig ( fela )
}
När vi har kört den föregående koden ska den skriva ut alla rader från tabellen db_clients som visas i följande exempelutdata:
Där har du det!
Slutsats
Vi utforskade hur vi kan använda pq-paketet för att ansluta och fråga PostgreSQL-databasen med Golang.