Redis Stream යනු 5.0 අනුවාදය සමඟ Redis හි හඳුන්වා දුන් නව වියුක්ත දත්ත වර්ගයකි
සංකල්පමය වශයෙන්, Redis Stream යනු ඔබට ඇතුළත් කිරීම් එකතු කළ හැකි ලැයිස්තුවකි. සෑම ප්‍රවේශයකටම අනන්‍ය හඳුනාගැනීමක් ඇත. පෙරනිමියෙන්, හැඳුනුම්පත ස්වයංක්‍රීයව ජනනය වන අතර වේලා මුද්‍රාවක් ඇතුළත් වේ. එමනිසා, ඔබට කාලයත් සමඟ වාර්තා පරාසයන් විමසිය හැකිය, නැතහොත් එය ප්‍රවාහයට පැමිණෙන විට නව දත්ත ලබා ගත හැකිය, බොහෝ දුරට Unix "tail -f" විධානය ලොග් ගොනුවක් කියවා නව දත්ත සඳහා රැඳී සිටින විට කැටි වේ. "tail -f" ක්‍රියාවලි බොහොමයකට එකිනෙක ගැටීමෙන් තොරව ගොනුවක් එකවර කියවිය හැකි සේම, බොහෝ සේවාලාභීන්ට ත්‍රෙඩ් එකකට එකවර සවන් දිය හැකි බව සලකන්න.
නව දත්ත වර්ගයෙහි සියලු ප්‍රතිලාභ අවබෝධ කර ගැනීම සඳහා, Redis Stream හි ක්‍රියාකාරීත්වය අර්ධ වශයෙන් ප්‍රතිනිර්මාණය කරන දිගුකාලීන Redis ව්‍යුහයන් දෙස ඉක්මනින් බලමු.
Redis PUB/SUB
Redis Pub/Sub යනු ඔබේ ප්රධාන වටිනාකම් ගබඩාව තුළ දැනටමත් ගොඩනගා ඇති සරල පණිවිඩකරණ පද්ධතියකි. කෙසේ වෙතත්, සරල බව මිලකට පැමිණේ:
- කිසියම් හේතුවක් නිසා ප්‍රකාශකයා අසමත් වුවහොත්, ඔහුට ඔහුගේ සියලුම ග්‍රාහකයින් අහිමි වේ
- ප්‍රකාශකයාට එහි සියලුම ග්‍රාහකයින්ගේ නිවැරදි ලිපිනය දැනගත යුතුය
- දත්ත සැකසීමට වඩා වේගයෙන් ප්‍රකාශනය කරන්නේ නම් ප්‍රකාශකයෙකුට එහි ග්‍රාහකයින් වැඩ අධික විය හැක
- පණිවිඩය ප්‍රකාශනය කළ වහාම ප්‍රකාශකයාගේ බෆරයෙන් මකා දමනු ලැබේ, එය කොපමණ ග්‍රාහකයින් වෙත ලබා දුන්නේද සහ ඔවුන්ට මෙම පණිවිඩය සැකසීමට කෙතරම් ඉක්මනින් හැකි වූයේද යන්න නොසලකා.
- සියලුම ග්‍රාහකයින්ට එම අවස්ථාවේදීම පණිවිඩය ලැබෙනු ඇත. එකම පණිවිඩය සැකසීමේ අනුපිළිවෙල පිළිබඳව ග්‍රාහකයින් විසින්ම කෙසේ හෝ එකඟ විය යුතුය.
- ග්‍රාහකයෙකු පණිවිඩයක් සාර්ථකව සකසන ලද බව තහවුරු කිරීමට ඇති යාන්ත්‍රණයක් නොමැත. ග්‍රාහකයෙකුට පණිවිඩයක් ලැබී සැකසීමේදී බිඳ වැටුනහොත්, ප්‍රකාශකයා ඒ ගැන නොදනී.
රෙඩිස් ලැයිස්තුව
Redis List යනු කියවීමේ විධාන අවහිර කිරීමට සහාය වන දත්ත ව්‍යුහයකි. ඔබට ලැයිස්තුවේ ආරම්භයේ හෝ අවසානයේ සිට පණිවිඩ එක් කිරීමට සහ කියවීමට හැකිය. මෙම ව්යුහය මත පදනම්ව, ඔබේ බෙදා හරින ලද පද්ධතිය සඳහා හොඳ තොගයක් හෝ පෝලිමක් සෑදිය හැකි අතර, බොහෝ අවස්ථාවලදී මෙය ප්රමාණවත් වනු ඇත. Redis Pub/Sub වෙතින් ප්රධාන වෙනස්කම්:
- පණිවිඩය එක් සේවාදායකයෙකුට භාර දෙනු ලැබේ. පළමු කියවීම අවහිර කරන ලද සේවාලාභියාට පළමුව දත්ත ලැබෙනු ඇත.
- ක්ලින්ට් විසින්ම සෑම පණිවිඩයක් සඳහාම කියවීමේ මෙහෙයුම ආරම්භ කළ යුතුය. ලැයිස්තුව ගනුදෙනුකරුවන් ගැන කිසිවක් දන්නේ නැත.
- යමෙකු ඒවා කියවන තුරු හෝ පැහැදිලිව මකා දමන තුරු පණිවිඩ ගබඩා කෙරේ. ඔබ Redis සේවාදායකය තැටියට දත්ත ෆ්ලෂ් කිරීමට වින්‍යාස කරන්නේ නම්, පද්ධතියේ විශ්වසනීයත්වය නාටකාකාර ලෙස වැඩි වේ.
ප්‍රවාහයට හැඳින්වීම
ප්‍රවාහයකට ප්‍රවේශයක් එක් කිරීම
කණ්ඩායම XADD ප්‍රවාහයට නව ප්‍රවේශයක් එක් කරයි. වාර්තාවක් යනු තන්තුවක් පමණක් නොවේ, එය යතුරු අගය යුගල එකකින් හෝ වැඩි ගණනකින් සමන්විත වේ. මේ අනුව, සෑම ප්‍රවේශයක්ම දැනටමත් ව්‍යුහගත කර ඇති අතර CSV ගොනුවක ව්‍යුහයට සමාන වේ.
> XADD mystream * sensor-id 1234 temperature 19.8
1518951480106-0
ඉහත උදාහරණයේ, අපි ප්‍රවාහයට ක්ෂේත්‍ර දෙකක් එකතු කරමු (යතුර) “mystream”: “sensor-id” සහ “උෂ්ණත්වය” පිළිවෙලින් “1234” සහ “19.8” අගයන් සමඟ. දෙවන තර්කය ලෙස, විධානය ප්‍රවේශයට පවරනු ලබන හඳුනාගැනීමක් ගනී - මෙම හඳුනාගැනීම ප්රවාහයේ එක් එක් ප්‍රවේශය අනන්‍ය ලෙස හඳුනා ගනී. කෙසේ වෙතත්, මෙම අවස්ථාවෙහිදී අපි * සමත් වූයේ අපට Redis සඳහා නව හැඳුනුම්පතක් ජනනය කිරීමට අවශ්ය බැවිනි. සෑම නව හැඳුනුම්පතක්ම වැඩි වනු ඇත. එබැවින්, සෑම නව ප්‍රවේශයකටම පෙර ඇතුළත් කිරීම්වලට සාපේක්ෂව ඉහළ හඳුනාගැනීමක් ඇත.
හඳුනාගැනීමේ ආකෘතිය
ඇතුල්වීමේ හැඳුනුම්පත විධානය මඟින් ආපසු එවන ලදී XADD, කොටස් දෙකකින් සමන්විත වේ:
{millisecondsTime}-{sequenceNumber}
මිලි තත්පර කාලය — Unix කාලය මිලි තත්පර වලින් (Redis සේවාදායක කාලය). කෙසේ වෙතත්, වත්මන් වේලාව පෙර පටිගත කළ වේලාවට සමාන හෝ අඩු නම්, පෙර පටිගත කිරීමේ කාල මුද්‍රාව භාවිතා වේ. එබැවින්, සේවාදායක කාලය නියමිත වේලාවට ආපසු ගියහොත්, නව හඳුනාගැනීම් වර්ධක දේපල තවමත් රඳවා ගනු ඇත.
අනුපිළිවෙල අංකය එකම මිලි තත්පරයක සාදන ලද වාර්තා සඳහා භාවිතා වේ. අනුපිළිවෙල අංකය පෙර ප්‍රවේශයට සාපේක්ෂව 1 කින් වැඩි වනු ඇත. මන්දයත් අනුපිළිවෙල අංකය ප්‍රමාණය බිටු 64කි, එවිට ප්‍රායෝගිකව ඔබ මිලි තත්පරයක් තුළ ජනනය කළ හැකි වාර්තා සංඛ්‍යාවේ සීමාවකට නොපැමිණිය යුතුය.
එවැනි හඳුනාගැනීම් වල ආකෘතිය මුලින්ම බැලූ බැල්මට අමුතු විය හැකිය. කාලය හඳුනාගැනීමේ කොටසක් වන්නේ මන්දැයි අවිශ්වාසවන්ත පාඨකයෙකු කල්පනා කළ හැකිය. හේතුව Redis ප්‍රවාහ ID මගින් පරාස විමසුම් සඳහා සහය වීමයි. හඳුනාගැනීම වාර්තාව නිර්මාණය කළ කාලය සමඟ සම්බන්ධ වී ඇති බැවින්, මෙය කාල පරාසයන් විමසීමට හැකි වේ. අපි විධානය දෙස බලන විට අපි නිශ්චිත උදාහරණයක් දෙස බලමු XRANGE.
කිසියම් හේතුවක් නිසා පරිශීලකයාට ඔහුගේම හඳුනාගැනීමක් නියම කිරීමට අවශ්ය නම්, උදාහරණයක් ලෙස, යම් බාහිර පද්ධතියක් සමඟ සම්බන්ධ වී ඇත, එවිට අපට එය විධානයට ලබා දිය හැකිය. XADD පහත දැක්වෙන පරිදි * වෙනුවට:
> XADD somestream 0-1 field value
0-1
> XADD somestream 0-2 foo bar
0-2
මෙම අවස්ථාවෙහිදී ඔබ විසින්ම ID වර්ධකය නිරීක්ෂණය කළ යුතු බව කරුණාවෙන් සලකන්න. අපගේ උදාහරණයේ, අවම හඳුනාගැනීම "0-1" වේ, එබැවින් විධානය "0-1" ට සමාන හෝ අඩු වෙනත් හඳුනාගැනීමක් පිළි නොගනී.
> XADD somestream 0-1 foo bar
(error) ERR The ID specified in XADD is equal or smaller than the target stream top item
ප්‍රවාහයකට වාර්තා ගණන
විධානය භාවිතා කිරීමෙන් ප්‍රවාහයක ඇති වාර්තා ගණන ලබා ගත හැකිය XLEN. අපගේ උදාහරණය සඳහා, මෙම විධානය පහත අගය ලබා දෙනු ඇත:
> XLEN somestream
(integer) 2
පරාස විමසුම් - XRANGE සහ XREVRANGE
පරාසය අනුව දත්ත ඉල්ලීමට, අපි හඳුනාගැනීම් දෙකක් සඳහන් කළ යුතුය - පරාසයේ ආරම්භය සහ අවසානය. ආපසු ලබා දුන් පරාසයට මායිම් ඇතුළුව සියලුම අංග ඇතුළත් වේ. ප්රවාහයේ ඇති කුඩාම (පළමු වාර්තාව) සහ විශාලතම (අවසාන වාර්තාව) හඳුනාගැනීමේ අර්ථය පිළිවෙළින් “-” සහ “+” විශේෂ හඳුනාගැනීම් දෙකක් ද ඇත. පහත උදාහරණය සියලුම ප්‍රවාහ ඇතුළත් කිරීම් ලැයිස්තුගත කරනු ඇත.
> XRANGE mystream - +
1) 1) 1518951480106-0
2) 1) "sensor-id"
2) "1234"
3) "temperature"
4) "19.8"
2) 1) 1518951482479-0
2) 1) "sensor-id"
2) "9999"
3) "temperature"
4) "18.2"
ආපසු ලබා දුන් සෑම වාර්තාවක්ම මූලද්රව්ය දෙකක අරාවකි: හඳුනාගැනීමක් සහ යතුරු-අගය යුගල ලැයිස්තුවක්. වාර්තා හඳුනාගැනීම් කාලයට සම්බන්ධ බව අපි දැනටමත් පවසා ඇත. එබැවින්, අපට නිශ්චිත කාල පරාසයක් ඉල්ලා සිටිය හැක. කෙසේ වෙතත්, අපට ඉල්ලීමෙහි සඳහන් කළ හැක්කේ සම්පූර්ණ හැඳුනුම්කාරකය නොව, යුනික්ස් වේලාව පමණක්, අදාළ කොටස මග හරිමිනි. අනුපිළිවෙල අංකය. හඳුනාගැනීමේ අත්හැර දැමූ කොටස පරාසයේ ආරම්භයේ ශුන්‍යයට සහ පරාසය අවසානයේ හැකි උපරිම අගයට ස්වයංක්‍රීයව සකසනු ඇත. ඔබට මිලි තත්පර දෙකක පරාසයක් ඉල්ලා සිටිය හැකි ආකාරය පිළිබඳ උදාහරණයක් පහත දැක්වේ.
> XRANGE mystream 1518951480106 1518951480107
1) 1) 1518951480106-0
2) 1) "sensor-id"
2) "1234"
3) "temperature"
4) "19.8"
අපට මෙම පරාසය තුළ ඇත්තේ එක් ප්‍රවේශයක් පමණි, කෙසේ වෙතත් සැබෑ දත්ත කට්ටලවල ආපසු ලබා දෙන ප්‍රතිඵලය විශාල විය හැක. මේ හේතුව නිසා XRANGE COUNT විකල්පයට සහය දක්වයි. ප්‍රමාණය නියම කිරීමෙන්, අපට සරලව පළමු N වාර්තා ලබා ගත හැක. අපට ඊළඟ N වාර්තා (pagination) ලබා ගැනීමට අවශ්ය නම්, අපට අවසන් වරට ලැබුණු හැඳුනුම්පත භාවිතා කළ හැකිය, එය වැඩි කරන්න අනුපිළිවෙල අංකය එකකින් සහ නැවත අසන්න. පහත උදාහරණයෙන් මෙය බලමු. අපි සමඟ මූලද්රව්ය 10 ක් එකතු කිරීමට පටන් ගනිමු XADD (මෛස්ට්‍රීම් දැනටමත් මූලද්රව්ය 10 කින් පිරී ඇතැයි උපකල්පනය කරයි). විධානයකට මූලද්රව්ය 2ක් ලබා ගැනීම ආරම්භ කිරීම සඳහා, අපි සම්පූර්ණ පරාසයෙන් ආරම්භ කරන නමුත් 2 ට සමාන COUNT කින් ආරම්භ කරමු.
> XRANGE mystream - + COUNT 2
1) 1) 1519073278252-0
2) 1) "foo"
2) "value_1"
2) 1) 1519073279157-0
2) 1) "foo"
2) "value_2"
මීළඟ මූලද්රව්ය දෙක සමඟින් පුනරාවර්තනය දිගටම කරගෙන යාමට, අපට ලැබුණු අවසන් හැඳුනුම්පත, එනම් 1519073279157-0 තෝරාගෙන, 1 වෙත එක් කිරීමට අවශ්ය වේ. අනුපිළිවෙල අංකය.
ප්‍රතිඵලයක් ලෙස ලැබෙන ID, මෙම අවස්ථාවෙහි 1519073279157-1, දැන් ඊළඟ ඇමතුම සඳහා පරාස තර්කයේ නව ආරම්භය ලෙස භාවිත කළ හැක. XRANGE:
> XRANGE mystream 1519073279157-1 + COUNT 2
1) 1) 1519073280281-0
2) 1) "foo"
2) "value_3"
2) 1) 1519073281432-0
2) 1) "foo"
2) "value_4"
සහ යනාදි. සංකීර්ණත්වය නිසා XRANGE සෙවීමට O(log(N)) වන අතර M මූලද්රව්ය ලබා දීමට O(M) වේ, එවිට එක් එක් පුනරාවර්තන පියවර වේගවත් වේ. මේ අනුව, භාවිතා කිරීම XRANGE ධාරාවන් කාර්යක්ෂමව පුනරාවර්තනය කළ හැකිය.
කණ්ඩායම XREVRANGE සමාන වේ XRANGE, නමුත් මූලද්රව්ය ප්‍රතිලෝම අනුපිළිවෙලට ලබා දෙයි:
> XREVRANGE mystream + - COUNT 1
1) 1) 1519073287312-0
2) 1) "foo"
2) "value_10"
විධානය බව කරුණාවෙන් සලකන්න XREVRANGE පරාස තර්ක ආරම්භය සහ නැවතීම ප්‍රතිලෝම අනුපිළිවෙලට ගනී.
XREAD භාවිතයෙන් නව ඇතුළත් කිරීම් කියවීම
බොහෝ විට කාර්යය පැන නගින්නේ ප්‍රවාහයකට දායක වීම සහ නව පණිවිඩ පමණක් ලබා ගැනීමයි. මෙම සංකල්පය Redis Pub/Sub හෝ Redis List අවහිර කිරීම හා සමාන බවක් පෙනෙන්නට ඇත, නමුත් Redis Stream භාවිතා කරන ආකාරය සම්බන්ධයෙන් මූලික වෙනස්කම් තිබේ:
- සෑම නව පණිවිඩයක්ම පෙරනිමියෙන් සෑම ග්‍රාහකයෙකුටම බෙදා හරිනු ලැබේ. මෙම හැසිරීම අවහිර කරන Redis ලැයිස්තුවකට වඩා වෙනස් වේ, නව පණිවිඩයක් කියවිය හැක්කේ එක් ග්‍රාහකයෙකු විසින් පමණි.
- Redis Pub/Sub හි සියලුම පණිවිඩ අමතක වී ඇති අතර කිසිදා නොපවතින අතර, Stream හි සියලුම පණිවිඩ දින නියමයක් නොමැතිව රඳවා ගනු ලැබේ (සේවාදායකයා පැහැදිලිව මකාදැමීමට හේතු නොවේ නම්).
- එක් ප්‍රවාහයක් තුළ පණිවිඩ වෙත ප්‍රවේශය වෙනස් කිරීමට Redis Stream ඔබට ඉඩ සලසයි. නිශ්චිත ග්‍රාහකයෙකුට බැලිය හැක්කේ ඔවුන්ගේ පුද්ගලික පණිවිඩ ඉතිහාසය පමණි.
ඔබට ත්‍රෙඩ් එකකට දායක වී විධානය භාවිතයෙන් නව පණිවිඩ ලබා ගත හැකිය XREAD. වඩා ටිකක් සංකීර්ණයි XRANGE, ඒ නිසා අපි මුලින්ම සරල උදාහරණ වලින් පටන් ගනිමු.
> XREAD COUNT 2 STREAMS mystream 0
1) 1) "mystream"
2) 1) 1) 1519073278252-0
2) 1) "foo"
2) "value_1"
2) 1) 1519073279157-0
2) 1) "foo"
2) "value_2"
ඉහත උදාහරණය අවහිර නොවන පෝරමයක් පෙන්වයි XREAD. COUNT විකල්පය විකල්ප නොවන බව සලකන්න. ඇත්ත වශයෙන්ම, අවශ්ය එකම විධාන විකල්පය වන්නේ STREAMS විකල්පයයි, එය අනුරූප උපරිම හඳුනාගැනීම් සමඟ ප්‍රවාහ ලැයිස්තුවක් නියම කරයි. අපි "STREAMS mystream 0" ලිව්වා - අපට mystream ප්රවාහයේ සියලුම වාර්තා "0-0" ට වඩා වැඩි හඳුනාගැනීමක් සමඟ ලබා ගැනීමට අවශ්‍යයි. ඔබට උදාහරණයෙන් පෙනෙන පරිදි, විධානය මඟින් ත්‍රෙඩ් එකේ නම නැවත ලබා දෙන්නේ අපට එකවර නූල් කිහිපයකට දායක විය හැකි බැවිනි. අපට ලිවිය හැක, උදාහරණයක් ලෙස, "STREAMS mystream otherstream 0 0". STREAMS විකල්පයෙන් පසුව අපි මුලින්ම අවශ්ය සියලුම ප්‍රවාහවල නම් සැපයිය යුතු අතර පසුව පමණක් හඳුනාගැනීම් ලැයිස්තුවක් ලබා දිය යුතු බව කරුණාවෙන් සලකන්න.
මෙම සරල ස්වරූපයෙන් විධානය හා සසඳන විට විශේෂ කිසිවක් නොකරයි XRANGE. කෙසේ වෙතත්, සිත්ගන්නා කරුණ නම් අපට පහසුවෙන් හැරවිය හැකිය XREAD BLOCK තර්කය සඳහන් කරමින් අවහිර කිරීමේ විධානයකට:
> XREAD BLOCK 0 STREAMS mystream $
ඉහත උදාහරණයේ, නව BLOCK විකල්පය මිලි තත්පර 0 ක කාල සීමාවක් සහිතව නියම කර ඇත (මෙයින් අදහස් වන්නේ දින නියමයක් නොමැතිව රැඳී සිටීමයි). එපමනක් නොව, stream mystream සඳහා සුපුරුදු හැඳුනුම්කාරකය පසු කිරීම වෙනුවට, විශේෂ හඳුනාගැනීමක් $ සම්මත කරන ලදී. මෙම විශේෂ හඳුනාගැනීමේ තේරුම එයයි XREAD හැඳුනුම්කාරකය ලෙස mystream හි උපරිම හඳුනාගැනීම භාවිතා කළ යුතුය. එබැවින් අපට නව පණිවිඩ ලැබෙන්නේ අප සවන් දීමට පටන් ගත් මොහොතේ සිට පමණි. සමහර ආකාරවලින් මෙය Unix "tail -f" විධානයට සමාන වේ.
BLOCK විකල්පය භාවිතා කරන විට අපට විශේෂ හැඳුනුම්කාරකය $ භාවිතා කිරීමට අවශ්ය නොවන බව සලකන්න. අපට ප්රවාහයේ පවතින ඕනෑම හඳුනාගැනීමක් භාවිතා කළ හැක. කණ්ඩායමට අපගේ ඉල්ලීම අවහිර නොකර වහාම සේවය කළ හැකි නම්, එය එසේ කරනු ඇත, එසේ නොමැතිනම් එය අවහිර කරනු ඇත.
අවහිර කිරීම XREAD ඔබට එකවර නූල් කිහිපයකට සවන් දිය හැකිය, ඔබට ඔවුන්ගේ නම් සඳහන් කිරීමට අවශ්ය වේ. මෙම අවස්ථාවේදී, විධානය දත්ත ලැබුණු පළමු ප්රවාහයේ වාර්තාවක් ලබා දෙනු ඇත. දී ඇති ප්‍රවාහයක් සඳහා අවහිර කළ පළමු ග්‍රාහකයාට පළමුව දත්ත ලැබෙනු ඇත.
පාරිභෝගික කණ්ඩායම්
ඇතැම් කාර්යයන් වලදී, අපට එක් නූලක් තුළ පණිවිඩ සඳහා ග්‍රාහක ප්‍රවේශය සීමා කිරීමට අවශ්‍යය. මෙය ප්රයෝජනවත් විය හැකි උදාහරණයක් නම්, ත්‍රෙඩ් එකකින් විවිධ පණිවිඩ ලැබෙන, පණිවිඩ සැකසීමට පරිමාණයට ඉඩ සලසන සේවකයින් සමඟ පණිවිඩ පෝලිමකි.
අප සතුව C1, C2, C3 ග්‍රාහකයින් තිදෙනෙකු සහ 1, 2, 3, 4, 5, 6, 7 යන පණිවිඩ අඩංගු නූල් එකක් ඇතැයි අපි සිතන්නේ නම්, පහත රූප සටහනේ පරිදි පණිවිඩ ලබා දෙනු ඇත:
1 -> C1
2 -> C2
3 -> C3
4 -> C1
5 -> C2
6 -> C3
7 -> C1
මෙම බලපෑම සාක්ෂාත් කර ගැනීම සඳහා, Redis Stream Consumer Group නම් සංකල්පයක් භාවිතා කරයි. මෙම සංකල්පය ව්‍යාජ ග්‍රාහකයෙකුට සමාන වන අතර එය ප්‍රවාහයකින් දත්ත ලබා ගනී, නමුත් ඇත්ත වශයෙන්ම කණ්ඩායමක් තුළ බහු ග්‍රාහකයින් විසින් සපයනු ලබන අතර, යම් සහතික කිරීම් සපයයි:
- සෑම පණිවිඩයක්ම සමූහය තුළ සිටින වෙනත් ග්‍රාහකයෙකු වෙත භාර දෙනු ලැබේ.
- කණ්ඩායමක් තුළ, ග්‍රාහකයින් ඔවුන්ගේ නමින් හඳුනා ගැනේ, එය සිද්ධි සංවේදී තන්තුවකි. ග්‍රාහකයෙකු කණ්ඩායමෙන් තාවකාලිකව ඉවත් වුවහොත්, ඔහුට ඔහුගේම අනන්‍ය නම භාවිතා කර කණ්ඩායමට ප්‍රතිසාධනය කළ හැක.
- සෑම පාරිභෝගික කණ්ඩායමක්ම "පළමු නොකියවූ පණිවිඩය" සංකල්පය අනුගමනය කරයි. ග්‍රාහකයෙකු නව පණිවිඩ ඉල්ලා සිටින විට, එයට ලැබිය හැක්කේ සමූහය තුළ සිටින කිසිදු ග්‍රාහකයෙකුට මින් පෙර ලබා නොදුන් පණිවිඩ පමණි.
- පණිවිඩය ග්රාහකයා විසින් සාර්ථකව සකසන ලද බව පැහැදිලිව තහවුරු කිරීමට විධානයක් ඇත. මෙම විධානය අමතන තුරු, ඉල්ලා සිටින පණිවිඩය "පොරොත්තු" තත්වයේ පවතිනු ඇත.
- පාරිභෝගික කණ්ඩායම තුළ, සෑම ග්‍රාහකයෙකුටම තමා වෙත ලබා දුන්, නමුත් තවමත් ක්‍රියාවට නංවා නොමැති පණිවිඩවල ඉතිහාසයක් ඉල්ලා සිටිය හැක ("පොරොත්තු" තත්වයේ)
එක් අර්ථයකින්, කණ්ඩායමේ තත්වය පහත පරිදි ප්රකාශ කළ හැකිය:
+----------------------------------------+
| consumer_group_name: mygroup
| consumer_group_stream: somekey
| last_delivered_id: 1292309234234-92
|
| consumers:
| "consumer-1" with pending messages
| 1292309234234-4
| 1292309234232-8
| "consumer-42" with pending messages
| ... (and so forth)
+----------------------------------------+
දැන් පාරිභෝගික කණ්ඩායම සඳහා වන ප්රධාන විධානයන් පිළිබඳව දැන හඳුනා ගැනීමට කාලයයි, එනම්:
- XGROUP කණ්ඩායම් නිර්මාණය කිරීමට, විනාශ කිරීමට සහ කළමනාකරණය කිරීමට භාවිතා කරයි
- XREADGROUP සමූහය හරහා ප්‍රවාහය කියවීමට භාවිතා කරයි
- XACK - මෙම විධානය ග්‍රාහකයාට පණිවිඩය සාර්ථකව සැකසූ ලෙස සලකුණු කිරීමට ඉඩ සලසයි
පාරිභෝගික කණ්ඩායමක් නිර්මාණය කිරීම
අපි හිතමු mystream දැනටමත් පවතිනවා කියලා. එවිට කණ්ඩායම් නිර්මාණය කිරීමේ විධානය පෙනෙන්නේ:
> XGROUP CREATE mystream mygroup $
OK
කණ්ඩායමක් නිර්මාණය කිරීමේදී, අපි හඳුනාගැනීමක් සමත් විය යුතු අතර, කණ්ඩායමට පණිවිඩ ලැබෙනු ඇත. අපට සියලුම නව පණිවිඩ ලබා ගැනීමට අවශ්ය නම්, අපට විශේෂ හැඳුනුම්කාරකය භාවිතා කළ හැකිය $ (අපගේ ඉහත උදාහරණයේ මෙන්). ඔබ විශේෂ හැඳුනුම්කාරකයක් වෙනුවට 0 සඳහන් කළහොත්, ත්‍රෙඩ් එකේ ඇති සියලුම පණිවිඩ සමූහයට ලබා ගත හැකිය.
දැන් කණ්ඩායම නිර්මාණය කර ඇති අතර, අපට වහාම විධානය භාවිතයෙන් පණිවිඩ කියවීම ආරම්භ කළ හැකිය XREADGROUP. මෙම විධානය බොහෝ දුරට සමාන වේ XREAD සහ විකල්ප BLOCK විකල්පය සඳහා සහය දක්වයි. කෙසේ වෙතත්, අවශ්ය GROUP විකල්පයක් ඇත, එය සෑම විටම තර්ක දෙකක් සමඟ සඳහන් කළ යුතුය: කණ්ඩායම් නම සහ ග්‍රාහකයාගේ නම. COUNT විකල්පය ද සහය දක්වයි.
ත්‍රෙඩ් එක කියවීමට පෙර, අපි එහි පණිවිඩ කිහිපයක් දමමු:
> XADD mystream * message apple
1526569495631-0
> XADD mystream * message orange
1526569498055-0
> XADD mystream * message strawberry
1526569506935-0
> XADD mystream * message apricot
1526569535168-0
> XADD mystream * message banana
1526569544280-0
දැන් අපි මෙම ප්‍රවාහය සමූහය හරහා කියවීමට උත්සාහ කරමු:
> XREADGROUP GROUP mygroup Alice COUNT 1 STREAMS mystream >
1) 1) "mystream"
2) 1) 1) 1526569495631-0
2) 1) "message"
2) "apple"
ඉහත විධානය පහත පරිදි වාචිකව කියවයි:
"මගේ සමූහයේ සාමාජිකයෙකු වන මට ග්‍රාහක ඇලිස්, මීට පෙර කිසිවකුට ලබා නොදුන් mystream වෙතින් එක් පණිවිඩයක් කියවීමට අවශ්‍යයි."
ග්‍රාහකයෙකු කණ්ඩායමක් මත මෙහෙයුමක් සිදු කරන සෑම අවස්ථාවකම, එය කණ්ඩායම තුළ අනන්‍ය ලෙස හඳුනා ගනිමින් එහි නම සැපයිය යුතුය. ඉහත විධානයේ තවත් ඉතා වැදගත් විස්තරයක් ඇත - විශේෂ හඳුනාගැනීම ">". මෙම විශේෂ හැඳුනුම්කාරකය පණිවිඩ පෙරහන් කරයි, පෙර කිසි දිනෙක බෙදා නොදුන් ඒවා පමණක් ඉතිරි කරයි.
එසේම, විශේෂ අවස්ථා වලදී, ඔබට 0 හෝ වෙනත් වලංගු හඳුනාගැනීමක් වැනි සැබෑ හඳුනාගැනීමක් නියම කළ හැක. මෙම අවස්ථාවේදී, විධානය XREADGROUP නිශ්චිත ග්‍රාහකයාට (ඇලිස්) භාර දුන් නමුත් විධානය භාවිතයෙන් තවමත් පිළිගෙන නොමැති "පොරොත්තු" තත්ත්වය සහිත පණිවිඩ ඉතිහාසයක් ඔබට ලබා දෙනු ඇත. XACK.
විකල්පය නොමැතිව ID 0 වහාම සඳහන් කිරීමෙන් අපට මෙම හැසිරීම පරීක්ෂා කළ හැක COUNT. අපි හුදෙක් තනි පොරොත්තු පණිවිඩයක් දකිනු ඇත, එනම් ඇපල් පණිවිඩය:
> XREADGROUP GROUP mygroup Alice STREAMS mystream 0
1) 1) "mystream"
2) 1) 1) 1526569495631-0
2) 1) "message"
2) "apple"
කෙසේ වෙතත්, අපි පණිවිඩය සාර්ථකව සකසන ලද බව තහවුරු කළහොත්, එය තවදුරටත් දර්ශනය නොවේ:
> XACK mystream mygroup 1526569495631-0
(integer) 1
> XREADGROUP GROUP mygroup Alice STREAMS mystream 0
1) 1) "mystream"
2) (empty list or set)
දැන් යමක් කියවීමට බොබ්ගේ වාරයයි.
> XREADGROUP GROUP mygroup Bob COUNT 2 STREAMS mystream >
1) 1) "mystream"
2) 1) 1) 1526569498055-0
2) 1) "message"
2) "orange"
2) 1) 1526569506935-0
2) 1) "message"
2) "strawberry"
mygroup හි සාමාජිකයෙකු වන Bob, පණිවිඩ දෙකකට වඩා ඉල්ලා සිටියේ නැත. ">" විශේෂ හැඳුනුම්කාරකය හේතුවෙන් විධානය මඟින් ලබා නොදුන් පණිවිඩ පමණක් වාර්තා කරයි. ඔබට පෙනෙන පරිදි, "ඇපල්" පණිවිඩය දැනටමත් ඇලිස් වෙත ලබා දී ඇති බැවින් එය දර්ශනය නොවනු ඇත, එබැවින් බොබ්ට "තැඹිලි" සහ "ස්ට්රෝබෙරි" ලැබේ.
මේ ආකාරයෙන්, ඇලිස්, බොබ් සහ සමූහයට වෙනත් ඕනෑම ග්‍රාහකයෙකුට එකම ප්‍රවාහයෙන් විවිධ පණිවිඩ කියවිය හැකිය. ඔවුන්ට ඔවුන්ගේ සැකසූ පණිවිඩවල ඉතිහාසය කියවීමට හෝ පණිවිඩ සැකසූ ලෙස සලකුණු කිරීමටද හැකිය.
මතක තබා ගත යුතු කරුණු කිහිපයක් තිබේ:
- ග්රාහකයා පණිවිඩය විධානයක් ලෙස සලකන වහාම XREADGROUP, මෙම පණිවිඩය "පොරොත්තු" තත්වයට ගොස් එම නිශ්චිත ග්‍රාහකයාට පවරනු ලැබේ. අනෙකුත් කණ්ඩායම් ග්‍රාහකයින්ට මෙම පණිවිඩය කියවීමට නොහැකි වනු ඇත.
- පළමු සඳහන මත ග්‍රාහකයින් ස්වයංක්‍රීයව නිර්මාණය වේ, ඒවා පැහැදිලිව නිර්මාණය කිරීමට අවශ්ය නොවේ.
- සහාය ඇතිව XREADGROUP ඔබට එකවර විවිධ ත්‍රෙඩ් කිහිපයකින් පණිවිඩ කියවිය හැක, කෙසේ වෙතත් මෙය ක්‍රියාත්මක වීමට ඔබ මුලින්ම භාවිතා කරන එක් එක් ත්‍රෙඩ් සඳහා එකම නමින් කණ්ඩායම් සෑදිය යුතුය. XGROUP
අසාර්ථක වීමෙන් පසු ප්රකෘතිමත් වීම
ග්‍රාහකයාට අසාර්ථක වීමෙන් යථා තත්ත්වයට පත් විය හැකි අතර "පොරොත්තු වන" තත්ත්වය සමඟ ඔහුගේ පණිවිඩ ලැයිස්තුව නැවත කියවිය හැකිය. කෙසේ වෙතත්, සැබෑ ලෝකයේ, ග්‍රාහකයින් අවසානයේ අසාර්ථක විය හැකිය. ග්‍රාහකයාට අසාර්ථක වීමෙන් යථා තත්ත්වයට පත් වීමට නොහැකි වුවහොත් ග්‍රාහකයාගේ සිරවී ඇති පණිවිඩවලට කුමක් සිදුවේද?
පාරිභෝගික සමූහය එවැනි අවස්ථා සඳහා පමණක් භාවිතා කරන විශේෂාංගයක් ඉදිරිපත් කරයි - ඔබට පණිවිඩවල හිමිකරු වෙනස් කිරීමට අවශ්ය වූ විට.
ඔබ කළ යුතු පළමු දෙය නම් විධානය අමතන්න XPENDING, එය "පොරොත්තු" තත්ත්වය සමඟ සමූහයේ සියලුම පණිවිඩ පෙන්වයි. එහි සරලම ආකාරයෙන්, විධානය හැඳින්වෙන්නේ තර්ක දෙකකින් පමණි: නූල් නම සහ කණ්ඩායම් නම:
> XPENDING mystream mygroup
1) (integer) 2
2) 1526569498055-0
3) 1526569506935-0
4) 1) 1) "Bob"
2) "2"
කණ්ඩායම මුළු කණ්ඩායම සඳහාම සහ එක් එක් ග්රාහකයා සඳහා සකස් නොකළ පණිවිඩ ගණන ප්‍රදර්ශනය කළේය. ඇලිස් ඉල්ලා සිටි එකම පණිවිඩය තහවුරු කර ඇති නිසා අපට ඇත්තේ කැපී පෙනෙන පණිවිඩ දෙකක් සහිත බොබ් පමණි XACK.
අපට තවත් තර්ක භාවිතා කර වැඩිදුර තොරතුරු ඉල්ලා සිටිය හැක:
XPENDING {key} {groupname} [{start-id} {end-id} {count} [{consumer-name}]]
{start-id} {end-id} - හඳුනාගැනීමේ පරාසය (ඔබට "-" සහ "+" භාවිතා කළ හැක)
{count} — බෙදාහැරීමේ උත්සාහයන් ගණන
{consumer-name} - කණ්ඩායම් නම
> XPENDING mystream mygroup - + 10
1) 1) 1526569498055-0
2) "Bob"
3) (integer) 74170458
4) (integer) 1
2) 1) 1526569506935-0
2) "Bob"
3) (integer) 74170458
4) (integer) 1
දැන් අපට එක් එක් පණිවිඩය සඳහා විස්තර තිබේ: හැඳුනුම්පත, ග්‍රාහකයාගේ නම, නිෂ්ක්‍රීය කාලය මිලි තත්පර වලින් සහ අවසානයේ බෙදා හැරීමේ උත්සාහයන් ගණන. අපට Bob වෙතින් පණිවිඩ දෙකක් ඇති අතර ඒවා මිලි තත්පර 74170458, පැය 20ක් පමණ අක්‍රියව පවතී.
හුදෙක් භාවිතා කිරීමෙන් පණිවිඩයේ අන්තර්ගතය කුමක්දැයි පරීක්ෂා කිරීමෙන් කිසිවෙකු අපව වළක්වන්නේ නැති බව කරුණාවෙන් සලකන්න XRANGE.
> XRANGE mystream 1526569498055-0 1526569498055-0
1) 1) 1526569498055-0
2) 1) "message"
2) "orange"
අපිට තියෙන්නේ එකම identifier එක දෙපාරක් විතර arguments වල නැවත නැවත කියන්න. දැන් අපට යම් අදහසක් ඇති බැවින්, පැය 20ක ක්‍රියා විරහිත වීමෙන් පසු, බොබ් බොහෝ විට සුව නොවනු ඇතැයි ඇලිස් තීරණය කළ හැකි අතර, එම පණිවිඩ විමසා ඒවා බොබ් සඳහා නැවත සැකසීමට කාලය පැමිණ තිබේ. මේ සඳහා අපි විධානය භාවිතා කරමු XCLAIM:
XCLAIM {key} {group} {consumer} {min-idle-time} {ID-1} {ID-2} ... {ID-N}
මෙම විධානය භාවිතා කරමින්, හිමිකරු {consumer} ලෙස වෙනස් කිරීමෙන් අපට තවමත් සකස් කර නොමැති "විදේශීය" පණිවිඩයක් ලබා ගත හැක. කෙසේ වෙතත්, අපට අවම නිෂ්ක්‍රීය කාලයක් {min-idle-time} ලබා දිය හැක. සේවාදායකයින් දෙදෙනෙකු එකම පණිවිඩවල හිමිකරු එකවර වෙනස් කිරීමට උත්සාහ කරන තත්වයක් වළක්වා ගැනීමට මෙය උපකාරී වේ:
Client 1: XCLAIM mystream mygroup Alice 3600000 1526569498055-0
Clinet 2: XCLAIM mystream mygroup Lora 3600000 1526569498055-0
පළමු පාරිභෝගිකයා අක්‍රීය කාලය නැවත සකස් කර බෙදා හැරීමේ කවුන්ටරය වැඩි කරයි. එබැවින් දෙවන සේවාදායකයාට එය ඉල්ලා සිටීමට නොහැකි වනු ඇත.
> XCLAIM mystream mygroup Alice 3600000 1526569498055-0
1) 1) 1526569498055-0
2) 1) "message"
2) "orange"
පණිවිඩයට ඇලිස් විසින් සාර්ථකව හිමිකම් කියන ලදී, ඇයට දැන් පණිවිඩය සැකසීමට සහ එය පිළිගැනීමට හැකිය.
ඉහත උදාහරණයෙන්, සාර්ථක ඉල්ලීමක් පණිවිඩයේ අන්තර්ගතය නැවත ලබා දෙන බව ඔබට දැක ගත හැකිය. කෙසේ වෙතත්, මෙය අවශ්ය නොවේ. JUSTID විකල්පය භාවිතා කළ හැක්කේ පණිවිඩ හැඳුනුම්පත් ආපසු යැවීමට පමණි. ඔබ පණිවිඩයේ විස්තර ගැන උනන්දුවක් නොදක්වන අතර පද්ධතියේ කාර්ය සාධනය වැඩි කිරීමට අවශ්ය නම් මෙය ප්රයෝජනවත් වේ.
බෙදාහැරීමේ කවුන්ටරය
ප්රතිදානයේ ඔබ දකින කවුන්ටරය XPENDING එක් එක් පණිවිඩයේ බෙදාහැරීම් ගණන වේ. එවැනි කවුන්ටරයක් ක්රම දෙකකින් වැඩි වේ: පණිවිඩයක් හරහා සාර්ථකව ඉල්ලා සිටින විට XCLAIM හෝ ඇමතුමක් භාවිතා කරන විට XREADGROUP.
සමහර පණිවිඩ කිහිප වතාවක් බෙදා හැරීම සාමාන්‍ය දෙයකි. ප්රධාන දෙය නම් සියලුම පණිවිඩ අවසානයේ සැකසීමයි. පණිවිඩය දූෂිත වී ඇති නිසා පණිවිඩයක් සැකසීමේදී සමහර විට ගැටළු ඇති වේ, නැතහොත් පණිවිඩ සැකසීම හසුරුවන්නා කේතයේ දෝෂයක් ඇති කරයි. මෙම අවස්ථාවේදී, මෙම පණිවිඩය සැකසීමට කිසිවෙකුට නොහැකි වනු ඇත. අප සතුව බෙදාහැරීමේ උත්සාහ කවුන්ටරයක් ඇති බැවින්, එවැනි තත්වයන් හඳුනා ගැනීමට අපට මෙම කවුන්ටරය භාවිතා කළ හැකිය. එමනිසා, බෙදා හැරීමේ ගණන ඔබ සඳහන් කරන ඉහළ අංකයට ළඟා වූ පසු, එවැනි පණිවිඩයක් වෙනත් නූලක දමා පද්ධති පරිපාලක වෙත දැනුම්දීමක් යැවීම වඩාත් ඥානවන්ත වනු ඇත.
නූල් තත්ත්වය
කණ්ඩායම XINFO නූල් සහ එහි කණ්ඩායම් පිළිබඳ විවිධ තොරතුරු ඉල්ලා සිටීමට භාවිතා කරයි. උදාහරණයක් ලෙස, මූලික විධානයක් මේ වගේ ය:
> XINFO STREAM mystream
1) length
2) (integer) 13
3) radix-tree-keys
4) (integer) 1
5) radix-tree-nodes
6) (integer) 2
7) groups
8) (integer) 2
9) first-entry
10) 1) 1524494395530-0
2) 1) "a"
2) "1"
3) "b"
4) "2"
11) last-entry
12) 1) 1526569544280-0
2) 1) "message"
2) "banana"
ඉහත විධානය මඟින් නිශ්චිත ප්‍රවාහය පිළිබඳ සාමාන්‍ය තොරතුරු පෙන්වයි. දැන් ටිකක් සංකීර්ණ උදාහරණයක්:
> XINFO GROUPS mystream
1) 1) name
2) "mygroup"
3) consumers
4) (integer) 2
5) pending
6) (integer) 2
2) 1) name
2) "some-other-group"
3) consumers
4) (integer) 1
5) pending
6) (integer) 0
ඉහත විධානය මඟින් නිශ්චිත නූල්වල සියලුම කණ්ඩායම් සඳහා සාමාන්‍ය තොරතුරු පෙන්වයි
> XINFO CONSUMERS mystream mygroup
1) 1) name
2) "Alice"
3) pending
4) (integer) 1
5) idle
6) (integer) 9104628
2) 1) name
2) "Bob"
3) pending
4) (integer) 1
5) idle
6) (integer) 83841983
ඉහත විධානය මඟින් නිශ්චිත ප්රවාහයේ සහ කණ්ඩායමේ සියලුම ග්‍රාහකයින් සඳහා තොරතුරු පෙන්වයි.
ඔබට විධාන වාක්‍ය ඛණ්ඩය අමතක වුවහොත්, උදව් සඳහා විධානයෙන් ම විමසන්න:
> XINFO HELP
1) XINFO {subcommand} arg arg ... arg. Subcommands are:
2) CONSUMERS {key} {groupname} -- Show consumer groups of group {groupname}.
3) GROUPS {key} -- Show the stream consumer groups.
4) STREAM {key} -- Show information about the stream.
5) HELP -- Print this help.
ප්‍රවාහ ප්‍රමාණය සීමාව
බොහෝ යෙදුම් වලට සදහටම ප්‍රවාහයකට දත්ත රැස් කිරීමට අවශ්ය නැත. ත්‍රෙඩ් එකකට උපරිම පණිවිඩ ප්‍රමාණයක් ලබා දීම බොහෝ විට ප්රයෝජනවත් වේ. වෙනත් අවස්ථා වලදී, නිශ්චිත නූල් ප්‍රමාණයට ළඟා වූ විට සියලුම පණිවිඩ නූල් එකකින් වෙනත් ස්ථීර ගබඩාවකට ගෙන යාම ප්රයෝජනවත් වේ. ඔබට විධානයේ ඇති MAXLEN පරාමිතිය භාවිතයෙන් ප්‍රවාහයක ප්‍රමාණය සීමා කළ හැක XADD:
> XADD mystream MAXLEN 2 * value 1
1526654998691-0
> XADD mystream MAXLEN 2 * value 2
1526654999635-0
> XADD mystream MAXLEN 2 * value 3
1526655000369-0
> XLEN mystream
(integer) 2
> XRANGE mystream - +
1) 1) 1526654999635-0
2) 1) "value"
2) "2"
2) 1) 1526655000369-0
2) 1) "value"
2) "3"
MAXLEN භාවිතා කරන විට, පැරණි වාර්තා නිශ්චිත දිගකට ළඟා වූ විට ඒවා ස්වයංක්‍රීයව මකා දමනු ලැබේ, එබැවින් ප්‍රවාහයට නියත ප්‍රමාණයක් ඇත. කෙසේ වෙතත්, මෙම නඩුවේ කප්පාදු කිරීම Redis මතකයේ වඩාත් කාර්යක්ෂම ආකාරයෙන් සිදු නොවේ. ඔබට පහත පරිදි තත්වය වැඩිදියුණු කළ හැකිය:
XADD mystream MAXLEN ~ 1000 * ... entry fields here ...
ඉහත උදාහරණයේ ඇති ~ තර්කයෙන් අදහස් වන්නේ ප්රවාහයේ දිග නිශ්චිත අගයකට සීමා කිරීමට අවශ්ය නොවන බවයි. අපගේ උදාහරණයේ, මෙය 1000 ට වඩා වැඩි හෝ සමාන ඕනෑම අංකයක් විය හැකිය (උදාහරණයක් ලෙස, 1000, 1010, හෝ 1030). අපගේ ප්‍රවාහයට අවම වශයෙන් වාර්තා 1000ක් වත් ගබඩා කිරීමට අවශ්ය බව අපි පැහැදිලිවම සඳහන් කළෙමු. මෙය Redis තුළ මතක කළමනාකරණය වඩාත් කාර්යක්ෂම කරයි.
වෙනම කණ්ඩායමකුත් ඉන්නවා XTRIM, එය එකම දේ කරයි:
> XTRIM mystream MAXLEN 10
> XTRIM mystream MAXLEN ~ 10
ස්ථිර ගබඩා කිරීම සහ අනුකරණය
රෙඩිස් ප්‍රවාහය ස්ලේව් නෝඩ් වෙත අසමමුහුර්තව ප්‍රතිනිර්මාණය කර AOF (සියලු දත්තවල ස්නැප්ෂොට්) සහ RDB (සියලු ලිවීමේ මෙහෙයුම් වල ලොගය) වැනි ගොනු වෙත සුරැකේ. පාරිභෝගික කණ්ඩායම් තත්ත්වය අනුකරණය කිරීම සඳහා ද සහය දක්වයි. එමනිසා, පණිවිඩයක් ප්රධාන නෝඩයේ “පොරොත්තු” තත්ත්වයේ තිබේ නම්, වහල් නෝඩ් වල මෙම පණිවිඩයට එම තත්ත්වයම ඇත.
ධාරාවකින් තනි මූලද්රව්ය ඉවත් කිරීම
පණිවිඩ මකා දැමීමට විශේෂ විධානයක් ඇත XDEL. විධානය මඟින් ත්‍රෙඩ් එකේ නම සහ පසුව මකා දැමිය යුතු පණිවිඩ හැඳුනුම්පත් ලැබේ:
> XRANGE mystream - + COUNT 2
1) 1) 1526654999635-0
2) 1) "value"
2) "2"
2) 1) 1526655000369-0
2) 1) "value"
2) "3"
> XDEL mystream 1526654999635-0
(integer) 1
> XRANGE mystream - + COUNT 2
1) 1) 1526655000369-0
2) 1) "value"
2) "3"
මෙම විධානය භාවිතා කරන විට, සැබෑ මතකය වහාම නිදහස් නොකරන බව ඔබ සැලකිල්ලට ගත යුතුය.
ශුන්‍ය දිග ප්‍රවාහ
ප්‍රවාහ සහ අනෙකුත් Redis දත්ත ව්‍යුහයන් අතර වෙනස වන්නේ අනෙකුත් දත්ත ව්‍යුහයන් තුළ තවදුරටත් මූලද්රව්ය නොමැති විට අතුරු ප්‍රතිඵලයක් ලෙස දත්ත ව්‍යුහයම මතකයෙන් ඉවත් වීමයි. එබැවින්, උදාහරණයක් ලෙස, ZREM ඇමතුම අවසන් මූලද්රව්යය ඉවත් කරන විට වර්ග කළ කට්ටලය සම්පූර්ණයෙන්ම ඉවත් කරනු ලැබේ. ඒ වෙනුවට, නූල් ඇතුළත කිසිදු අංගයක් නොමැතිව වුවද මතකයේ රැඳී සිටීමට ඉඩ දෙනු ලැබේ.
නිගමනය
Redis Stream පණිවිඩ තැරැව්කරුවන්, පණිවිඩ පෝලිම්, ඒකාබද්ධ ලොග් කිරීම සහ ඉතිහාසය තබා ගැනීමේ කතාබස් පද්ධති නිර්මාණය කිරීම සඳහා වඩාත් සුදුසු වේ.
මම වරක් කී පරිදි , වැඩසටහන් යනු ඇල්ගොරිතම සහ දත්ත ව්‍යුහයන් වන අතර Redis දැනටමත් ඔබට දෙකම ලබා දෙයි.
මූලාශ්රය: www.habr.com