Database Access using ADO.NET

📖 Theory

ખરેખરનું વાંચવું અને લખવું

ADO.NET નાં પાત્રો તમે ઓળખો છો; હવે એમને FestConnect નાં રોજિંદાં બે કામે લગાડો: page પર બતાવવા માટે events ની list વાંચવી, અને વિદ્યાર્થી નોંધાય ત્યારે નવું registration લખવું.

વાંચવા માટે Command નું ExecuteReader અને DataReader વપરાય છે; લખવા માટે ExecuteNonQuery વપરાય છે. રસ્તામાં database ના code ની સૌથી અગત્યની એક ટેવ પણ આવે છે: વપરાશકાર પાસેથી આવેલી કોઈ પણ કિંમત માટે parameters વાપરો. આ પાઠ બંને ક્રિયાઓ બતાવે છે અને એ ટેવ કેમ બાંધછોડ વગરની છે તે પણ.

🪜 Follow along

Connected વાચનની ઢબ

1. Connection ખોલો Connection string સાથે SqlConnection બનાવો અને એને ખોલો (સૌથી સારું તો using block ની અંદર, જે એને આપોઆપ બંધ કરે છે).
2. Command બનાવો તમારું SELECT વિધાન ધરાવતું SqlCommand, જે connection સાથે બંધાયેલું હોય.
3. ExecuteReader Rows ને વહેતી આપતું SqlDataReader મેળવવા cmd.ExecuteReader() બોલાવો.
4. Read() સાથે આંટા મારો while (reader.Read()) એક સમયે એક row આગળ વધારે છે; columns ને નામથી વાંચો.
5. બંધ કરો કામ પતે ત્યારે using block connection બંધ કરી દે છે, ભૂલ આવે તો પણ.

⌨️ Practical

FestConnect ના events વાંચવા

using (var conn = new SqlConnection(connectionString))
{
    var cmd = new SqlCommand("SELECT Name, EventDate FROM Events", conn);
    conn.Open();

    SqlDataReader reader = cmd.ExecuteReader();
    while (reader.Read())          // true while there is another row
    {
        string name = reader["Name"].ToString();
        // ... add name to a list, or bind it to a control
    }
}   // connection closed automatically here

📖 Theory

લખવું: ExecuteNonQuery

Database બદલવા માટે, એટલે કે registration insert કરવા, વિગત update કરવા કે row delete કરવા, તમે Command નું ExecuteNonQuery વાપરો છો. નામનો અર્થ છે 'એવો command ચલાવો જે query નથી (SELECT નથી)'. એ વિધાન ચલાવે છે અને કેટલી rows પર અસર થઈ તે સંખ્યા પાછી આપે છે.

એટલે એક registration ઉમેરતું એક INSERT 1 પાછું આપે છે. લખાણ સફળ થયું કે નહીં એની ખાતરી કરવા આ પાછી મળતી કિંમત કામની છે: તમે એક row insert કરવાની ધારણા રાખી હોય અને ExecuteNonQuery 1 પાછું આપે, તો એ સફળ થયું એમ સમજાય.

⌨️ Practical

Registration ને parameters સાથે સાચવવું

using (var conn = new SqlConnection(connectionString))
{
    // @name and @eventId are PLACEHOLDERS, not the actual values
    var cmd = new SqlCommand(
        "INSERT INTO Registrations (StudentName, EventId) VALUES (@name, @eventId)",
        conn);

    // Supply the user's values as parameters (safe)
    cmd.Parameters.AddWithValue("@name", txtName.Text);
    cmd.Parameters.AddWithValue("@eventId", selectedEventId);

    conn.Open();
    int rows = cmd.ExecuteNonQuery();   // returns 1 for one inserted row
    lblStatus.Text = rows == 1 ? "Registered!" : "Something went wrong.";
}

⚠️ Watch out

વપરાશકારે ભરેલું લખાણ SQL માં કદી ચોંટાડશો નહીં

Database ના code ની સૌથી ખતરનાક એક ભૂલ એટલે વપરાશકારે ભરેલા લખાણને જોડીને SQL બનાવવો, જેમ કે "... VALUES ('" + txtName.Text + "')". મુલાકાતી એ ખાનામાં પોતાનું SQL લખી શકે અને તમારી query એ ચલાવી નાખે, અને એ હુમલાને SQL injection કહે છે (DBMS માં અને PHP ના unit માં તમે એને મળી ચૂક્યા છો).

એને બદલે હંમેશા parameters વાપરો (@name, જે cmd.Parameters દ્વારા ઉમેરાય છે). પછી ADO.NET વપરાશકારનું લખાણ કડક રીતે ફક્ત કિંમત તરીકે મોકલે છે, ચાલી શકે એવા SQL તરીકે કદી નહીં, એટલે injection થઈ જ ન શકે. વપરાશકારે આપેલી દરેક કિંમતને, દર વખતે, parameter બનાવો. અને connection હંમેશા બંધ કરો (using block એની ખાતરી આપે છે).

🧩 Quiz

એક નવી registration ની row સાચવવા તમે INSERT ચલાવો છો. તમે કઈ method બોલાવો છો, અને એ શું પાછું આપે છે?

1. ExecuteReader, જે insert થયેલી row ને DataReader તરીકે પાછી આપે છે
2. ExecuteNonQuery, જે INSERT ચલાવે છે અને અસર પામેલી rows ની સંખ્યા પાછી આપે છે (એક insert માટે 1)
3. ExecuteScalar, જે આખું Registrations table પાછું આપે છે
4. DataBind, જે row insert કરે છે અને page તાજું કરે છે

💭 Think first

Parameters SQL injection ને બરાબર કઈ રીતે અટકાવે છે?

બંને છેવટે વપરાશકારનું લખાણ જ વાપરે છે, તો પણ "'" + txtName.Text + "'" જોખમી હોય અને @name સલામત હોય એવું શા માટે? વિચારીને પછી tap કરો.

✅ Summary

Key takeaways

• Connection, Command અને ExecuteReader થી વાંચો: DataReader મેળવો અને reader.Read() rows માં આગળ વધારે ત્યાં સુધી આંટા મારો.
• Data બદલવા (insert, update, delete) ExecuteNonQuery વાપરો, જે અસર પામેલી rows ની સંખ્યા પાછી આપે છે: એક insert માટે 1.
• ExecuteScalar એક જ કિંમત પાછી આપે છે (જેમ કે COUNT); ExecuteReader rows પાછી આપે છે; ExecuteNonQuery ગણતરી પાછી આપે છે.
• વપરાશકારે ભરેલા લખાણ માટે હંમેશા parameter વાળી queries વાપરો (cmd.Parameters દ્વારા @name); એને SQL માં કદી જોડશો નહીં.
• જોડાણ SQL injection ને છૂટ આપે છે; parameters વપરાશકારનું લખાણ કડક રીતે data તરીકે મોકલે છે, એટલે એ SQL તરીકે કદી ચાલી શકતું નથી.
• Connection હંમેશા બંધ કરો; using block એ કામ આપોઆપ કરે છે, ભૂલ આવે તો પણ.
• યાદ રાખવાની કડી: વાંચવા ExecuteReader, બદલવા ExecuteNonQuery, અને વપરાશકારની દરેક કિંમતને parameter બનાવો.