Theory
પરીક્ષા વિભાગને કાગળ પર પુરાવો જોઈએ છે
પરીક્ષા વિભાગ હવે ResultDesk પર ભરોસો કરે છે, એક શરતે: "તમે marks ના કોષ્ટકને અડો એ પહેલાં, અમને એવી નકલ આપો જે અમે વાંચી શકીએ અને પાછી લાવી શકીએ."
college.db ની નકલ એમના માટે binary નો સૂપ છે. એમને જોઈએ છે કોષ્ટક વાંચી શકાય એવા SQL તરીકે: બરાબર એ CREATE TABLE અને INSERT નાં વિધાનો જે એને શૂન્યમાંથી ફરી બાંધે.
sqlite3 નું command નું shell આ એક dot-command થી કરે છે: .dump. એ શીખો અને કોઈ પણ કોષ્ટક એવી લખાણની file બની જાય જે તમે વાંચી, mail કરી, કે ફરી ચલાવી શકો.
Theory
વાનગી, રાંધેલી થાળી નહીં
college.db ની નકલ કરવી એટલે રાંધેલી થાળીનો ફોટો પાડવા જેવું છે: બરાબર, પણ એમાં શું ગયું એ તમે જોઈ શકતા નથી.
.dump વાનગી લખી નાખે છે: દરેક પગલું (CREATE TABLE) અને દરેક સામગ્રી (દરેક INSERT), સાદા લખાણમાં. વાનગી ધરાવનાર કોઈ પણ પછીથી એ જ થાળી રાંધી શકે છે, કોઈ પણ ચૂલા પર (કોઈ પણ SQLite ની આવૃત્તિ), અને રાંધતાં પહેલાં એક લીટી વાંચી કે સુધારી પણ શકે છે. જે backup તમે વાંચી શકો એ backup પર તમે ભરોસો કરી શકો.
Theory
Dot-commands: shell ની પોતાની ભાષા
sqlite3 ના shell માં (terminal માંથી sqlite3 college.db), બે ભાષા સાથે રહે છે:
- SQL અર્ધવિરામથી પૂરું થાય છે અને database સાથે વાત કરે છે:
SELECT * FROM marks; - Dot-commands ટપકાંથી શરૂ થાય છે, અર્ધવિરામ લેતાં નથી, અને shell ને પોતાને આદેશ આપે છે:
.dump,.schema,.output,.read.
Dot-commands એ SQL નથી: એ Python માં કે કોઈ program માં ચાલશે નહીં, ફક્ત shell માં. પરીક્ષાઓ બરાબર આ ભેદ તપાસે છે.
Follow along
એક કોષ્ટકને file માં dump કરો
- Database પર shell ખોલો Terminal: sqlite3 college.db (prompt બદલાઈને sqlite> થાય છે)
- Output ને file તરફ તાકો: .output marks_backup.sql હવેથી, shell જે કંઈ છાપે એ પડદાને બદલે marks_backup.sql માં જાય છે.
- કોષ્ટક dump કરો: .dump marks CREATE TABLE marks નું વિધાન લખે છે અને પછી દરેક હરોળ દીઠ એક INSERT.
- Output પાછું પડદા તરફ તાકો: .output stdout આ ભૂલો અને પછીનું દરેક query નું પરિણામ ચૂપચાપ file માં અદૃશ્ય થાય છે.
- ચકાસો: marks_backup.sql ને કોઈ પણ text editor માં ખોલો તમારે વાંચવું જોઈએ CREATE TABLE marks(...); INSERT INTO marks VALUES(101,'DBMS',78); વગેરે.
Theory
ફક્ત માળખું: .schema
ક્યારેક તમને data વગરનું હાડપિંજર જોઈએ: સાથી સાથે રચના વહેંચવી, કે નવા યંત્ર પર ખાલી કોષ્ટકો ફરી બનાવવાં.
.schema marksફક્તCREATE TABLE marks (...)નું વિધાન છાપે છે.- એકલું
.schemaદરેક કોષ્ટક, index અને trigger નું માળખું છાપે છે.
અંગૂઠાનો નિયમ: .dump = માળખું વત્તા data, .schema = ફક્ત માળખું. બંને લખાણ છે; બંને પછીથી .read થી ફરી ચલાવી શકાય છે.
Quiz
.dump marks એ બનાવેલી file માં બરાબર શું હોય છે?
- SQL નું લખાણ: CREATE TABLE નું વિધાન વત્તા દરેક હરોળ દીઠ એક INSERT નું વિધાન
- marks ના કોષ્ટકની સંકોચેલી binary નકલ
- Header ની હરોળવાળી CSV ની file
- ફક્ત data નાં મૂલ્યો, કોઈ માળખા વગર
Show the answer
SQL નું લખાણ: CREATE TABLE નું વિધાન વત્તા દરેક હરોળ દીઠ એક INSERT નું વિધાન
Dump એ તાર્કિક backup છે: ચલાવી શકાય એવું SQL જે કોષ્ટકને શૂન્યથી ફરી બાંધે છે: પહેલાં CREATE TABLE, પછી દરેક હરોળ INSERT તરીકે. એ binary નથી (એ તો .db ની file નકલ કરવી હોત) અને CSV નથી (એ .mode csv નો workflow છે, બે પાઠ આગળ). કારણ કે માળખું data સાથે પ્રવાસ કરે છે, file ને ખાલી database પર ફરી ચલાવવાથી કામ થઈ જાય છે.
Think first
અટકેલું shell પકડો
એક student .output backup.sql પછી .dump marks ચલાવે છે, પછી SELECT FROM students; ટાઈપ કરે છે અને પડદા પર કશું* દેખાતું નથી. Database બરાબર છે. Tap કરતાં પહેલાં: શું થયું, અને કઈ એક command એ સુધારે છે?
Show the answer
Shell હજી બધું backup.sql માં વાળી રહ્યું છે: SELECT ચાલ્યું, પણ એની હરોળ dump પછી ઉમેરાઈને file માં ગઈ. ઉકેલ છે .output stdout, જે છાપવાનું પાછું પડદા તરફ તાકે છે. આ જાણીતો .output નો ફાંદો છે: તમે બંધ ન કરો ત્યાં સુધી વાળવાનું ચાલુ રહે છે, અને shell કોઈ યાદ કરાવતું નથી.
Watch out
Marks ક્યાં ગળે છે
Dot-commands પર અર્ધવિરામ: .dump; shell ને ગૂંચવે છે. Dot-commands અર્ધવિરામ લેતાં નથી; SQL લે છે.
Shell ની બહાર dot-commands ચલાવવાં: એ shell નાં લક્ષણ છે, SQL નહીં: Python માં cursor.execute('.dump') નિષ્ફળ જાય છે.
Dump પુછાય ત્યારે "file નકલ કરો" જવાબ આપવો: file ની નકલ માન્ય binary backup છે, પણ પ્રશ્ન SQL-લખાણની પદ્ધતિ માંગે છે; .dump નું નામ આપો અને એનું output શું ધરાવે છે એ કહો.
Theory
વ્યાવસાયિકોને લખાણનાં dumps કેમ ગમે છે
લખાણનાં dumps git માં સ્વચ્છ diff આપે છે (ગઈકાલનું dump સામે આજનું બરાબર દેખાડે છે કઈ હરોળ બદલાઈ), SQLite ની આવૃત્તિના upgrade માં ટકે છે, અને restore પહેલાં સુધારી શકાય છે (લખાણની file માં ખરાબ હરોળ ઠીક કરો). આગલો પાઠ આને એક કોષ્ટકથી આખા database સુધી લઈ જાય છે, અને એ restore નું command ઉમેરે છે જે તમારી વાનગીને પાછી થાળી બનાવે છે.
Summary
Key takeaways
- Dot-commands (.dump, .schema, .output) એ sqlite3 ના shell નાં commands છે: પહેલાં ટપકું, અર્ધવિરામ નહીં, SQL નહીં.
- .dump marks એ SQL લખે છે જે કોષ્ટક ફરી બાંધે: CREATE TABLE વત્તા દરેક હરોળ દીઠ એક INSERT.
- .schema marks ફક્ત માળખું આપે છે; એકલું .schema દરેક પદાર્થને આવરે છે.
- Dump પહેલાં .output file.sql થી વાળો; હંમેશા .output stdout થી પાછા ફરો.
- Dump એ તાર્કિક, વાંચી શકાય એવું, વહન કરી શકાય એવું backup છે; .db ની file નકલ કરવી એ binary તસવીર છે.
- Memory hook: વાનગી, રાંધેલી થાળી નહીં.