ક્વેરી રનરને રીડ-ઓન્લી (Read-Only) બનાવવા માટે SQL પાર્સ (Parse) કરશો નહીં
SQL સ્ટ્રિંગ્સમાં કીવર્ડ્સ તપાસીને તમારા ડેટાબેઝને સુરક્ષિત કરવાનો પ્રયાસ કરવાનું બંધ કરો.
જો તમે SQL ચલાવવા માટે કોઈ ટૂલ બનાવો છો, તો તમારે રીડ-ઓન્લી મોડની જરૂર પડશે. તમે ભૂલથી થતા UPDATE દ્વારા તમારા ડેટાને ડિલીટ થતો અટકાવવા માંગો છો. તમારો પહેલો વિચાર DELETE અથવા DROP જેવા શબ્દોને બ્લોક કરવાનો હોઈ શકે છે.
આવું કરશો નહીં.
સ્ટ્રિંગ ચેક્સને બાયપાસ (bypass) કરવી સરળ છે. વપરાશકર્તા DELETE ને છુપાવવા માટે WITH ક્લોઝનો ઉપયોગ કરી શકે છે. તેઓ કમાન્ડ્સ છુપાવવા માટે કોમેન્ટ્સનો ઉપયોગ કરી શકે છે. તેઓ એવું ફંક્શન કોલ કરી શકે છે જે ટેબલમાં ડેટા લખે છે. અંતે તમે એક નિરર્થક અને ક્યારેય ન જીતી શકાય તેવી રમત રમતા રહી જશો.
સુરક્ષાનું કામ ડેટાબેઝને કરવા દો.
Postgres માં આ માટે ઇન-બિલ્ટ ફીચર છે. તમે ટ્રાન્ઝેક્શનને રીડ-ઓન્લી તરીકે જાહેર કરી શકો છો. ત્યારબાદ સર્વર કોઈપણ 'write' કમાન્ડનો ઇનકાર કરશે. આમાં CTEs, functions અને DDL નો સમાવેશ થાય છે.
Python માં તેને યોગ્ય રીતે કેવી રીતે અમલમાં મૂકવું તે અહીં છે:
autocommitનેFalseસેટ કરીને વાસ્તવિક ટ્રાન્ઝેક્શનનો ઉપયોગ કરો.- પ્રથમ કમાન્ડ તરીકે
SET TRANSACTION READ ONLYચલાવો. - લાંબા સમય સુધી ચાલતી ક્વેરીઝ દ્વારા તમારી સિસ્ટમ લોક ન થઈ જાય તે માટે
statement_timeoutસેટ કરો. - લોક્સ અને સ્નેપશોટ્સને મુક્ત કરવા માટે અંતમાં
rollback()નો ઉપયોગ કરો.
આ અભિગમ SQL ટેક્સ્ટનું નિરીક્ષણ કરતો નથી. ક્વેરી બરાબર લખેલી રીતે જ સર્વર પર જાય છે. તમે એન્જિનને નિયમનું પાલન કરવા માટે કહી રહ્યા છો.
સુરક્ષા માટે બે ભાગો જરૂરી છે:
- રાઈટ્સ (writes) થી રક્ષણ: રીડ-ઓન્લી ટ્રાન્ઝેક્શનનો ઉપયોગ કરો.
- રિસોર્સના દુરુપયોગથી રક્ષણ: ટાઈમઆઉટ અને રો લિમિટ્સ (row limits) નો ઉપયોગ કરો.
એક રીડ-ઓન્લી ક્વેરી હજુ પણ વિશાળ join સાથે તમારી સિસ્ટમને ક્રેશ કરી શકે છે. રીડ-ઓન્લી ટ્રાન્ઝેક્શન રાઈટ્સને અટકાવે છે, પરંતુ તે ભારે રિસોર્સ વપરાશને અટકાવતું નથી. એડ-હોક (ad-hoc) SQL ને સુરક્ષિત બનાવવા માટે તમારે બંનેની જરૂર છે.
SQL પાર્સ કરવાનું બંધ કરો. ડેટાબેઝને તેનું કામ કરવા કહો.
સ્ત્રોત: https://dev.to/hitoshi1964/dont-parse-sql-to-make-a-query-runner-read-only-b62