ముందస్తు అవసరాలు:
ఈ ట్యుటోరియల్‌లోని ఉదాహరణలను సాధన చేయడానికి ముందు మీరు ఈ క్రింది పనులను పూర్తి చేయాలి:
A. సిస్టమ్‌లో గోలాంగ్ భాషని ఇన్‌స్టాల్ చేయండి, ఒకవేళ ఇది ముందు ఇన్‌స్టాల్ చేయబడకపోతే. గోలాంగ్ యొక్క ఇన్‌స్టాల్ చేసిన సంస్కరణను తనిఖీ చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి:
$ గో వెర్షన్
బి. సిస్టమ్‌లో sqlite3ని ఇన్‌స్టాల్ చేయండి, ఒకవేళ అది ఇంతకు ముందు ఇన్‌స్టాల్ చేయబడకపోతే. Ubuntu 20+లో Sqlite3 డిఫాల్ట్‌గా ఇన్‌స్టాల్ చేయబడింది. sqlite3 యొక్క ఇన్‌స్టాల్ చేసిన సంస్కరణను తనిఖీ చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి:
$ sqlite3 --వెర్షన్
C. 'golang-sqlite' పేరుతో ఫోల్డర్‌ని సృష్టించడానికి క్రింది ఆదేశాలను అమలు చేయండి మరియు SQLite డేటాబేస్ ఫైల్ మరియు గోలాంగ్ ఫైల్ నిల్వ చేయబడే ఫోల్డర్‌కు వెళ్లండి:
$ mkdir గోలాంగ్-స్క్లైట్$ cd గోలాంగ్-స్క్లైట్
D. గోలాంగ్‌తో SQLiteని ఉపయోగించడానికి అవసరమైన గోలాంగ్ ప్యాకేజీని డౌన్‌లోడ్ చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి:
$ github.com/mattn/go-sqlite3 పొందండి
గోలాంగ్ మరియు SQLite ఉపయోగించి డేటాబేస్ కార్యకలాపాలు
SQLite డేటాబేస్ మరియు గోలాంగ్ స్క్రిప్ట్‌ని ఉపయోగించే ప్రాథమిక డేటాబేస్ కార్యకలాపాలు ఈ ట్యుటోరియల్‌లో చూపబడ్డాయి. ఈ ట్యుటోరియల్‌లో కవర్ చేయబడిన డేటాబేస్ టాస్క్‌ల జాబితా క్రింది వాటిలో పేర్కొనబడింది:
- ఒక SQLite డేటాబేస్ సృష్టించండి
- SQLite డేటాబేస్ కనెక్షన్ చేయండి
- కొత్త పట్టికను సృష్టించండి
- పట్టికలో డేటాను చొప్పించండి
- పట్టిక నుండి డేటాను చదవండి
- పట్టిక యొక్క డేటాను నవీకరించండి
- పట్టిక నుండి డేటాను తొలగించండి
గోలాంగ్‌ని ఉపయోగించి SQLite డేటాబేస్ను సృష్టించండి
'test.db' పేరుతో కొత్త SQLite డేటాబేస్ ఫైల్‌ను సృష్టించే క్రింది స్క్రిప్ట్‌తో గోలాంగ్ ఫైల్‌ను సృష్టించండి. స్క్రిప్ట్‌లోకి నాలుగు మాడ్యూల్‌లు దిగుమతి చేయబడ్డాయి. టెర్మినల్‌లో అవుట్‌పుట్‌ను ప్రింట్ చేయడానికి “fmt” మాడ్యూల్ ఉపయోగించబడుతుంది. ఏదైనా లోపం కనిపించినప్పుడు ప్రోగ్రామ్‌ను ఆపివేయడానికి “లాగ్” మాడ్యూల్ ఉపయోగించబడుతుంది. 'os' మాడ్యూల్ SQLite డేటాబేస్ను సృష్టించడానికి మరియు లోపాన్ని నిర్వహించడానికి ఉపయోగించబడుతుంది. గోలాంగ్ ద్వారా SQLite డేటాబేస్‌తో కనెక్షన్‌లను చేయడానికి “go-sqlite3” మాడ్యూల్ ఉపయోగించబడుతుంది. SQLite డేటాబేస్‌ని సృష్టించడానికి “os” మాడ్యూల్ యొక్క Create() పద్ధతి ఇక్కడ ఉపయోగించబడుతుంది. డేటాబేస్ విజయవంతంగా సృష్టించబడినట్లయితే, టెర్మినల్‌లో విజయ సందేశం ముద్రించబడుతుంది. లేకపోతే, ప్రోగ్రామ్ నిలిపివేయబడుతుంది. డేటాబేస్ కనెక్షన్‌ను మూసివేయడానికి క్లోజ్ () పద్ధతిని పిలుస్తారు.
ప్యాకేజీ ప్రధాన//అవసరమైన మాడ్యూల్‌లను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'లాగ్'
'నువ్వు'
_ 'github.com/mattn/go-sqlite3'
)
ఫంక్ ప్రధాన () {
//కొత్త SQLite డేటాబేస్ సృష్టించండి
db , తప్పు := మీరు . సృష్టించు ( 'test.db' )
//ఏదైనా లోపం కోసం తనిఖీ చేయండి
ఉంటే తప్పు != శూన్యం {
//దోష సందేశాన్ని లాగ్‌కు జోడించండి
లాగ్ . ప్రాణాంతకం ( తప్పు )
} లేకపోతే {
//విజయ సందేశాన్ని ముద్రించండి
fmt . Println ( 'డేటాబేస్ సృష్టించబడింది.' )
}
//డేటాబేస్ కనెక్షన్‌ను మూసివేయండి
db . దగ్గరగా ()
}
“db_connect.go” ఫైల్‌ను అమలు చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి:
$ db_connect.goని అమలు చేయండి“test.db” డేటాబేస్ ఫైల్ సృష్టించబడిందో లేదో తనిఖీ చేయడానికి “ls” ఆదేశాన్ని అమలు చేయండి:
$లు'డేటాబేస్ సృష్టించబడింది' అనే విజయ సందేశం అవుట్‌పుట్‌లో ముద్రించబడిందని మరియు 'test.db' ఫైల్ ప్రస్తుత స్థానంలో సృష్టించబడిందని క్రింది అవుట్‌పుట్ చూపిస్తుంది:
గోలాంగ్‌ని ఉపయోగించి SQLite డేటాబేస్‌తో కనెక్ట్ అవ్వండి
'test.db' డేటాబేస్ ఫైల్‌ను తెరిచే క్రింది స్క్రిప్ట్‌తో గోలాంగ్ ఫైల్‌ను సృష్టించండి మరియు డేటాబేస్‌తో కనెక్షన్‌ని చేయండి. ఈ పనిని చేయడానికి గోలాంగ్ యొక్క డేటాబేస్/SQL మాడ్యూల్ ఇక్కడ దిగుమతి చేయబడింది. ఇప్పటికే ఉన్న SQLite డేటాబేస్‌తో కనెక్షన్ చేయడానికి ఓపెన్() పద్ధతి ఇక్కడ ఉపయోగించబడుతుంది. డేటాబేస్ విజయవంతంగా కనెక్ట్ చేయబడితే, టెర్మినల్‌లో విజయ సందేశం ముద్రించబడుతుంది. లేకపోతే, ప్రోగ్రామ్ నిలిపివేయబడుతుంది.
ప్యాకేజీ ప్రధాన//అవసరమైన మాడ్యూల్‌లను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'లాగ్'
'డేటాబేస్/sql'
_ 'github.com/mattn/go-sqlite3'
)
ఫంక్ ప్రధాన () {
//కొత్త SQLite డేటాబేస్ సృష్టించండి
db , తప్పు := sql . తెరవండి ( 'sqlite3' , 'test.db' )
//ఏదైనా లోపం కోసం తనిఖీ చేయండి
ఉంటే తప్పు != శూన్యం {
//దోష సందేశాన్ని లాగ్‌కు జోడించండి
లాగ్ . ప్రాణాంతకం ( తప్పు )
} లేకపోతే {
//విజయ సందేశాన్ని ముద్రించండి
fmt . Println ( 'డేటాబేస్ విజయవంతంగా కనెక్ట్ చేయబడింది.' )
}
//డేటాబేస్ కనెక్షన్‌ను మూసివేయండి
db . దగ్గరగా ()
}
“db_connect2.go” ఫైల్‌ను అమలు చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి:
$ db_connect2.goని అమలు చేయండికింది అవుట్‌పుట్ “test.db” డేటాబేస్ ఫైల్ తెరవబడి విజయవంతంగా కనెక్ట్ చేయబడిందని చూపిస్తుంది. విజయవంతమైన సందేశం, “డేటాబేస్ విజయవంతంగా కనెక్ట్ చేయబడింది”, అవుట్‌పుట్‌లో ముద్రించబడింది:
గోలాంగ్‌ని ఉపయోగించి SQLite డేటాబేస్‌లో పట్టికను సృష్టించండి
'test.db' డేటాబేస్ ఫైల్ లోపల 'సభ్యులు' అనే డేటాబేస్ పట్టికను సృష్టించే క్రింది స్క్రిప్ట్‌తో గోలాంగ్ ఫైల్‌ను సృష్టించండి. ఆరు ఫీల్డ్‌లు మరియు ప్రాథమిక కీతో “సభ్యుల” పట్టికను సృష్టించే క్రియేట్ టేబుల్ ప్రశ్నను అమలు చేయడానికి Exec() పద్ధతి ఇక్కడ ఉపయోగించబడుతుంది. డేటాబేస్‌లో పట్టిక విజయవంతంగా సృష్టించబడితే, విజయ సందేశం ముద్రించబడుతుంది. లేకపోతే, ప్రోగ్రామ్ నిలిపివేయబడుతుంది.
ప్యాకేజీ ప్రధాన//అవసరమైన మాడ్యూల్‌లను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'లాగ్'
'డేటాబేస్/sql'
_ 'github.com/mattn/go-sqlite3'
)
ఫంక్ ప్రధాన () {
//కొత్త sqlite డేటాబేస్ సృష్టించండి
db , తప్పు := sql . తెరవండి ( 'sqlite3' , 'test.db' )
//ఏదైనా లోపం కోసం తనిఖీ చేయండి
ఉంటే తప్పు != శూన్యం {
//దోష సందేశాన్ని లాగ్‌కు జోడించండి
లాగ్ . ప్రాణాంతకం ( తప్పు )
} లేకపోతే {
స్థిరంగా ప్రశ్న స్ట్రింగ్ = `
సభ్యులు లేకుంటే పట్టికను సృష్టించండి (
id పూర్ణాంకం శూన్య ప్రాథమిక కీ కాదు,
పేరు చార్(40) శూన్యం కాదు,
mtype CHAR(100) NULL కాదు,
ఇమెయిల్ CHAR(50),
చిరునామా టెక్స్ట్ శూన్యం కాదు,
మొబైల్ CHAR(25) NULL కాదు);`
_ , తప్పు := db . Exec ( ప్రశ్న );
ఉంటే తప్పు != శూన్యం {
//దోష సందేశాన్ని లాగ్‌కు జోడించండి
లాగ్ . ప్రాణాంతకం ( తప్పు )
} లేకపోతే {
//విజయ సందేశాన్ని ముద్రించండి
fmt . Println ( 'టేబుల్ విజయవంతంగా సృష్టించబడింది.' )
}
}
//డేటాబేస్ కనెక్షన్‌ని మూసివేయండి
db . దగ్గరగా ()
}
“create_table.go” ఫైల్‌ను అమలు చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి:
$ go run create_table.goకింది అవుట్‌పుట్ డేటాబేస్‌లో పట్టిక విజయవంతంగా సృష్టించబడిందని చూపిస్తుంది. 'టేబుల్ విజయవంతంగా సృష్టించబడింది' అనే విజయ సందేశం టెర్మినల్‌లో ముద్రించబడింది:
డేటాబేస్‌లో పట్టిక సృష్టించబడిందో లేదో తనిఖీ చేయడానికి మీరు SQLiteకి లాగిన్ చేయవచ్చు.
“test.db” డేటాబేస్‌తో SQLiteని అమలు చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి:
$ sqlite3 test.dbడేటాబేస్ యొక్క పట్టిక పేర్లను తనిఖీ చేయడానికి SQLite కమాండ్ ప్రాంప్ట్ నుండి “.tables” SQLite ఆదేశాన్ని అమలు చేయండి:
sqlite3 > .tablesడేటాబేస్ గోలాంగ్ స్క్రిప్ట్‌ను అమలు చేయడం ద్వారా సృష్టించబడిన “సభ్యుల” పట్టికను కలిగి ఉందని క్రింది అవుట్‌పుట్ చూపిస్తుంది:
గోలాంగ్‌ని ఉపయోగించి SQLite టేబుల్‌లో రికార్డ్‌లను చొప్పించండి
INSERT ప్రశ్నను అనేక సార్లు అమలు చేయడం ద్వారా లేదా ఒకే ఇన్సర్ట్ ప్రశ్నలో బహుళ విలువలను జోడించడం ద్వారా బహుళ రికార్డులను పట్టికలోకి చొప్పించవచ్చు. ఒకే ఇన్సర్ట్ ప్రశ్నను ఉపయోగించి 'test.db' డేటాబేస్ ఫైల్ యొక్క 'సభ్యుల' పట్టికలో మూడు రికార్డ్‌లను చొప్పించే క్రింది స్క్రిప్ట్‌తో గోలాంగ్ ఫైల్‌ను సృష్టించండి. INSERT ప్రశ్నను అమలు చేయడానికి Exec() పద్ధతి ఇక్కడ ఉపయోగించబడుతుంది. పట్టికలో రికార్డులు విజయవంతంగా చొప్పించబడితే, విజయ సందేశం ముద్రించబడుతుంది. లేకపోతే, ప్రోగ్రామ్ నిలిపివేయబడుతుంది.
ప్యాకేజీ ప్రధాన//అవసరమైన మాడ్యూల్‌లను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'లాగ్'
'డేటాబేస్/sql'
_ 'github.com/mattn/go-sqlite3'
)
ఫంక్ ప్రధాన () {
//కొత్త SQLite డేటాబేస్ సృష్టించండి
db , తప్పు := sql . తెరవండి ( 'sqlite3' , 'test.db' )
//ఏదైనా లోపం కోసం తనిఖీ చేయండి
ఉంటే తప్పు != శూన్యం {
//దోష సందేశాన్ని లాగ్‌కు జోడించండి
లాగ్ . ప్రాణాంతకం ( తప్పు )
} లేకపోతే {
స్థిరంగా ప్రశ్న స్ట్రింగ్ = `
సభ్యులలోకి చొప్పించండి (ID, పేరు, mtype, ఇమెయిల్, చిరునామా, మొబైల్)
విలువలు(1, 'నెహాల్ అహ్మద్', 'సిల్వర్', 'nehal@gmail.com','36, ధన్మొండి 2, ఢాకా','01844657342'),
(2, 'అబిర్ చౌదరి', 'గోల్డ్', 'abir@gmail.com','102, మీర్పూర్ 10, ఢాకా','01994563423'),
(3, 'మీర్జా అబ్బాస్', 'సిల్వర్', 'abbas@gmail.com','12, జిగతలా, ఢాకా','01640006710');`
//ప్రశ్నను అమలు చేయండి
_ , తప్పు := db . Exec ( ప్రశ్న );
ఉంటే తప్పు != శూన్యం {
//దోష సందేశాన్ని లాగ్‌కు జోడించండి
లాగ్ . ప్రాణాంతకం ( తప్పు )
} లేకపోతే {
//విజయ సందేశాన్ని ముద్రించండి
fmt . Println ( 'రికార్డులు విజయవంతంగా చొప్పించబడ్డాయి.' )
}
}
//డేటాబేస్ కనెక్షన్‌ను మూసివేయండి
db . దగ్గరగా ()
}
“insert_table.go” ఫైల్‌ను అమలు చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి:
$ వెళ్ళు insert_table.go రన్ చేయండిపట్టికలో రికార్డులు విజయవంతంగా చొప్పించబడినట్లు క్రింది అవుట్‌పుట్ చూపిస్తుంది. విజయ సందేశం, “రికార్డులు విజయవంతంగా చొప్పించబడ్డాయి”, అవుట్‌పుట్‌లో ముద్రించబడింది:
'సభ్యులు' పట్టికలో మూడు రికార్డులు విజయవంతంగా చొప్పించబడ్డాయో లేదో తనిఖీ చేయడానికి మీరు SQLiteకి లాగిన్ చేయవచ్చు.
“test.db” డేటాబేస్‌తో SQLiteని అమలు చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి:
$ sqlite3 test.db'సభ్యులు' పట్టికలోని మొత్తం కంటెంట్‌ను చదవడానికి క్రింది SELECT ప్రశ్నను అమలు చేయండి:
sqlite3 > SELECT * సభ్యుల నుండి ;కింది అవుట్‌పుట్ 'సభ్యుల' పట్టికలో గోలాంగ్ స్క్రిప్ట్ ద్వారా చొప్పించబడిన మూడు రికార్డ్‌లు ఉన్నాయని చూపిస్తుంది:
గోలాంగ్ ఉపయోగించి SQLite టేబుల్ యొక్క డేటాను చదవండి
'సభ్యుల' పట్టిక యొక్క రికార్డులను చదివే క్రింది స్క్రిప్ట్‌తో గోలాంగ్ ఫైల్‌ను సృష్టించండి. SELECT ప్రశ్న నుండి అందించబడిన విలువలను నిల్వ చేయడానికి మీరు గోలాంగ్‌లో వేరియబుల్‌లను నిర్వచించాలి. ఈ స్క్రిప్ట్‌లో, SELECT ప్రశ్నను ఉపయోగించి 'సభ్యులు' పట్టిక నుండి ఐదు ఫీల్డ్‌లు తిరిగి పొందబడతాయి. కాబట్టి, 'mtype' ఫీల్డ్ యొక్క విలువ 'సిల్వర్' అయిన 'సభ్యుల' పట్టికలోని ఐదు ఫీల్డ్‌ల విలువలను నిల్వ చేయడానికి స్క్రిప్ట్‌లో ఐదు వేరియబుల్స్ నిర్వచించబడ్డాయి. SELECT ప్రశ్నను అమలు చేయడానికి ఇక్కడ ప్రశ్న() పద్ధతి ఉపయోగించబడుతుంది. తర్వాత, SELECT ప్రశ్న ద్వారా తిరిగి వచ్చే ఫలితాల సెట్‌ను చదవడానికి “ఫర్” లూప్ ఉపయోగించబడుతుంది. ప్రింట్ఎఫ్() ఫంక్షన్ ఫలిత సెట్ యొక్క ఫార్మాట్ చేయబడిన విలువలను ముద్రించడానికి ఉపయోగించబడుతుంది.
ప్యాకేజీ ప్రధాన//అవసరమైన మాడ్యూల్‌లను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'లాగ్'
'డేటాబేస్/sql'
_ 'github.com/mattn/go-sqlite3'
)
ఫంక్ ప్రధాన () {
//కొత్త SQLite డేటాబేస్ సృష్టించండి
db , తప్పు := sql . తెరవండి ( 'sqlite3' , 'test.db' )
//ఏదైనా లోపం కోసం తనిఖీ చేయండి
ఉంటే తప్పు != శూన్యం {
//దోష సందేశాన్ని లాగ్‌కు జోడించండి
లాగ్ . ప్రాణాంతకం ( తప్పు )
} లేకపోతే {
//వరుస విలువలను నిల్వ చేయడానికి వేరియబుల్‌లను ప్రకటించండి
ఉంది id int
ఉంది పేరు స్ట్రింగ్
ఉంది mtype స్ట్రింగ్
ఉంది చిరునామా స్ట్రింగ్
ఉంది మొబైల్ స్ట్రింగ్
స్థిరంగా ప్రశ్న స్ట్రింగ్ = ID, పేరు, mtype, చిరునామా, మొబైల్ ఎంచుకోండి
సభ్యుల నుండి
ఎక్కడ mtype = 'వెండి';`
//ప్రశ్నను అమలు చేయండి
వరుసలు , తప్పు := db . ప్రశ్న ( ప్రశ్న );
ఉంటే తప్పు != శూన్యం {
//దోష సందేశాన్ని లాగ్‌కు జోడించండి
లాగ్ . ప్రాణాంతకం ( తప్పు )
} లేకపోతే {
//విజయ సందేశాన్ని ముద్రించండి
fmt . Println ( 'వెండి సభ్యులందరి రికార్డులు:' )
fmt . Println ( 'ID \t పేరు \t \t సభ్యుల రకం \t చిరునామా \t \t సంప్రదంచాల్సిన నెం' )
కోసం వరుసలు . తరువాత () {
వరుసలు . స్కాన్ చేయండి ( &id , &పేరు , &mtype , &చిరునామా , &మొబైల్ )
fmt . ప్రింట్ఎఫ్ ( '%d \t %s \t %s \t %s \t %s \n ' , id , పేరు , mtype , చిరునామా , మొబైల్ )
}
}
}
//డేటాబేస్ కనెక్షన్‌ను మూసివేయండి
db . దగ్గరగా ()
}
“select_table.go” ఫైల్‌ను అమలు చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి:
$ go run select_table.go'mtype' ఫీల్డ్‌లో 'సిల్వర్' ఉన్న 'సభ్యుల' పట్టికలో రెండు రికార్డులు ఉన్నాయి. కింది అవుట్‌పుట్ SELECT ప్రశ్న ద్వారా అందించబడిన “సభ్యుల” పట్టిక యొక్క రెండు రికార్డ్‌లను చూపుతుంది:
గోలాంగ్‌ని ఉపయోగించి SQLite టేబుల్ డేటాను అప్‌డేట్ చేయండి
2 యొక్క id విలువను కలిగి ఉన్న 'సభ్యులు' పట్టిక యొక్క మొబైల్ ఫీల్డ్ విలువను మార్చే క్రింది స్క్రిప్ట్‌తో గోలాంగ్ ఫైల్‌ను సృష్టించండి. UPDATE ప్రశ్నను అమలు చేయడానికి Exec() పద్ధతి ఇక్కడ ఉపయోగించబడుతుంది. పట్టికలో రికార్డు విజయవంతంగా నవీకరించబడినట్లయితే, విజయ సందేశం ముద్రించబడుతుంది. లేకపోతే, ప్రోగ్రామ్ నిలిపివేయబడుతుంది.
ప్యాకేజీ ప్రధాన//అవసరమైన మాడ్యూల్‌లను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'లాగ్'
'డేటాబేస్/sql'
_ 'github.com/mattn/go-sqlite3'
)
ఫంక్ ప్రధాన () {
//కొత్త SQLite డేటాబేస్ సృష్టించండి
db , తప్పు := sql . తెరవండి ( 'sqlite3' , 'test.db' )
//ఏదైనా లోపం కోసం తనిఖీ చేయండి
ఉంటే తప్పు != శూన్యం {
//దోష సందేశాన్ని లాగ్‌కు జోడించండి
లాగ్ . ప్రాణాంతకం ( తప్పు )
} లేకపోతే {
స్థిరంగా ప్రశ్న స్ట్రింగ్ = `
సభ్యులను అప్‌డేట్ చేయండి మొబైల్ = '018563452390' ఎక్కడ id = 2;`
_ , తప్పు := db . Exec ( ప్రశ్న );
ఉంటే తప్పు != శూన్యం {
//దోష సందేశాన్ని లాగ్‌కు జోడించండి
లాగ్ . ప్రాణాంతకం ( తప్పు )
} లేకపోతే {
//విజయ సందేశాన్ని ముద్రించండి
fmt . Println ( 'రికార్డ్ విజయవంతంగా నవీకరించబడింది.' )
}
}
//డేటాబేస్ కనెక్షన్‌ను మూసివేయండి
db . దగ్గరగా ()
}
“update_table.go” ఫైల్‌ను అమలు చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి:
$ go run update_table.go'సభ్యులు' పట్టికలో, రెండవ అడ్డు వరుసలో id విలువ 2 ఉంటుంది. పట్టిక యొక్క రికార్డ్ విజయవంతంగా నవీకరించబడినట్లు క్రింది అవుట్‌పుట్ చూపుతుంది. 'రికార్డ్ విజయవంతంగా నవీకరించబడింది' అనే విజయ సందేశం టెర్మినల్‌లో ముద్రించబడింది:
సభ్యుల పట్టిక యొక్క ఏదైనా రికార్డు నవీకరించబడిందో లేదో తనిఖీ చేయడానికి మీరు SQLiteకి లాగిన్ చేయవచ్చు.
“test.db” డేటాబేస్‌తో SQLiteని అమలు చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి:
$ sqlite3 test.db'సభ్యులు' పట్టికలోని మొత్తం కంటెంట్‌ను చదవడానికి క్రింది SELECT ప్రశ్నను అమలు చేయండి:
sqlite3 > SELECT * సభ్యుల నుండి ;2 యొక్క మొబైల్ ఫీల్డ్ విలువ nd స్క్రిప్ట్‌ని అమలు చేయడానికి ముందు సభ్యుల పట్టిక రికార్డు “01994563423”. కింది అవుట్‌పుట్ 2 యొక్క మొబైల్ ఫీల్డ్ యొక్క విలువను చూపుతుంది nd స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత సభ్యుల పట్టిక రికార్డు “018563452390”కి మార్చబడింది:
గోలాంగ్ ఉపయోగించి SQLite టేబుల్ యొక్క డేటాను తొలగించండి
3ని తొలగించే క్రింది స్క్రిప్ట్‌తో గోలాంగ్ ఫైల్‌ను సృష్టించండి RD 3 యొక్క id విలువను కలిగి ఉన్న “సభ్యుల” పట్టిక యొక్క రికార్డ్. DELETE ప్రశ్నను అమలు చేయడానికి Exec() పద్ధతి ఇక్కడ ఉపయోగించబడుతుంది. పట్టిక నుండి రికార్డు విజయవంతంగా తొలగించబడితే, విజయ సందేశం ముద్రించబడుతుంది. లేకపోతే, ప్రోగ్రామ్ నిలిపివేయబడుతుంది.
ప్యాకేజీ ప్రధాన//అవసరమైన మాడ్యూల్‌లను దిగుమతి చేయండి
దిగుమతి (
'fmt'
'లాగ్'
'డేటాబేస్/sql'
_ 'github.com/mattn/go-sqlite3'
)
ఫంక్ ప్రధాన () {
//కొత్త SQLite డేటాబేస్ సృష్టించండి
db , తప్పు := sql . తెరవండి ( 'sqlite3' , 'test.db' )
//ఏదైనా లోపం కోసం తనిఖీ చేయండి
ఉంటే తప్పు != శూన్యం {
//దోష సందేశాన్ని లాగ్‌కు జోడించండి
లాగ్ . ప్రాణాంతకం ( తప్పు )
} లేకపోతే {
//తొలగింపు ప్రశ్నను నిర్వచించండి
స్థిరంగా ప్రశ్న స్ట్రింగ్ = `ఇక్కడ ఐడి = 3;` సభ్యుల నుండి తొలగించండి
//ప్రశ్నను అమలు చేయండి
_ , తప్పు := db . Exec ( ప్రశ్న );
ఉంటే తప్పు != శూన్యం {
//దోష సందేశాన్ని లాగ్‌కు జోడించండి
లాగ్ . ప్రాణాంతకం ( తప్పు )
} లేకపోతే {
//విజయ సందేశాన్ని ముద్రించండి
fmt . Println ( 'రికార్డ్ విజయవంతంగా తొలగించబడింది.' )
}
}
//డేటాబేస్ కనెక్షన్‌ను మూసివేయండి
db . దగ్గరగా ()
}
“delete_table.go” ఫైల్‌ను అమలు చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి:
$ delete_table.goని అమలు చేయండికింది అవుట్‌పుట్ 3 అని చూపిస్తుంది RD 'సభ్యుల' పట్టిక రికార్డు విజయవంతంగా తొలగించబడింది. 'రికార్డ్ విజయవంతంగా తొలగించబడింది' అనే విజయ సందేశం టెర్మినల్‌లో ముద్రించబడింది:
సభ్యుల పట్టిక యొక్క ఏదైనా రికార్డ్ తొలగించబడిందో లేదో తనిఖీ చేయడానికి మీరు SQLiteకి లాగిన్ చేయవచ్చు.
“test.db” డేటాబేస్‌తో SQLiteని అమలు చేయడానికి కింది ఆదేశాన్ని అమలు చేయండి:
$ sqlite3 test.db'సభ్యులు' పట్టికలోని మొత్తం కంటెంట్‌ను చదవడానికి క్రింది SELECT ప్రశ్నను అమలు చేయండి:
sqlite3 > SELECT * సభ్యుల నుండి ;కింది అవుట్‌పుట్ 3 యొక్క విలువను చూపుతుంది RD స్క్రిప్ట్‌ని అమలు చేసిన తర్వాత సభ్యుల పట్టిక యొక్క రికార్డ్ తొలగించబడుతుంది మరియు మిగిలిన రెండు రికార్డులు అవుట్‌పుట్‌లో ముద్రించబడతాయి:
ముగింపు
SQLite మరియు Golang రెండూ వాటి సరళత మరియు తేలికైన లక్షణాల కోసం ఇప్పుడు ప్రసిద్ధి చెందాయి. ఏదైనా సాధారణ డేటాబేస్ ఆధారిత అప్లికేషన్‌ను ఈ సాధనాలను ఉపయోగించి సులభంగా అమలు చేయవచ్చు. ఏదైనా అప్లికేషన్ యొక్క ప్రధాన భాగం CRUD ఆపరేషన్‌ను అమలు చేయడం. గోలాంగ్ స్క్రిప్ట్ మరియు SQLite డేటాబేస్ ఉపయోగించి CRUD ఆపరేషన్‌ను అమలు చేసే పద్ధతులు బహుళ గోలాంగ్ ఫైల్‌లను ఉపయోగించి ఈ ట్యుటోరియల్‌లో వివరించబడ్డాయి. మీరు గో లాంగ్వేజ్ మరియు SQLite డేటాబేస్‌ని కొత్తగా నేర్చుకునేవారైతే, ఈ ట్యుటోరియల్ వీటిని ప్రాథమికంగా నేర్చుకోవడంలో మీకు సహాయం చేస్తుంది.