PostgreSQL, తరచుగా పోస్ట్‌గ్రెస్‌గా సూచించబడుతుంది, ఇది శక్తివంతమైన, ఓపెన్-సోర్స్ ఆబ్జెక్ట్-రిలేషనల్ డేటాబేస్ సిస్టమ్. 30 సంవత్సరాల కంటే ఎక్కువ యాక్టివ్ డెవలప్‌మెంట్‌తో, దాని పటిష్టత, అధునాతన ఫీచర్‌లు మరియు గణనీయమైన ప్రమాణాల సమ్మతి కోసం ఇది బలమైన ఖ్యాతిని పొందింది.
ఇది ఒకే యంత్రాల నుండి డేటా గిడ్డంగులు లేదా అనేక ఉమ్మడి వినియోగదారులతో వెబ్ సేవల వరకు విస్తృతమైన పనిభారాన్ని నిర్వహించడానికి రూపొందించబడింది. ఇది లావాదేవీల సమగ్రత మరియు మన్నికను అందిస్తుంది మరియు వివిధ అధునాతన డేటా రకాలు మరియు శక్తివంతమైన, సౌకర్యవంతమైన డేటా మానిప్యులేషన్ భాషకు మద్దతు ఇస్తుంది.
ఈ ట్యుటోరియల్ గో అప్లికేషన్‌తో PostgreSQL సర్వర్‌ను ఎలా కాన్ఫిగర్ చేయాలో మరియు కనెక్ట్ చేయాలో నేర్పుతుంది.
అవసరాలు:
ప్రోగ్రామింగ్ లాంగ్వేజ్‌కి వెళ్లండి – ఇది గో కంపైలర్ మీ మెషీన్‌లో ఇన్స్టాల్ చేయబడిందని నిర్ధారిస్తుంది.
PostgreSQL డేటాబేస్ – మీరు PostgreSQLని కూడా ఇన్స్టాల్ చేసుకోవాలి. మీరు దీన్ని నేరుగా మీ మెషీన్‌లో ఇన్స్టాల్ చేయవచ్చు లేదా మరింత సరళమైన సెటప్ కోసం డాకర్ కంటైనర్‌ను ఉపయోగించవచ్చు.
అభివృద్ధి సాధనాలు – విజువల్ స్టూడియో కోడ్, గోలాండ్ మొదలైన వాటికి మద్దతు ఇచ్చే ఇంటిగ్రేటెడ్ డెవలప్‌మెంట్ ఎన్విరాన్‌మెంట్ (IDE).
SQL మరియు గో యొక్క ప్రాథమిక జ్ఞానం – PostgreSQL డేటాబేస్తో పరస్పర చర్య చేయడానికి, మీరు తప్పనిసరిగా SQL మరియు మీరు నిర్వహించాల్సిన వివిధ ప్రశ్నలను అర్థం చేసుకోవాలి. మీకు గో భాషపై ప్రాథమిక అవగాహన కూడా అవసరం.
అందించిన అవసరాలకు అనుగుణంగా, మేము ఈ క్రింది దశలకు వెళ్లవచ్చు.
ప్రాజెక్ట్ సెటప్
మన ప్రాజెక్ట్ డైరెక్టరీ నిర్మాణాన్ని సెటప్ చేయడం ద్వారా ప్రారంభిద్దాం. మీరు ప్రాజెక్ట్ సోర్స్ కోడ్‌ను నిల్వ చేయాల్సిన ప్రధాన డైరెక్టరీని సృష్టించండి.
$ mkdir గోలాంగ్_పోస్ట్గ్రెస్డైరెక్టరీలోకి నావిగేట్ చేయండి మరియు కొత్త గో మాడ్యూల్‌ను ప్రారంభించండి.
$ cd గోలాంగ్_పోస్ట్‌గ్రెస్ && mod init మెయిన్‌కి వెళ్లండిఅవసరమైన డ్రైవర్లను ఇన్స్టాల్ చేయండి
PostgreSQL డేటాబేస్తో పరస్పర చర్య చేయడానికి, Go ప్రోగ్రామింగ్ లాంగ్వేజ్ కోసం మాకు PostgreSQL డ్రైవర్ అవసరం.
ఈ ట్యుటోరియల్ కోసం, మేము PostgreSQL డేటాబేస్తో పని చేయడానికి అనేక రకాల ఫీచర్లను అందించే pq డ్రైవర్‌ని ఉపయోగిస్తాము.
కింది ఆదేశాన్ని అమలు చేయడం ద్వారా మీరు దీన్ని ఇన్స్టాల్ చేయవచ్చు:
github.comని పొందండి / లిబ్ / pqఒక డేటాబేస్ సృష్టించండి
తదుపరి దశ కొత్త PostgreSQL డేటాబేస్‌ను సృష్టించడం. మళ్ళీ, మనం దీన్ని PostgreSQL షెల్‌లో చేయవచ్చు.
$ psql -IN పోస్ట్గ్రెస్ఈ ఆదేశం పోస్ట్‌గ్రెస్ పాస్వర్డ్ కోసం మిమ్మల్ని అడుగుతుంది. లాగిన్ అయిన తర్వాత, కొత్త డేటాబేస్‌ను ప్రారంభించడానికి “డేటాబేస్ సృష్టించు” ఆదేశాన్ని అమలు చేయండి:
postgres=# డేటాబేస్ గోలాంగ్‌ని సృష్టించండి;డేటాబేస్ సృష్టించండి
ఇచ్చిన ఆదేశం 'గోలాంగ్' అనే కొత్త డేటాబేస్‌ను సృష్టిస్తుంది. మీకు కావలసిన పేరుతో డేటాబేస్ పేరును భర్తీ చేయడానికి సంకోచించకండి.
డేటాబేస్కు కనెక్ట్ చేయడం ద్వారా విజయవంతంగా సృష్టించబడిందని మీరు ధృవీకరించవచ్చు.
postgres=# \c గోలాంగ్;మీరు ఇప్పుడు డేటాబేస్ 'గోలాంగ్'కి వినియోగదారు 'పోస్ట్‌గ్రెస్'గా కనెక్ట్ అయ్యారు.
తరువాత, మీరు డేటాను నిల్వ చేయాలనుకుంటున్న పట్టికను సెటప్ చేయండి. సెషన్ సమాచారాన్ని నిల్వ చేసే ఈ ట్యుటోరియల్ కోసం మేము ఒక సాధారణ పట్టికను సృష్టిస్తాము.
టేబుల్ db_clientsని సృష్టించండి (ఐడి సీరియల్ ప్రైమరీ కీ,
పేరు వర్చర్(100) శూన్యం కాదు,
సెషన్_టైమ్ TIMESTAMP శూన్యం కాదు,
number_of_queries INT డిఫాల్ట్ 0,
యాక్టివ్_స్టేట్ బూలియన్ డిఫాల్ట్ తప్పు
);
ఇవ్వబడిన ప్రశ్న 'db_clients' అనే కొత్త పట్టికను సృష్టించాలి, అది ఇచ్చిన డేటాబేస్ సర్వర్‌లోకి లాగిన్ అయిన క్లయింట్‌ల గురించి సమాచారాన్ని నిల్వ చేస్తుంది.
PostgreSQLతో Go యాప్‌ని కనెక్ట్ చేయండి
మేము డేటాబేస్ మరియు డేటాబేస్ టేబుల్‌ని సెటప్ చేసిన తర్వాత, మేము కొనసాగవచ్చు మరియు PostgreSQL సర్వర్‌తో మా గో అప్లికేషన్‌ను ఎలా కనెక్ట్ చేయాలో తెలుసుకోవచ్చు.
మీ ప్రాజెక్ట్ యొక్క రూట్‌లో “main.go” ఫైల్‌ని సృష్టించడం ద్వారా ప్రారంభించండి:
$ స్పర్శ ప్రధాన.గోతర్వాత, మీకు నచ్చిన టెక్స్ట్ ఎడిటర్‌తో ఫైల్‌ని ఎడిట్ చేయండి:
$ ఎందుకంటే ప్రధాన.గో“main.go” ఫైల్‌లో, కింది వాటిలో చూపిన విధంగా సోర్స్ కోడ్‌ను జోడించండి:
ప్యాకేజీ ప్రధానదిగుమతి (
'డేటాబేస్/sql'
'fmt'
'లాగ్'
_ 'github.com/lib/pq'
)
ఫంక్ మెయిన్ ( ) {
connStr := 'postgres://postgres:password@localhost/golang?sslmode=disable'
db, err := sql.ఓపెన్ ( 'పోస్ట్‌గ్రేస్' , connStr )
ఉంటే తప్పు ! = లేదు {
log.Fatal ( తప్పు )
}
ఉంటే err = db.పింగ్ ( ) ; తప్పు ! = లేదు {
log.Fatal ( తప్పు )
}
fmt.Println ( 'డేటాబేస్కు కనెక్ట్ చేయబడింది' )
}
మునుపటి కోడ్‌లో, అవసరమైన మాడ్యూళ్ళను దిగుమతి చేయడం ద్వారా మేము ప్రారంభిస్తాము. అప్పుడు మేము ప్రధాన విధిని నిర్వచించాము. చివరగా, ప్రధాన ఫంక్షన్‌లో, టార్గెట్ హోస్ట్, డేటాబేస్ యూజర్, డేటాబేస్ పాస్వర్డ్ మరియు వాస్తవ లక్ష్య డేటాబేస్‌ను పేర్కొనడానికి మమ్మల్ని అనుమతించే కనెక్షన్ స్ట్రింగ్‌ను మేము నిర్వచించాము.
మాడ్యూల్ కనెక్షన్ స్ట్రింగ్‌లోని క్రింది పారామితులకు మద్దతు ఇస్తుంది:
- dbname – కనెక్ట్ చేయవలసిన డేటాబేస్ పేరు.
- వినియోగదారు - ఇలా సైన్ ఇన్ చేయాల్సిన వినియోగదారు.
- పాస్వర్డ్ - వినియోగదారు పాస్వర్డ్.
- హోస్ట్ - కనెక్ట్ చేయవలసిన హోస్ట్. “/”తో ప్రారంభమయ్యే విలువలు Unix డొమైన్ సాకెట్‌ల కోసం ఉంటాయి (డిఫాల్ట్ స్థానిక హోస్ట్).
- పోర్ట్ – బైండ్ చేయాల్సిన పోర్ట్ (డిఫాల్ట్ 5432).
- sslmode – SSLని ఉపయోగించాలా వద్దా (డిఫాల్ట్ అవసరం; ఇది libpq కోసం డిఫాల్ట్ కాదు).
- fallback_application_name – ఒక అప్లికేషన్_పేరు అందించబడకపోతే తిరిగి వస్తుంది.
- connect_timeout - సెకన్లలో కనెక్షన్ కోసం గరిష్ట నిరీక్షణ. సున్నా లేదా పేర్కొనబడలేదు అంటే నిరవధికంగా వేచి ఉండటం.
- sslcert – సర్ట్ ఫైల్ స్థానం. ఫైల్ తప్పనిసరిగా PEM-ఎన్‌కోడ్ చేసిన డేటాను కలిగి ఉండాలి.
- sslkey - కీ ఫైల్ స్థానం. ఫైల్ తప్పనిసరిగా PEM-ఎన్‌కోడ్ చేసిన డేటాను కలిగి ఉండాలి.
- sslrootcert – రూట్ సర్టిఫికేట్ ఫైల్ యొక్క స్థానం. ఫైల్ తప్పనిసరిగా PEM-ఎన్‌కోడ్ చేసిన డేటాను కలిగి ఉండాలి.
మీరు మీ లక్ష్య కనెక్షన్ లక్షణాలను అవసరమైన విధంగా కాన్ఫిగర్ చేయవచ్చు. SSL మరియు ఆమోదించబడిన SSLMode పారామితులను కాన్ఫిగర్ చేయడానికి, మా ట్యుటోరియల్‌ని తనిఖీ చేయండి https://linuxhint.com/postgres-sslmode .
కనెక్షన్ లక్షణాలతో సంతృప్తి చెందిన తర్వాత, కనెక్షన్ ఏర్పాటు చేయబడిందో లేదో పరీక్షించడానికి మీరు మునుపటి కోడ్‌ని అమలు చేయవచ్చు.
పరుగు .\main.goకనెక్షన్ తర్వాత, మీరు క్రింది అవుట్‌పుట్‌ను పొందాలి:
డేటాబేస్కు కనెక్ట్ చేయబడిందిPostgreSQL పట్టికలోకి డేటాను చొప్పించండి
మేము ముందుగా సృష్టించిన పట్టికలో నమూనా డేటాను చొప్పించడం తదుపరి దశ. మేము ఇన్సర్ట్ ప్రశ్నలను స్ట్రింగ్ లిటరల్‌గా నిర్వచించడం ద్వారా దీన్ని చేయవచ్చు మరియు లక్ష్య ప్రశ్నను అమలు చేయడానికి db.Exec() ఫంక్షన్‌ని ఉపయోగించవచ్చు.
కోడ్ క్రింది విధంగా ఉంది:
---insertStatement := `db_clients (పేరు, సెషన్_టైమ్, number_of_queries, active_state)కి ఇన్సర్ట్ చేయండి
విలువలు
('psql', '2023-05-26 10:15:00', 10, నిజం)
('డేటాగ్రిప్', '2023-05-26 09:30:00', 5, నిజం)
('dbeaver', '2023-05-26 11:00:00', 20, నిజం)
('వర్క్‌బెంచ్', '2023-05-26 14:45:00', 15, తప్పు)
('రిమోట్', '2023-05-26 13:20:00', 8, నిజం);`
_, తప్పు = db.Exec(ఇన్సర్ట్‌స్టేట్‌మెంట్)
తప్పు చేస్తే != నిల్ {
log.Fatal(తప్పు)
}
మీరు మునుపటి కోడ్‌ని అమలు చేస్తే, అది నిర్దేశిత రికార్డులను లక్ష్య పట్టికలో చొప్పించాలి.
PostgreSQL ప్రశ్న డేటా
పట్టిక నుండి అడ్డు వరుసలను ప్రశ్నించడానికి, మేము ఎంచుకున్న స్టేట్‌మెంట్‌ను స్ట్రింగ్‌గా నిర్వచించవచ్చు మరియు దానిని అమలు చేయడానికి db.Query()ని ఉపయోగించవచ్చు. మేము తదుపరి() ఫంక్షన్‌ని ఉపయోగించి పట్టిక వరుసలపై మళ్ళించవచ్చు మరియు క్రింది వాటిలో చూపిన విధంగా వాటిని ముద్రించవచ్చు:
అడ్డు వరుసలు, తప్పు := db.Query ( 'db_clients నుండి * ఎంచుకోండి' )ఉంటే తప్పు ! = లేదు {
log.Fatal ( తప్పు )
}
అడ్డు వరుసలను వాయిదా వేయండి.మూసివేయండి ( )
కోసం వరుసలు. తదుపరి ( ) {
ఉంది id int
var పేరు స్ట్రింగ్
var సెషన్సమయం సమయం.సమయం
var numberOfQueries int
var యాక్టివ్ స్టేట్ బూల్
తప్పు := అడ్డు వరుసలు.స్కాన్ ( & id , & పేరు, & సెషన్ సమయం, & ప్రశ్నల సంఖ్య, & క్రియాశీల రాష్ట్రం )
ఉంటే తప్పు ! = లేదు {
log.Fatal ( తప్పు )
}
fmt.Printf ( 'ID: %d, పేరు: %s, సెషన్ సమయం: %s, ప్రశ్నల సంఖ్య: %d, క్రియాశీల స్థితి: %t \n ' , id , పేరు, సెషన్ టైమ్, నంబర్ ఆఫ్ క్వెరీస్, యాక్టివ్ స్టేట్ )
}
ఉంటే err = వరుసలు.Err ( ) ; తప్పు ! = లేదు {
log.Fatal ( తప్పు )
}
మేము మునుపటి కోడ్‌ని అమలు చేసిన తర్వాత, అది క్రింది ఉదాహరణ అవుట్‌పుట్‌లో చూపిన విధంగా db_clients పట్టిక నుండి అన్ని అడ్డు వరుసలను ముద్రించాలి:
అక్కడ మీ దగ్గర ఉంది!
ముగింపు
గోలాంగ్‌ని ఉపయోగించి PostgreSQL డేటాబేస్‌ని కనెక్ట్ చేయడానికి మరియు ప్రశ్నించడానికి pq ప్యాకేజీని ఎలా ఉపయోగించవచ్చో మేము అన్వేషించాము.