Theory
રિસેપ્શનિસ્ટ પાસે તમારો જવાબ છે. હવે એ લો.
ગયો પાઠ રહસ્ય પર પૂરો થયો: cur.execute("SELECT roll, score FROM marks") બરાબર ચાલ્યું, પણ ક્યાંય કોઈ હરોળ દેખાઈ નહીં.
એ રચનાથી જ છે. execute() ફક્ત cursor પર પરિણામ તૈયાર કરે છે; તમે fetch ન કરો ત્યાં સુધી કશું Python માં આવતું નથી.
એકઠું કરવાની બે શૈલી છે, અને એમની વચ્ચે પસંદગી કરવી એ જ પાઠ છે: હરોળ એક એક કરીને લેવી (fetchone) કે બધું એકસાથે લેવું (fetchall).
Theory
ટોકનની બારી
પરિણામો બારીએ રાહ જુએ છે, ક્રમમાં, છાપેલા ટોકનની જેમ.
fetchone() આગલું એક ટોકન લે છે: ફરી બોલાવો, પછીનું મળે છે: દરેક call સાથે ઢગલો ઘટે છે. ઢગલો ખાલી થાય ત્યારે, કારકુન તમને None આપે છે: કશું બાકી નથી.
fetchall() એક જ ઝાટકે બાકીનો આખો ઢગલો પેટીમાં (Python ની list માં) ભરી લે છે. તરત ફરી ઝાટકો મારો? પેટી ખાલી પાછી આવે છે: ઢગલો પહેલેથી લેવાઈ ગયો હતો.
Theory
બે calls, ઔપચારિક રીતે
cur.execute("SELECT ...") પછી:
- cur.fetchone() આગલી હરોળ tuple તરીકે આપે છે, કે પરિણામ ખૂટે ત્યારે None. દરેક call cursor ને આગળ ખસેડે છે.
- cur.fetchall() બાકીની બધી હરોળ tuples ની list તરીકે આપે છે (કશું બાકી ન હોય તો ખાલી list
[]). - cur.fetchmany(n) વધુમાં વધુ n હરોળ list તરીકે આપે છે: મોટાં પરિણામ માટે વચલો રસ્તો.
ખાનાં સ્થાન પ્રમાણે આવે છે: row[0] તમારા SELECT નું પહેલું ખાનું છે, row[1] બીજું.
Practical
marks ના કોષ્ટક પર બંને શૈલી
import sqlite3
conn = sqlite3.connect('college.db')
cur = conn.cursor()
cur.execute("SELECT roll, score FROM marks WHERE subject = 'DBMS'")
# Style 1: one at a time
row = cur.fetchone()
print(row) # (101, 78) a TUPLE, even for one row
print(row[1]) # 78 columns by index
# Style 2: everything remaining
rest = cur.fetchall()
print(rest) # [(102, 55), (103, 91)] list of tuples
print(len(rest)) # 2
# the pile is now empty:
print(cur.fetchone()) # None
print(cur.fetchall()) # []
# Style 3: the cursor is iterable (fresh execute first!)
cur.execute("SELECT roll, score FROM marks WHERE subject = 'DBMS'")
for roll, score in cur: # tuple unpacking per row
print(roll, score)
conn.close()
Think first
ચારેય prints ધારો
DBMS ના પરિણામમાં બરાબર 3 હરોળ છે. execute પછી, code ચાલે છે:
print(cur.fetchone())
print(len(cur.fetchall()))
print(cur.fetchall())
print(cur.fetchone())
Tap કરતાં પહેલાં ચારેય outputs કાઢો.
Show the answer
1. (101, 78): પહેલી હરોળ, tuple તરીકે.
2. 2: fetchall બાકીની હરોળ લે છે (હરોળ 1 પહેલેથી વપરાઈ ગઈ).
3. []: ઢગલો ખાલી છે; બીજા fetchall ને કશું મળતું નથી.
4. None: ખૂટવા પર fetchone.
ચારેય પાછળનું engine: fetch નાં calls એક-માર્ગી પ્રવાહને વાપરી નાખે છે. તમે fetch કરેલું કશું નવા execute() વગર ક્યારેય પાછું દેખાતું નથી.
Quiz
એક program ને એક જ ટોચના scorer જોઈએ છે: cur.execute('SELECT name FROM ... ORDER BY score DESC LIMIT 1') પછી row = cur.fetchone(); print(row[0]). એક દિવસ એ ભાંગી પડે છે: TypeError: 'NoneType' object is not subscriptable. શું થયું?
- Query ને કોઈ હરોળ મળી નહીં, fetchone એ None આપ્યું, અને None[0] ગેરકાયદે છે: index કરતાં પહેલાં None માટે તપાસો
- fetchone એક string આપે છે, અને strings ને index કરી શકાતું નથી
- LIMIT 1 એ fetchone સાથે અસંગત છે
- Database ની file બીજા program એ lock કરી હતી
Show the answer
Query ને કોઈ હરોળ મળી નહીં, fetchone એ None આપ્યું, અને None[0] ગેરકાયદે છે: index કરતાં પહેલાં None માટે તપાસો
ખાલી પરિણામ પર (ધારો કે એ દિવસે marks ના કોષ્ટકમાં કોઈ હરોળ નહોતી), fetchone() None આપે છે, અને None ને index કરવાથી બરાબર આ રીતે ફૂટે છે. વ્યાવસાયિક ભાત: row = cur.fetchone() પછી if row is not None: print(row[0]). વિકલ્પ B ઊલટો છે (હરોળ tuples છે, જે બરાબર index થાય છે); LIMIT અને fetchone ખરેખર સંપૂર્ણ જોડી બનાવે છે; અને lock થયેલી file જુદી, સ્પષ્ટ નામવાળી ભૂલ આપે છે.
Watch out
Fetch ના ત્રણ ફાંદા
બેવડું fetchall: બીજું call [] આપે છે અને શરૂઆત કરનારા એક કલાક 'ખોવાયેલા data' નો bug શોધે છે. એક વાર fetch કરો, list ને variable માં રાખો.
None ને index કરવું: query ખાલી હોઈ શકે ત્યાં હંમેશા શક્ય: પહેલાં if row: તપાસો.
અલ્પવિરામની વાસ્તવિકતા ભૂલવી: એક ખાનાવાળી હરોળ એ tuple ('Riya',) છે, ખુલ્લી string નહીં: row[0] થી કાઢો. પરીક્ષાઓ print(row) નું output દેખાડીને પૂછે છે કે કૌંસ અને અલ્પવિરામ કેમ દેખાય છે.
Theory
બંને વચ્ચે પસંદગી
fetchall() આરામદાયક છે અને વર્ગખંડના કદના data માટે યોગ્ય: એક list, મુક્તપણે loop કરો. fetchone() (કે cursor પર iterate કરવું) ત્યારે ચમકે છે જ્યારે પરિણામ વિશાળ હોય: એક વખતે memory માં એક હરોળ, એ જ કારણે એકમ 2 નાં backups બધું લોડ કરવાને બદલે વહે છે. ResultDesk ના અહેવાલના પડદા fetchall કરશે; એનું CSV ફરી આયાત તપાસનાર iterate કરશે. આગલો પાઠ એકમ પૂરો કરે છે: ફેરફાર પાછા લખવા, અને commit() નું વચન આખરે પળાય છે.
Summary
Key takeaways
- execute() પરિણામ તૈયાર કરે છે; તમે fetch ન કરો ત્યાં સુધી કશું Python સુધી પહોંચતું નથી.
- fetchone() → આગલી હરોળ tuple તરીકે, કે ખૂટે ત્યારે None; દરેક call cursor ને આગળ ખસેડે છે.
- fetchall() → બાકીની બધી હરોળ tuples ની list તરીકે; કશું બાકી ન હોય તો [].
- Fetch કરેલી હરોળ વપરાઈ જાય છે: બીજું fetchall [] આપે છે, ક્યારેય પુનરાવર્તન નહીં.
- fetchone નાં પરિણામ સંભાળો: જો row એ None હોય, તો index ન કરો.
- ખાનાં સ્થાન પ્રમાણે આવે છે: row[0], row[1], SELECT ના ક્રમમાં; એક ખાનાવાળી હરોળ પણ tuples છે.
- Memory hook: બારીએ ટોકન, એક લેવાય કે બધાં ઝાટકે.