ව්ලැඩිමීර් සිට්නිකොව්ගේ මුල් 2016 වාර්තාවේ පිටපත කියවීමට මම ඔබට යෝජනා කරමි "PostgreSQL සහ JDBC සියලු යුෂ මිරිකා"
සුභ සන්ධ්යාවක් මගේ නම ව්ලැඩිමීර් සිට්නිකොව්. මම අවුරුදු 10ක් NetCracker එකේ වැඩ කරනවා. ඒ වගේම මම වැඩිපුරම ඉන්නේ ඵලදායිතාවයට. ජාවා සම්බන්ධ හැම දෙයක්ම, SQL සම්බන්ධ සෑම දෙයක්ම මම කැමතියි.
අපි PostgreSQL දත්ත සමුදා සේවාදායකයක් ලෙස භාවිතා කිරීමට පටන් ගත් විට සමාගම තුළ අපට හමු වූ දේ ගැන අද මම කතා කරමි. අනික අපි වැඩිපුරම වැඩ කරන්නේ ජාවා එක්ක. හැබැයි මම අද ඔයාලට කියන්න යන්නේ Java ගැන විතරක් නෙවෙයි. ප්රායෝගිකව පෙන්වා දී ඇති පරිදි, මෙය වෙනත් භාෂාවලින් ද සිදු වේ.
අපි කතා කරන්නම්:
- දත්ත නියැදීම ගැන.
- දත්ත සුරැකීම ගැන.
- ඒ වගේම කාර්ය සාධනය ගැන.
- සහ එහි වළලනු ලබන දිය යට රාක්ක ගැන.
සරල ප්‍රශ්නයකින් පටන් ගනිමු. ප්රාථමික යතුර මත පදනම්ව අපි මේසයෙන් එක් පේළියක් තෝරා ගනිමු.
දත්ත සමුදාය එකම සත්කාරකයේ පිහිටා ඇත. ඒ වගේම මේ හැම ගොවිතැනකටම මිලි තත්පර 20ක් යනවා.
මෙම මිලි තත්පර 20 බොහෝ වේ. ඔබට එවැනි ඉල්ලීම් 100ක් තිබේ නම්, ඔබ මෙම ඉල්ලීම් හරහා තත්පරයකට කාලය ගත කරයි, එනම් අපි කාලය නාස්ති කරනවා.
අපි මෙය කිරීමට කැමති නැති අතර මේ සඳහා පදනම අපට ලබා දෙන දේ දෙස බලන්න. දත්ත සමුදාය අපට විමසුම් ක්රියාත්මක කිරීම සඳහා විකල්ප දෙකක් ඉදිරිපත් කරයි.
පළමු විකල්පය සරල ඉල්ලීමකි. එහි ඇති හොඳ කුමක්ද? අපි ඒක අරන් යවන එක මිසක් වැඩි දෙයක් නෑ.
දත්ත සමුදායේ උසස් විමසුමක් ද ඇත, එය වඩාත් උපක්‍රමශීලී, නමුත් වඩා ක්‍රියාකාරී වේ. විග්‍රහ කිරීම, ක්රියාත්මක කිරීම, විචල්‍ය බැඳීම යනාදිය සඳහා ඔබට වෙන වෙනම ඉල්ලීමක් යැවිය හැකිය.
සුපිරි දිගු විමසුම අපි වත්මන් වාර්තාවෙන් ආවරණය නොකරන දෙයකි. අපට, සමහර විට, දත්ත සමුදායෙන් යමක් අවශ්ය වන අතර, යම් ආකාරයකින් සකස් කර ඇති පැතුම් ලැයිස්තුවක් ඇත, එනම් අපට අවශ්ය වන්නේ මෙයයි, නමුත් එය දැන් සහ ඊළඟ වසරේ කළ නොහැක. එබැවින් අපි එය පටිගත කළ අතර අපි ප්‍රධාන පුද්ගලයින් සොලවමින් යන්නෙමු.
තවද අපට කළ හැක්කේ සරල විමසුම සහ දීර්ඝ විමසුමයි.
එක් එක් ප්රවේශයේ විශේෂත්වය කුමක්ද?
එක් වරක් ක්රියාත්මක කිරීම සඳහා සරල විමසුමක් හොඳයි. එක පාරක් කරලා අමතක වෙලා. තවද ගැටළුව වන්නේ එය ද්විමය දත්ත ආකෘතියට සහය නොදක්වයි, එනම් එය සමහර ඉහළ කාර්ය සාධන පද්ධති සඳහා සුදුසු නොවේ.
විස්තීරණ විමසුම - විග්‍රහ කිරීමේදී කාලය ඉතිරි කර ගැනීමට ඔබට ඉඩ සලසයි. මේක තමයි අපි කරලා පාවිච්චි කරන්න පටන් ගත්තේ. මෙය ඇත්ත වශයෙන්ම අපට උපකාර විය. විග්‍රහ කිරීමේදී ඉතිරිකිරීම් පමණක් නොමැත. දත්ත මාරු කිරීමේදී ඉතිරි කිරීම් තිබේ. ද්විමය ආකෘතියෙන් දත්ත මාරු කිරීම වඩාත් කාර්යක්ෂම වේ.
අපි පුහුණුවීම් වලට යමු. සාමාන්ය යෙදුමක් පෙනෙන්නේ මෙයයි. එය ජාවා ආදිය විය හැක.
අපි ප්රකාශයක් හැදුවා. විධානය ක්රියාත්මක කළා. සමීපව නිර්මාණය කර ඇත. මෙතන වැරැද්ද කොතනද? ප්රශ්නය කුමක් ද? ප්රශ්නයක් නැහැ. සියලුම පොත්වල සඳහන් වන්නේ මෙයයි. එය ලිවිය යුතු ආකාරය මෙයයි. ඔබට උපරිම කාර්ය සාධනය අවශ්ය නම්, මේ ආකාරයට ලියන්න.
නමුත් ප්රායෝගිකව පෙන්නුම් කර ඇත්තේ මෙය ක්රියා නොකරන බවයි. ඇයි? මොකද අපිට තියෙන්නේ "සමීප" ක්‍රමයක්. අපි මෙය කරන විට, දත්ත සමුදායේ දෘෂ්ටි කෝණයෙන් එය දත්ත සමුදායක් සමඟ වැඩ කරන දුම් පානය කරන්නෙකු වැනි බව පෙනේ. අපි කිව්වා "PARSE EXECUTE DEALLOCATE" කියලා.
ඇයි මේ අමතර නිර්මාණ සහ ප්‍රකාශ ගොඩබෑම? කාටවත් ඒවා අවශ්ය නැහැ. නමුත් PreparedStatements වල සාමාන්‍යයෙන් වෙන්නේ අපි ඒවා close කලාම ඒවා database එකේ තියෙන හැම දෙයක්ම close කරන එක. මෙය අපට අවශ්ය නොවේ.
අපට අවශ්ය, නිරෝගී පුද්ගලයන් මෙන්, පදනම සමඟ වැඩ කිරීමට ය. අපි එක පාරක් අරගෙන අපේ ප්රකාශය සකස් කළා, ඊට පස්සේ අපි එය බොහෝ වාරයක් ක්රියාත්මක කරනවා. ඇත්ත වශයෙන්ම, බොහෝ වාරයක් - මෙය යෙදුම්වල මුළු ජීවිත කාලය තුළම වරක් - ඒවා විග්‍රහ කර ඇත. තවද අපි විවිධ REST වල එකම ප්‍රකාශ id භාවිතා කරමු. මෙය අපගේ ඉලක්කයයි.
අපට මෙය සාක්ෂාත් කරගත හැක්කේ කෙසේද?
එය ඉතා සරලයි - ප්රකාශයන් වසා දැමීම අවශ්ය නොවේ. අපි එය මෙසේ ලියන්නෙමු: "සූදානම්" "ක්රියාත්මක කරන්න".
අපි මෙවැනි දෙයක් දියත් කළහොත්, යමක් කොතැනක හෝ පිටාර ගලන බව පැහැදිලිය. එය පැහැදිලි නැතිනම්, ඔබට එය උත්සාහ කළ හැකිය. මෙම සරල ක්රමය භාවිතා කරන මිණුම් ලකුණක් ලියමු. ප්රකාශයක් සාදන්න. අපි එය ධාවකයේ සමහර අනුවාදයක් මත දියත් කරන අතර එහි තිබූ සියලුම මතකය නැතිවීමත් සමඟ එය ඉතා ඉක්මනින් කඩා වැටෙන බව සොයා ගන්නෙමු.
එවැනි දෝෂ පහසුවෙන් නිවැරදි කළ හැකි බව පැහැදිලිය. මම ඔවුන් ගැන කතා නොකරමි. නමුත් නව අනුවාදය වඩා වේගයෙන් ක්රියා කරන බව මම කියමි. ක්රමය මෝඩයි, නමුත් තවමත්.
නිවැරදිව වැඩ කරන්නේ කෙසේද? මේ සඳහා අප කළ යුත්තේ කුමක්ද?
යථාර්ථය නම්, යෙදුම් සෑම විටම ප්‍රකාශ වසා දමයි. හැම පොතකම කියනවා වහන්න, නැත්නම් මතකය කාන්දු වෙනවා කියලා.
තවද PostgreSQL විමසුම් හැඹිලි කරන්නේ කෙසේදැයි නොදනී. සෑම සැසියක්ම තමාටම මෙම හැඹිලිය නිර්මාණය කිරීම අවශ්ය වේ.
ඒ වගේම අපි විග්‍රහ කිරීමට කාලය නාස්ති කරන්න කැමති නැහැ.
සහ සුපුරුදු පරිදි අපට විකල්ප දෙකක් තිබේ.
පළමු විකල්පය නම් අපි එය ගෙන PgSQL වලින් සියල්ල ඔතා ගනිමු යැයි පැවසීමයි. එතන cache එකක් තියෙනවා. එය සියල්ල හැඹිලි කරයි. එය විශිෂ්ට ලෙස හැරෙනු ඇත. අපි මේක දැක්කා. අපිට ඉල්ලීම් 100500ක් තියෙනවා. වැඩ කරන්නේ නෑ. ඉල්ලීම් අතින් ක්රියා පටිපාටි බවට පත් කිරීමට අපි එකඟ නොවෙමු. නෑ නෑ.
අපට දෙවන විකල්පය ඇත - එය ගෙන එය අප විසින්ම කපන්න. අපි මූලාශ්ර විවෘත කර කැපීම ආරම්භ කරමු. අපි දැක්කා දැක්කා. එය කිරීම එතරම් අපහසු නොවන බව පෙනී ගියේය.
මෙය 2015 අගෝස්තු මාසයේදී දර්ශනය විය. දැන් වඩාත් නවීන අනුවාදයක් තිබේ. ඒ වගේම හැම දෙයක්ම විශිෂ්ටයි. එය ඉතා හොඳින් ක්රියා කරන අතර අපි යෙදුමේ කිසිවක් වෙනස් නොකරමු. තවද අපි PgSQL හි දිශාවට සිතීම පවා නැවැත්වූයෙමු, එනම් මෙය අපට සියලු පොදු කාර්ය පිරිවැය බිංදුව දක්වා අඩු කිරීමට ප්‍රමාණවත් විය.
ඒ අනුව, එක් එක් වරක් ඉල්ලීම මත දත්ත සමුදායේ මතකය අපතේ යාම වළක්වා ගැනීම සඳහා 5 වැනි ක්රියාත්මක කිරීමේදී සේවාදායකය විසින් සකස් කරන ලද ප්රකාශයන් සක්‍රිය කෙරේ.
ඔබට ඇසිය හැක - අංක කොහෙද? ඔබට ලැබෙන්නේ කුමක්ද? මෙහි මම අංක ලබා නොදෙමි, මන්ද සෑම ඉල්ලීමකටම එයම ඇත.
අපගේ විමසුම් කෙතරම්ද යත්, අපි OLTP විමසුම් මත විග්‍රහ කිරීමට මිලි තත්පර 20ක් පමණ වැය කළෙමු. ක්රියාත්මක කිරීම සඳහා මිලි තත්පර 0,5 ක්, විග්‍රහ කිරීම සඳහා මිලි තත්පර 20 ක් විය. ඉල්ලීම - 10 KiB පෙළ, පේළි 170 සැලැස්ම. මෙය OLTP ඉල්ලීමකි. එය පේළි 1, 5, 10, සමහර විට තවත් ඉල්ලයි.
නමුත් අපට මිලි තත්පර 20ක් නාස්ති කිරීමට අවශ්ය නොවීය. අපි එය 0 දක්වා අඩු කළා. හැම දෙයක්ම නියමයි.
ඔබට මෙතැනින් රැගෙන යා හැක්කේ කුමක්ද? ඔබට ජාවා තිබේ නම්, ඔබ ධාවකයේ නවීන අනුවාදය ගෙන ප්රීති වන්න.
ඔබ වෙනත් භාෂාවක් කතා කරන්නේ නම්, සිතන්න - සමහර විට ඔබට මෙයද අවශ්‍යද? මක්නිසාද යත් අවසාන භාෂාවේ දෘෂ්ටි කෝණයෙන්, උදාහරණයක් ලෙස, PL 8 හෝ ඔබට LibPQ තිබේ නම්, ඔබ කාලය ගත කරන්නේ ක්රියාත්මක කිරීමට, විග්‍රහ කිරීමට නොවන බව ඔබට පැහැදිලි නැත, මෙය පරීක්ෂා කිරීම වටී. කෙසේද? හැම දෙයක්ම නොමිලේ.
වැරදි සහ සමහර සුවිශේෂතා ඇති බව හැර. ඒ වගේම අපි දැන් ඔවුන් ගැන කතා කරමු. එයින් වැඩි හරියක් කාර්මික පුරාවිද්‍යාව, අප සොයාගත් දේ, අපට හමු වූ දේ ගැන වනු ඇත.
ඉල්ලීම ගතිකව උත්පාදනය කරන්නේ නම්. එය සිදු වේ. යමෙක් නූල් එකට ඇලවීම, SQL විමසුමක් ඇති කරයි.
ඔහු නරක ඇයි? ඒක නරකයි මොකද හැම වෙලාවකම අපි වෙනස් නූලකින් අවසන් වෙනවා.
තවද මෙම වෙනස් තන්තුවෙහි hashCode නැවත කියවිය යුතුය. මෙය සැබවින්ම CPU කාර්යයකි - පවතින හැෂ් එකක පවා දිගු ඉල්ලීම් පෙළක් සොයා ගැනීම එතරම් පහසු නැත. එබැවින්, නිගමනය සරලයි - ඉල්ලීම් උත්පාදනය නොකරන්න. ඒවා එක් විචල්‍යයක ගබඩා කරන්න. සහ ප්රීති වන්න.
ඊළඟ ගැටලුව. දත්ත වර්ග වැදගත් වේ. ORMs ඇත, එය කුමන ආකාරයේ NULL තිබුණත් කමක් නැත, යම් ආකාරයක වේවා. Int නම් අපි setInt කියනවා. සහ NULL නම්, එය සැමවිටම VARCHAR වීමට ඉඩ දෙන්න. සහ අවසානයේ එහි ඇති NULL හි ඇති වෙනස කුමක්ද? දත්ත සමුදාය විසින්ම සියල්ල අවබෝධ වනු ඇත. ඒ වගේම මේ පින්තූරය වැඩ කරන්නේ නැහැ.
ප්රායෝගිකව, දත්ත සමුදාය කිසිසේත් ගණන් ගන්නේ නැත. ඔබ මෙය අංකයක් බව පළමු වරට කීවා නම් සහ දෙවන වරට එය VARCHAR එකක් බව ඔබ කීවේ නම්, එවිට සේවාදායකයෙන් සකස් කළ ප්රකාශයන් නැවත භාවිතා කළ නොහැක. මේ අවස්ථාවේ දී, අපි අපගේ ප්රකාශය නැවත නිර්මාණය කළ යුතුය.
ඔබ එකම විමසුම ක්රියාත්මක කරන්නේ නම්, ඔබේ තීරුවේ ඇති දත්ත වර්ග ව්‍යාකූල නොවන බවට වග බලා ගන්න. ඔබ NULL ගැන සැලකිලිමත් විය යුතුය. මෙය අපි PreparedStatements භාවිතා කිරීමට පටන් ගත් පසු අපට ඇති වූ පොදු දෝෂයකි
හරි, ඔන් කළා. සමහරවිට ඔවුන් රියදුරු රැගෙන ගියා. සහ ඵලදායිතාවය අඩු විය. දේවල් නරක අතට හැරුණා.
මෙය සිදු වන්නේ කෙසේද? මෙය දෝෂයක් හෝ විශේෂාංගයක්ද? අවාසනාවට, මෙය දෝෂයක් ද විශේෂාංගයක් ද යන්න තේරුම් ගැනීමට නොහැකි විය. නමුත් මෙම ගැටළුව ප්රතිනිෂ්පාදනය කිරීම සඳහා ඉතා සරල අවස්ථාවක් තිබේ. ඇය සම්පූර්ණයෙන්ම අනපේක්ෂිත ලෙස අපට පහර දුන්නාය. තවද එය එක් වගුවකින් වචනාර්ථයෙන් නියැදීමකින් සමන්විත වේ. ඇත්ත වශයෙන්ම, අපට තවත් එවැනි ඉල්ලීම් තිබුණි. රීතියක් ලෙස, ඒවාට වගු දෙකක් හෝ තුනක් ඇතුළත් කර ඇත, නමුත් එවැනි නැවත ධාවනය කිරීමේ අවස්ථාවක් තිබේ. ඔබගේ දත්ත ගබඩාවෙන් ඕනෑම අනුවාදයක් ගෙන එය වාදනය කරන්න.
කාරණය වන්නේ අපට තීරු දෙකක් ඇති අතර, ඒ සෑම එකක්ම සුචිගත කර ඇත. එක් NULL තීරුවක පේළි මිලියනයක් ඇත. දෙවන තීරුවේ අඩංගු වන්නේ පේළි 20 ක් පමණි. අපි බැඳී ඇති විචල්‍යයන් නොමැතිව ක්රියාත්මක කරන විට, සියල්ල හොඳින් ක්රියාත්මක වේ.
අපි බන්ධිත විචල්‍යයන් සමඟ ක්රියාත්මක කිරීම ආරම්භ කරන්නේ නම්, එනම් අපි "?" හෝ අපගේ ඉල්ලීම සඳහා "$1", අවසානයේ අපට ලැබෙන්නේ කුමක්ද?
පළමු ක්රියාත්මක කිරීම අපේක්ෂා කළ පරිදි වේ. දෙවෙනි එක ටිකක් වේගවත්. යමක් හැඹිලිගත විය. තුන්වන, හතරවන, පස්වන. එතකොට බං - සහ ඒ වගේ දෙයක්. නරකම දෙය නම් මෙය හයවන ක්රියාත්මක කිරීමේදී සිදු වීමයි. සත්‍ය ක්රියාත්මක කිරීමේ සැලැස්ම කුමක්දැයි වටහා ගැනීම සඳහා හරියටම මරණ දණ්ඩනය හයක් කළ යුතු බව කවුද දැන සිටියේ?
වැරදිකරු කවුද? සිදුවුයේ කුමක් ද? දත්ත සමුදායේ ප්‍රශස්තකරණය අඩංගු වේ. එය සාමාන්ය නඩුව සඳහා ප්‍රශස්ත කර ඇති බව පෙනේ. තවද, ඒ අනුව, යම් අවස්ථාවක සිට, ඇය පොදු සැලැස්මකට මාරු වන අතර, අවාසනාවකට මෙන්, එය වෙනස් විය හැකිය. එය සමාන විය හැකිය, නැතහොත් එය වෙනස් විය හැකිය. තවද මෙම හැසිරීමට තුඩු දෙන යම් ආකාරයක එළිපත්ත අගයක් තිබේ.
ඔබට ඒ ගැන කුමක් කළ හැකිද? මෙන්න, ඇත්ත වශයෙන්ම, ඕනෑම දෙයක් උපකල්පනය කිරීම වඩා දුෂ්කර ය. අපි භාවිතා කරන සරල විසඳුමක් තිබේ. මෙය +0, OFFSET 0. නිසැකවම ඔබ එවැනි විසඳුම් දන්නවා. අපි එය රැගෙන ඉල්ලීමට "+0" එකතු කරන්නෙමු, සියල්ල හොඳයි. මම ඔබට පසුව පෙන්වන්නම්.
තවත් විකල්පයක් ඇත - සැලසුම් වඩාත් ප්රවේශමෙන් බලන්න. සංවර්ධකයා ඉල්ලීමක් ලිවීමට පමණක් නොව, "විශ්ලේෂණ පැහැදිලි කරන්න" 6 වරක් පැවසිය යුතුය. එය 5 නම්, එය ක්රියා නොකරයි.
සහ තුන්වන විකල්පය ඇත - pgsql-hackers වෙත ලිපියක් ලියන්න. මම ලිව්වා, කෙසේ වෙතත්, මෙය දෝෂයක් ද නැතහොත් විශේෂාංගයක් ද යන්න තවමත් පැහැදිලි නැත.
මෙය දෝෂයක් හෝ විශේෂාංගයක් දැයි අපි සිතමින් සිටින අතර, අපි එය නිවැරදි කරමු. අපි අපේ ඉල්ලීම ගෙන "+0" එකතු කරමු. හැම දෙයක්ම හොඳයි. සංකේත දෙකක් සහ එය කෙසේ හෝ එය කුමක්ද යන්න ගැන සිතීමට පවා ඔබට අවශ්ය නැත. හරිම සරලයි. අපි මෙම තීරුවේ දර්ශකයක් භාවිතා කිරීම දත්ත සමුදාය තහනම් කළෙමු. අපට "+0" තීරුවේ දර්ශකයක් නොමැති අතර එය එයයි, දත්ත සමුදාය දර්ශකය භාවිතා නොකරයි, සියල්ල හොඳයි.
මෙය 6 හි රීතිය පැහැදිලි කරයි. දැන් පවතින සංස්කරණ වල ඔබට බන්ධන විචල්‍ය තිබේ නම් එය 6 වතාවක් කළ යුතුය. ඔබට බන්ධන විචල්‍ය නොමැති නම්, අපි කරන්නේ මෙයයි. අවසානයේ අසාර්ථක වන්නේ මෙම ඉල්ලීමයි. එය කපටි දෙයක් නොවේ.
පෙනෙන විදිහට, කොපමණ කළ හැකිද? මෙහි දෝෂයක්, එහි දෝෂයක්. ඇත්ත වශයෙන්ම, දෝෂය සෑම තැනකම තිබේ.
අපි සමීපව බලමු. උදාහරණයක් ලෙස, අපට යෝජනා ක්රම දෙකක් තිබේ. S වගුව සමඟ A යෝජනා ක්රමය සහ S වගුව සමඟ B රූප සටහන. විමසුම - වගුවකින් දත්ත තෝරන්න. මෙම නඩුවේදී අපට කුමක් සිදුවේද? අපට දෝෂයක් ඇති වේ. ඉහත සියල්ල අපට ලැබෙනු ඇත. රීතිය නම් - දෝෂයක් සෑම තැනකම ඇත, ඉහත සියල්ලම අපට ඇත.
දැන් ප්රශ්නය වන්නේ: "ඇයි?" අපට යෝජනා ක්‍රමයක් තිබේ නම්, මේසය සෙවිය යුත්තේ කොතැනදැයි අපට පවසන "සෙවුම්_මාර්ග" විචල්‍යයක් ඇති බවට ලේඛනගත කර ඇති බව පෙනේ. විචල්‍යයක් ඇති බව පෙනේ.
ප්රශ්නය කුමක් ද? ගැටළුව වන්නේ සේවාදායකය විසින් සකස් කරන ලද ප්රකාශයන් සෙවුම්_මාර්ගය යමෙකුට වෙනස් කළ හැකි බවට සැක නොකිරීමයි. මෙම අගය දත්ත සමුදාය සඳහා නියත ලෙසම පවතී. ඒවගේම සමහර කොටස් වලට අලුත් අරුත් නොගන්න පුළුවන්.
ඇත්ත වශයෙන්ම, මෙය ඔබ පරීක්ෂා කරන අනුවාදය මත රඳා පවතී. ඔබගේ වගු කෙතරම් බරපතල ලෙස වෙනස් වේද යන්න මත රඳා පවතී. 9.1 අනුවාදය පැරණි ඉල්ලීම් සරලව ක්රියාත්මක කරයි. නව අනුවාදයන් දෝෂය අල්ලාගෙන ඔබට දෝෂයක් ඇති බව පැවසිය හැක.
එය ප්රතිකාර කරන්නේ කෙසේද? සරල වට්ටෝරුවක් තිබේ - එය නොකරන්න. යෙදුම ක්රියාත්මක වන අතරතුර search_path වෙනස් කිරීමට අවශ්ය නොවේ. ඔබ වෙනස් කරන්නේ නම්, නව සම්බන්ධතාවයක් නිර්මාණය කිරීම වඩා හොඳය.
ඔබට සාකච්ඡා කළ හැකිය, එනම් විවෘත, සාකච්ඡා, එකතු කරන්න. සමහර විට අපට දත්ත සමුදා සංවර්ධකයින්ට ඒත්තු ගැන්විය හැකිය, යමෙකු අගයක් වෙනස් කරන විට, දත්ත සමුදාය මේ ගැන සේවාදායකයාට පැවසිය යුතුය: “බලන්න, ඔබේ අගය මෙහි යාවත්කාලීන කර ඇත. සමහර විට ඔබට ප්‍රකාශ නැවත සකස් කර ඒවා ප්‍රතිනිර්මාණය කිරීමට අවශ්ය විය හැකිද? දැන් දත්ත ගබඩාව රහසිගතව හැසිරෙන අතර ප්රකාශයන් ඇතුළත කොහේ හෝ වෙනස් වී ඇති බවක් කිසිදු ආකාරයකින් වාර්තා නොකරයි.
මම නැවතත් අවධාරණය කරමි - මෙය ජාවා සඳහා සාමාන්ය නොවන දෙයක්. අපි PL/pgSQL එකින් එක තුල එකම දේ දකිනු ඇත. නමුත් එය එහි ප්රතිනිෂ්පාදනය වනු ඇත.
අපි තවත් දත්ත තෝරා ගැනීමට උත්සාහ කරමු. අපි තෝරාගෙන තෝරා ගනිමු. පේළි මිලියනයක් සහිත මේසයක් අපට තිබේ. සෑම රේඛාවක්ම කිලෝබයිට් වේ. දළ වශයෙන් ගිගාබයිට් දත්තයක්. තවද අපට මෙගාබයිට් 128ක ජාවා යන්ත්‍රයේ ක්‍රියාකාරී මතකයක් ඇත.
අපි, සියලුම පොත්වල නිර්දේශ කර ඇති පරිදි, ප්‍රවාහ සැකසුම් භාවිතා කරන්නෙමු. එනම් අපි resultSet විවෘත කර එහි ඇති දත්ත ටිකෙන් ටික කියවමු. වැඩක් වෙයිද? මතකයෙන් වැටෙයිද? පොඩ්ඩක් කියවනවද? අපි දත්ත සමුදාය විශ්වාස කරමු, Postgres විශ්වාස කරමු. අපි එය විශ්වාස කරන්නේ නැහැ. අපි OutOFMemory වැටෙනවාද? OutOfMemory අත්දැකීම ලැබුවේ කවුද? ඉන් පසු එය නිවැරදි කිරීමට සමත් වූයේ කවුද? කවුරුහරි එය නිවැරදි කිරීමට සමත් විය.
ඔබට පේළි මිලියනයක් තිබේ නම්, ඔබට නිකම්ම තෝරා බේරා ගත නොහැක. OFFSET/LIMIT අවශ්‍යයි. මෙම විකල්පය සඳහා කවුද? සහ autoCommit සමඟ සෙල්ලම් කිරීමට කැමති කවුද?
මෙන්න, සුපුරුදු පරිදි, වඩාත්ම අනපේක්ෂිත විකල්පය නිවැරදි වේ. ඔබ හදිසියේ autoCommit අක්රිය කළහොත්, එය උපකාර වනු ඇත. ඇයි ඒ? විද්‍යාව මේ ගැන දන්නේ නැහැ.
නමුත් පෙරනිමියෙන්, Postgres දත්ත ගබඩාවකට සම්බන්ධ වන සියලුම සේවාලාභීන් සම්පූර්ණ දත්ත ලබා ගනී. PgJDBC මේ සම්බන්ධයෙන් ව්යතිරේකයක් නොවේ; එය සියලු පේළි තෝරා ගනී.
FetchSize තේමාවේ වෙනසක් ඇත, එනම් ඔබට වෙනම ප්‍රකාශයක මට්ටමින් පැවසිය හැක, කරුණාකර මෙහි 10, 50 න් දත්ත තෝරන්න. නමුත් ඔබ autoCommit අක්රිය කරන තුරු මෙය ක්රියා නොකරයි. autoCommit අක්රිය කළා - එය වැඩ කිරීමට පටන් ගනී.
නමුත් කේතය හරහා ගොස් setFetchSize සෑම තැනකම සැකසීම අපහසු වේ. එමනිසා, අපි සම්පූර්ණ සම්බන්ධතාවය සඳහා පෙරනිමි අගය පවසන සැකසුමක් සාදා ඇත.
ඒකයි අපි කිව්වේ. පරාමිතිය වින්‍යාස කර ඇත. සහ අපට ලැබුණේ කුමක්ද? අපි කුඩා ප්‍රමාණ තෝරා ගන්නේ නම්, උදාහරණයක් ලෙස, අපි වරකට පේළි 10 ක් තෝරා ගන්නේ නම්, අපට ඉතා විශාල පොදු කාර්ය පිරිවැයක් ඇත. එබැවින්, මෙම අගය සියයකට පමණ සැකසිය යුතුය.
ඉතා මැනවින්, ඇත්ත වශයෙන්ම, ඔබ තවමත් එය බයිට් වලින් සීමා කරන්නේ කෙසේදැයි ඉගෙන ගත යුතුය, නමුත් වට්ටෝරුව මෙයයි: defaultRowFetchSize සියයකට වඩා සකසා සතුටු වන්න.
අපි දත්ත ඇතුළත් කිරීමට ඉදිරියට යමු. ඇතුළත් කිරීම පහසුය, විවිධ විකල්ප තිබේ. උදාහරණයක් ලෙස, INSERT, VALUES. මෙය හොඳ විකල්පයකි. ඔබට "තෝරන්න ඇතුල් කරන්න" කියන්න පුළුවන්. ප්රායෝගිකව එය එකම දෙයකි. කාර්ය සාධනයේ වෙනසක් නැත.
පොත්වල කියනවා Batch statement එකක් execute කරන්න ඕන කියලා, පොත්වල කියනවා වරහන් කිහිපයක් එක්කම සංකීර්ණ commands ක්රියාත්මක කරන්න පුළුවන් කියලා. තවද Postgres හි අපූරු විශේෂාංගයක් ඇත - ඔබට COPY කළ හැකිය, එනම් එය වේගයෙන් කරන්න.
ඔබ එය මැන බැලුවහොත්, ඔබට නැවතත් රසවත් සොයාගැනීම් කිහිපයක් කළ හැකිය. අපට මෙය ක්රියාත්මක වීමට අවශ්ය වන්නේ කෙසේද? අපට අවශ්ය වන්නේ අනවශ්‍ය විධාන විග්‍රහ නොකිරීමට සහ ක්රියාත්මක නොකිරීමටයි.
ප්රායෝගිකව, TCP අපට මෙය කිරීමට ඉඩ නොදේ. සේවාදායකයා ඉල්ලීමක් යැවීමට කාර්යබහුල නම්, අපට ප්‍රතිචාර යැවීමට උත්සාහ කිරීමේදී දත්ත ගබඩාව ඉල්ලීම් කියවන්නේ නැත. අවසාන ප්‍රති result ලය වන්නේ සේවාදායකයා දත්ත සමුදාය ඉල්ලීම කියවීමට බලා සිටීම සහ දත්ත සමුදාය සේවාදායකයා ප්‍රතිචාරය කියවීමට බලා සිටීමයි.
එබැවින් සේවාදායකයාට වරින් වර සමමුහුර්ත කිරීමේ පැකට්ටුවක් යැවීමට බල කෙරේ. අමතර ජාල අන්තර්ක්‍රියා, අමතර කාලය නාස්ති කිරීම.
අපි ඒවා එකතු කරන තරමට එය නරක අතට හැරේ. රියදුරු තරමක් අශුභවාදී වන අතර රේඛා වල ප්‍රමාණය මත පදනම්ව සෑම පේළි 200 කට වරක්ම ඒවා බොහෝ විට එකතු කරයි.
ඔබ එක් පේළියක් පමණක් නිවැරදි කරන අතර සෑම දෙයක්ම 10 ගුණයකින් වේගවත් වනු ඇත. එය සිදු වේ. ඇයි? වෙනදා වගේම මේ වගේ නියතයක් දැනටමත් කොහේ හරි භාවිතා කරලා තියෙනවා. සහ "128" අගය අදහස් කළේ batching භාවිතා නොකිරීමයි.
මේක Official Version එකට ඇතුලත් නොකරපු එක හොදයි. මුදා හැරීම ආරම්භ වීමට පෙර සොයා ගන්නා ලදී. මම ලබා දෙන සියලුම අර්ථයන් නවීන අනුවාදයන් මත පදනම් වේ.
අපි එය උත්සාහ කරමු. අපි InsertBatch සරලව මනිමු. අපි InsertBatch කිහිප වතාවක් මනිමු, එනම් එකම දෙය, නමුත් බොහෝ අගයන් ඇත. කපටි චලනය. සෑම කෙනෙකුටම මෙය කළ නොහැක, නමුත් එය එතරම් සරල පියවරක්, පිටපත් කිරීමට වඩා පහසුය.
ඔබට COPY කරන්න පුළුවන්.
තවද ඔබට මෙය ව්යුහයන් මත කළ හැකිය. පරිශීලක පෙරනිමි වර්ගය ප්‍රකාශ කරන්න, අරාව සමත් කර කෙලින්ම වගුවට ඇතුළු කරන්න.
ඔබ සබැඳිය විවෘත කරන්නේ නම්: pgjdbc/ubenchmsrk/InsertBatch.java, එවිට මෙම කේතය GitHub මත ඇත. එහිදී ජනනය වන ඉල්ලීම් මොනවාදැයි ඔබට විශේෂයෙන් දැක ගත හැකිය. කමක් නැහැ.
අපි දියත් කළා. අපි තේරුම් ගත් පළමු දෙය නම් කණ්ඩායම භාවිතා නොකිරීම සරලවම කළ නොහැකි බවයි. සියලුම කණ්ඩායම් විකල්ප ශුන්‍ය වේ, එනම් ක්රියාත්මක කිරීමේ කාලය එක් වරක් ක්රියාත්මක කිරීමකට සාපේක්ෂව ප්රායෝගිකව ශුන්‍ය වේ.
අපි දත්ත ඇතුල් කරන්නෙමු. එය ඉතා සරල වගුවකි. තීරු තුනක්. තවද අප මෙහි දකින්නේ කුමක්ද? මෙම විකල්ප තුනම දළ වශයෙන් සැසඳිය හැකි බව අපට පෙනේ. සහ පිටපත, ඇත්තෙන්ම, වඩා හොඳය.
අපි කෑලි ඇතුල් කරන විට මෙයයි. අපි එක VALUES අගයක්, VALUES අගයන් දෙකක්, VALUES අගයන් තුනක් හෝ අපි ඒවායින් 10ක් කොමාවකින් වෙන් කළ බව පැවසුවෙමු. මේක දැන් තිරස් අතට විතරයි. 1, 2, 4, 128. නිල් පාටින් අඳින ලද Batch Insert එක ඔහුට හොඳටම දැනෙන බව පේනවා. එනම්, ඔබ වරකට එකක් ඇතුළු කරන විට හෝ ඔබ වරකට හතරක් ඇතුළු කරන විට පවා, එය දෙගුණයක් හොඳ වේ, හුදෙක් අපි තව ටිකක් VALUES තුළට තද කළ නිසා. අඩු EXECUTE මෙහෙයුම්.
කුඩා වෙළුම් මත COPY භාවිතා කිරීම අතිශයින්ම අසමසමයි. මම මුල් දෙකේ චිත්‍ර ඇන්දෙත් නැහැ. ඔවුන් ස්වර්ගයට යනවා, එනම්, COPY සඳහා මෙම හරිත අංක.
ඔබට අවම වශයෙන් දත්ත පේළි සියයක් ඇති විට COPY භාවිතා කළ යුතුය. මෙම සම්බන්ධතාවය විවෘත කිරීමේ උඩිස් මුදල විශාලයි. ඒ වගේම, ඇත්තම කිව්වොත්, මම මේ දිශාවට කැණීම් කළේ නැහැ. මම Batch ප්‍රශස්ත කළා, නමුත් COPY නොවේ.
අපි ඊළඟට කරන්නේ කුමක්ද? අපි එය උත්සාහ කළා. අප විසින් ව්යුහයන් හෝ අර්ථ කිහිපයක් ඒකාබද්ධ කරන දක්ෂ බක්තයක් භාවිතා කළ යුතු බව අපට වැටහේ.
අද වාර්තාවෙන් ඔබ ඉවත් කළ යුත්තේ කුමක්ද?
- සූදානම් ප්රකාශය අපගේ සෑම දෙයක්ම වේ. මෙය ඵලදායිතාව සඳහා බොහෝ දේ ලබා දෙයි. එය විලවුන් තුළ විශාල flop නිෂ්පාදනය කරයි.
- ඒවගේම EXPLAIN ANALYZE 6 පාරක් කරන්න ඕන.
- තවද අපගේ ගැටළුකාරී විමසුම්වල ඉතිරි ප්‍රතිශතය නිවැරදි කිරීම සඳහා අපි OFFSET 0 තනුක කළ යුතු අතර +0 වැනි උපක්‍රම
මූලාශ්රය: www.habr.com