CRUD શું છે? Create, Read, Update, Delete સમજાવ્યું

CRUD એટલે create, read, update અને delete — એપ સંગ્રહાયેલા ડેટા સાથે કરે તે ચાર મૂળભૂત કામો. નવો ગ્રાહક ઉમેરવું એ create છે, ગ્રાહકોની યાદી જોવી એ read છે, તેમનો ફોન નંબર બદલવો એ update છે, અને તેમને કાઢી નાખવા એ delete છે. મોટાભાગની બિઝનેસ એપ — CRM, બુકિંગ સિસ્ટમ, ઇન્વેન્ટરી ટ્રેકર, એડમિન પૅનલ — નિયમો અને સારા લેઆઉટ સાથેનું મોટા ભાગે CRUD છે.

AI સાથે બનાવતી વખતે તે કેમ મહત્વનું છે

CRUD એ શબ્દભંડોળ છે જે અસ્પષ્ટ એપ વિચારને ચોક્કસ વિનંતીમાં ફેરવે છે. "અમારા સપ્લાયરોનું સંચાલન કરવા માટેની એપ" AIને અનુમાન કરવા છોડી દે છે. "આ ફીલ્ડ સાથે સપ્લાયર બનાવો, યાદી જુઓ, સુધારો અને કાઢી નાખો" તેને બરાબર કહે છે કઈ સ્ક્રીન, ડેટાબેઝ કામગીરીઓ અને સર્વર રૂટ બનાવવા.

તે તમને ટેસ્ટિંગ માટે ચેકલિસ્ટ પણ આપે છે. તમારી એપમાં દરેક પ્રકારના રેકૉર્ડ માટે ચાર પ્રશ્નો પૂછી શકાય: શું હું એક ઉમેરી શકું, તેમને જોઈ શકું, એક બદલી શકું અને એક કાઢી શકું — અને શું ફક્ત યોગ્ય લોકો દરેક કરી શકે? AI-બનાવેલી ઘણી એપ રેકૉર્ડ બનાવી શકે પણ સુધારી ન શકે, અથવા કોઈને પણ કંઈ પણ કાઢવા દે.

રોજિંદા ઉદાહરણ: રેસિપી કાર્ડનું બૉક્સ

રસોડાના શેલ્ફ પર રેસિપી કાર્ડનું બૉક્સ કલ્પો.

• Create: નવું કાર્ડ લખો અને ફાઇલ કરો.
• Read: બૉક્સમાં જુઓ, અથવા લઝાનિયાનું કાર્ડ કાઢો.
• Update: "200g ચીઝ" કાપીને "250g" લખો.
• Delete: કાર્ડ કાઢીને ફેંકી દો.

હવે નિયમો ઉમેરો: ફક્ત મુખ્ય રસોઇયો કાર્ડ ફેંકી શકે, દરેક કાર્ડનું શીર્ષક હોવું જોઈએ, અને કોઈ એક જ નામના બે કાર્ડ ફાઇલ ન કરી શકે. એ વેલિડેશન અને પરવાનગીવાળી CRUD એપ છે — જે મોટાભાગની વાસ્તવિક એપ હોય છે.

દરેક સ્તરમાં CRUD કેવી રીતે દેખાય છે

દરેક કામગીરી સ્ક્રીન, સર્વર અને ડેટાબેઝમાં દેખાય છે. તેમને સાથે જોવાથી એપ કેવી રીતે બને છે તે ઘણું સમજાય છે.

સ્ક્રીન એ frontend છે, API વિનંતી એ frontend બૅકએન્ડ સાથે કેવી રીતે વાત કરે છે તે છે, અને SQL એ બૅકએન્ડ ડેટાબેઝ સાથે કેવી રીતે વાત કરે છે તે છે. જો આ શબ્દો નવા હોય, તો જુઓ API શું છે અને ડેટાબેઝ શું છે.

કામ કરેલું ઉદાહરણ: સાધનોની લોન ટ્રેકર

એક શાળાનો મીડિયા વિભાગ વિદ્યાર્થીઓને કૅમેરા અને માઇક્રોફોન ઉધાર આપે છે અને તેનો હિસાબ રાખવામાં વારંવાર ચૂકે છે. તેમને એક સરળ એપ જોઈએ છે.

રેકૉર્ડ. બે પ્રકારની વસ્તુઓ: સાધનો (નામ, પ્રકાર, સીરીયલ નંબર, સ્થિતિ) અને લોન (કયું સાધન, કયો વિદ્યાર્થી, ક્યારે આપ્યું, ક્યારે પાછું આપવાનું, ક્યારે પાછું આવ્યું).

સાધનો માટે CRUD:

• Create: સ્ટાફ સીરીયલ નંબર સાથે નવો કૅમેરા ઉમેરે. નિયમ: સીરીયલ નંબર અનન્ય હોવા જોઈએ.
• Read: બધાં સાધનોની યાદી, પ્રકાર અને "હમણાં ઉપલબ્ધ" પ્રમાણે ફિલ્ટર થઈ શકે; એક વસ્તુનો લોન ઇતિહાસ બતાવતું વિગતવાર પેજ.
• Update: સ્થિતિ "સમારકામ જોઈએ" કરવી.
• Delete: સામાન્ય રીતે ખરેખર કાઢી ન નાખવું. જો 30 ભૂતકાળની લોન ધરાવતો કૅમેરા કાઢી નાખવામાં આવે, તો તે લોન રેકૉર્ડ તેની સાથેનું જોડાણ ગુમાવે. તેના બદલે તેને "retired" ચિહ્નિત કરો, જેથી તે ઉપલબ્ધ યાદીમાંથી જાય પણ તેનો ઇતિહાસ રહે. આને soft delete કહેવાય છે.

લોન માટે CRUD:

• Create: વિદ્યાર્થીને વસ્તુ આપો. નિયમ: જે વસ્તુ પહેલેથી લોનમાં છે તે ફરી ન આપી શકાય.
• Read: "મુદત વીતેલી લોન" — યાદી જ્યાં પરત કરવાની તારીખ વીતી ગઈ છે અને પરત કરવાની તારીખ નથી.
• Update: વસ્તુ પાછી આવે ત્યારે પરત કરવાની તારીખ નોંધવી.
• Delete: ફક્ત સ્ટાફ, ભૂલથી દાખલ થયેલી લોન માટે.

પરવાનગીઓ. વિદ્યાર્થીઓ શું ઉપલબ્ધ છે તે વાંચી શકે; ફક્ત સ્ટાફ બનાવી, સુધારી કે કાઢી શકે. આ તપાસો સર્વર પર ચાલે છે, ફક્ત બટન છુપાવીને નહીં.

બસ, આ આખી એપ છે. રસપ્રદ ભાગો — ડબલ-લોન ન થવી, મુદત વીતેલી યાદી, દરેક વસ્તુનો ઇતિહાસ — એ સાદા CRUD ઉપર નિયમો અને ક્વેરી છે.

મુખ્ય શબ્દો

• રેકૉર્ડ (row): એક વસ્તુ, જેમ કે એક સપ્લાયર અથવા એક લોન.
• Entity / resource: રેકૉર્ડનો એક પ્રકાર, જેમ કે "સપ્લાયર". દરેકને સામાન્ય રીતે પોતાનું ટેબલ અને પોતાના CRUD સ્ક્રીનનો સેટ મળે છે.
• વેલિડેશન: ઇનપુટ પરની તપાસ — જરૂરી ફીલ્ડ, માન્ય ઇમેઇલ, હકારાત્મક જથ્થો. સગવડ માટે ફોર્મમાં અને સલામતી માટે સર્વર પર કરો.
• Soft delete: ઇતિહાસ અને જોડાણો ટકે તે માટે રેકૉર્ડને કાઢવાને બદલે deleted અથવા archived ચિહ્નિત કરવો.
• પેજિનેશન: લાંબી યાદી એક પેજ એક સમયે બતાવવી, જેથી એપ ઝડપી રહે.
• ઑડિટ લૉગ: કોણે શું બનાવ્યું, બદલ્યું કે કાઢ્યું, અને ક્યારે, તેનો રેકૉર્ડ.
• એડમિન પૅનલ: એપનો ડેટા સંચાલિત કરવા સ્ટાફ માટે CRUD સ્ક્રીનનો સેટ.

સામાન્ય ભૂલો અને ગેરસમજો

• ચારમાંથી એક ભૂલી જવું. એપ ઘણીવાર create અને read સાથે આવે પણ edit વગર, તેથી દરેક ટાઇપો માટે કાઢીને ફરી દાખલ કરવું પડે. દરેક entity માટે ચારેય તપાસો.
• એવા delete જે વસ્તુઓ તોડે. ઇન્વૉઇસ ધરાવતો ગ્રાહક કાઢવાથી અનાથ ઇન્વૉઇસ રહી શકે અથવા ઇતિહાસ ભૂંસાઈ શકે. દરેક entity માટે નક્કી કરો: delete અટકાવવું, soft delete, અથવા સંબંધિત રેકૉર્ડ પણ કાઢવા.
• ફક્ત ઇન્ટરફેસમાં પરવાનગીઓ. Delete બટન છુપાવવાથી કોઈ DELETE વિનંતી મોકલતાં અટકતું નથી. સર્વરે તપાસવું જોઈએ કે કોણ પૂછે છે.
• માલિકી તપાસ્યા વગર ID વડે અપડેટ. જો વપરાશકર્તા A URLમાં નંબર બદલીને /api/notes/42 સુધારી શકે, તો તે વપરાશકર્તા B ની નોંધ બદલી શકે. દરેક update અને delete એ ખાતરી કરવી જોઈએ કે રેકૉર્ડ વિનંતી કરનારનો છે.
• Delete પર પુષ્ટિ નહીં. એક ખોટો ટૅપ ડેટા નષ્ટ ન કરવો જોઈએ. પુષ્ટિ પગલું, અથવા undo માંગો.
• "CRUD એટલે સાદું, તો બનાવવા જેવું નથી." ઘણાં મૂલ્યવાન ઉત્પાદનો CRUD એપ છે જે સામાન્ય ટૂલ કરતાં વર્કફ્લોમાં વધુ સારી રીતે બંધબેસે છે.

તમારા AI બિલ્ડરને શું માંગવું

દરેક entity માટે, એક સમયે એક, આ પેટર્ન વાપરો:

suppliers સુવિધા બનાવો જેમાં list, create, edit અને delete હોય. ફીલ્ડ: name (જરૂરી), contact email (માન્ય ઇમેઇલ), phone, category (એક: food, packaging, cleaning), notes. નામ પ્રમાણે શોધ અને category પ્રમાણે ફિલ્ટર સાથેની યાદી, પાના દીઠ 20. કાઢતા પહેલાં પુષ્ટિ કરો; જો સપ્લાયર પાસે ઓર્ડર હોય તો કાઢવાને બદલે archive કરો. ફક્ત લૉગ ઇન થયેલો સ્ટાફ બનાવી, સુધારી કે archive કરી શકે — આ સર્વર પર લાગુ કરો.

પછી ચારેય કામગીરી ચકાસો, પરવાનગી ધરાવતા વપરાશકર્તા તરીકે અને જેને ઍક્સેસ ન હોવી જોઈએ તેના તરીકે. એક entity કામ કરે પછી આગલું ઉમેરો. આંતરિક ટૂલ કેવી રીતે બનાવવું બતાવે છે કે CRUD સ્ક્રીન સંપૂર્ણ એડમિન એપ કેવી રીતે બને છે, અને Postgres શું છે તે ડેટાબેઝ સમજાવે છે જેના પર આમાંની મોટાભાગની એપ ચાલે છે.

Mythex પર CRUD એપ

CRUD એપ એ AI એપ બિલ્ડર સૌથી સારી રીતે કરે છે તેમાંની એક છે, અને Mythex પણ તેમાં અપવાદ નથી. ચેટમાં entity અને તેના ફીલ્ડ માંગો, અને Mythex પ્રોજેક્ટ સાથે Postgres ડેટાબેઝ જોડે છે, ટેબલ બનાવે છે, અને લાઇવ પ્રીવ્યૂમાં યાદી, ફોર્મ અને વિગતવાર સ્ક્રીન બનાવે છે; પછી પ્રવાહ તપાસવા તમે /test ચલાવી શકો છો. docsમાં એક સ્ટાર્ટર પ્રોમ્પ્ટ સાથે CRUD એપ રેસિપી છે, અને આંતરિક ટૂલ બિલ્ડર તથા ડૅશબોર્ડ ટેમ્પ્લેટ શરૂ કરવા સારી જગ્યાઓ છે.

પ્રશ્નો