🥇በTarantool DBMS ውስጥ የከፍተኛ ደረጃ ማባዛት

ሰላም፣ ለዲቢኤምኤስ አፕሊኬሽኖችን እየፈጠርኩ ነው። ታራንቶል ከፍተኛ አፈጻጸም ያለው DBMS እና በሉአ ቋንቋ የመተግበሪያ አገልጋይን በማጣመር በ Mail.ru ቡድን የተገነባ መድረክ ነው። በ Tarantool ላይ የተመሰረቱ የመፍትሄዎች ከፍተኛ ፍጥነት በተለይም ለዲቢኤምኤስ ውስጠ-ማስታወሻ ሁነታ ድጋፍ እና የመተግበሪያ የንግድ ሎጂክን በአንድ የአድራሻ ቦታ ከውሂብ ጋር የማስፈፀም ችሎታን በማግኘቱ ነው. በተመሳሳይ ጊዜ የ ACID ግብይቶችን በመጠቀም የውሂብ ጽናት ይረጋገጣል (የWAL ምዝግብ ማስታወሻ በዲስክ ላይ ይቀመጣል)። Tarantool ለማባዛት እና ለመጋራት አብሮ የተሰራ ድጋፍ አለው። ከስሪት 2.1 ጀምሮ፣ በSQL ቋንቋ የሚደረጉ መጠይቆች ይደገፋሉ። Tarantool ክፍት ምንጭ እና በቀላል ቢኤስዲ ፍቃድ ስር ፍቃድ ያለው ነው። የንግድ ድርጅት ስሪትም አለ።

ኃይሉን ይወቁ! (… በአፈፃፀም ይደሰቱ)

ከላይ ያሉት ሁሉም ታራንቶልን ከመረጃ ቋቶች ጋር የሚሰሩ ከፍተኛ ጭነት ያላቸው መተግበሪያዎችን ለመፍጠር ማራኪ መድረክ ያደርጉታል። በእንደዚህ ዓይነት አፕሊኬሽኖች ውስጥ ብዙ ጊዜ የውሂብ ማባዛት ያስፈልጋል.

ከላይ እንደተጠቀሰው Tarantool አብሮ የተሰራ የውሂብ ማባዛት አለው። የክዋኔው መርህ በማስተር ሎግ (WAL) ውስጥ ያሉትን ሁሉንም ግብይቶች በማባዛት ላይ በቅደም ተከተል ማስፈጸም ነው። ብዙውን ጊዜ እንዲህ ዓይነቱ ማባዛት (በተጨማሪ እንጠራዋለን ዝቅተኛ ደረጃ) የመተግበሪያ ስህተት መቻቻልን ለማረጋገጥ እና/ወይም የንባብ ሸክሙን በክላስተር ኖዶች መካከል ለማሰራጨት ይጠቅማል።

ሩዝ. 1. በክላስተር ውስጥ ማባዛት

የአማራጭ ሁኔታ ምሳሌ በአንድ የውሂብ ጎታ ውስጥ የተፈጠረውን ውሂብ ወደ ሌላ የውሂብ ጎታ ለሂደት/ክትትል ማስተላለፍ ነው። በኋለኛው ሁኔታ, የበለጠ ምቹ የሆነ መፍትሄ መጠቀም ሊሆን ይችላል ከፍተኛ ደረጃ ማባዛት - በመተግበሪያው የንግድ ሎጂክ ደረጃ የውሂብ ማባዛት. እነዚያ። በዲቢኤምኤስ ውስጥ የተሰራ ዝግጁ የሆነ መፍትሄ አንጠቀምም፣ ነገር ግን እያዘጋጀን ባለው መተግበሪያ ውስጥ በራሳችን ማባዛትን ተግባራዊ እናደርጋለን። ይህ አቀራረብ ሁለቱም ጥቅሞች እና ጉዳቶች አሉት. ጥቅሞቹን እንዘርዝር።

1. የትራፊክ ቁጠባ;

ሁሉንም ውሂብ ማስተላለፍ አይችሉም, ነገር ግን የተወሰነው ክፍል ብቻ (ለምሳሌ, አንዳንድ ሰንጠረዦችን ብቻ, አንዳንድ አምዶችን ወይም የተወሰነ መስፈርት የሚያሟሉ መዝገቦችን ማስተላለፍ ይችላሉ);
ባልተመሳሰለው (በአሁኑ የTarantool - 1.10) ወይም የተመሳሰለ (በቀጣዮቹ የTarantool ስሪቶች ውስጥ የሚተገበር) ሁነታ በተከታታይ ከሚከናወነው ዝቅተኛ-ደረጃ ማባዛት በተቃራኒ ከፍተኛ-ደረጃ ማባዛት በክፍለ-ጊዜዎች ውስጥ ሊከናወን ይችላል (ማለትም ፣ ትግበራ በመጀመሪያ ውሂቡን ያመሳስላል - የልውውጥ ክፍለ ጊዜ ውሂብ, ከዚያም በማባዛት ላይ ቆም አለ, ከዚያ በኋላ የሚቀጥለው የልውውጥ ክፍለ ጊዜ ይከሰታል, ወዘተ.);
መዝገብ ብዙ ጊዜ ከተቀየረ የቅርብ ጊዜውን ስሪት ብቻ ማስተላለፍ ይችላሉ (ከዝቅተኛ ደረጃ ማባዛት በተለየ ፣ በጌታው ላይ የተደረጉ ለውጦች ሁሉ በቅደም ተከተል በተገለበጡ ላይ ይጫወታሉ)።

2. የርቀት ዳታቤዞችን ለማመሳሰል የሚያስችል የኤችቲቲፒ ልውውጥን በመተግበር ላይ ምንም ችግሮች የሉም።

ሩዝ. 2. በ HTTP ላይ ማባዛት

3. መረጃ የሚተላለፍባቸው የውሂብ ጎታ አወቃቀሮች አንድ አይነት መሆን የለባቸውም (በተጨማሪም በአጠቃላይ ሁኔታ የተለያዩ ዲቢኤምኤስዎችን፣ ፕሮግራሚንግ ቋንቋዎችን፣ መድረኮችን ወዘተ መጠቀም ይቻላል)።

ሩዝ. 3. በተለያዩ ስርዓቶች ውስጥ ማባዛት

ጉዳቱ በአማካይ ፕሮግራሚንግ ከማዋቀር የበለጠ ከባድ/ዋጋ ነው፣ እና አብሮ የተሰራውን ተግባር ከማበጀት ይልቅ የእራስዎን መተግበር ይኖርብዎታል።

በእርስዎ ሁኔታ ውስጥ ከላይ ያሉት ጥቅሞች ወሳኝ ከሆኑ (ወይንም አስፈላጊ ከሆነ) ከፍተኛ ደረጃ ማባዛትን መጠቀም ምክንያታዊ ነው. በ Tarantool DBMS ውስጥ ባለ ከፍተኛ ደረጃ የውሂብ ማባዛትን ለመተግበር በርካታ መንገዶችን እንመልከት።

የትራፊክ መቀነስ

ስለዚህ የከፍተኛ ደረጃ ማባዛት አንዱ ጠቀሜታ የትራፊክ ቁጠባ ነው። ይህ ጥቅም ሙሉ በሙሉ እውን እንዲሆን በእያንዳንዱ የልውውጥ ክፍለ ጊዜ የተላለፈውን የውሂብ መጠን መቀነስ አስፈላጊ ነው. እርግጥ ነው, በክፍለ-ጊዜው መጨረሻ ላይ የመረጃ መቀበያው ከምንጩ ጋር ማመሳሰል እንዳለበት መዘንጋት የለብንም (ቢያንስ ለዚያው የውሂብ ክፍል በማባዛት ውስጥ).

በከፍተኛ ደረጃ ማባዛት ወቅት የተላለፈውን የውሂብ መጠን እንዴት መቀነስ ይቻላል? ቀጥተኛ መፍትሔ መረጃን በቀን እና በሰዓቱ መምረጥ ሊሆን ይችላል። ይህንን ለማድረግ በሠንጠረዡ ውስጥ ያለውን የቀን-ሰዓት መስክ (ካለ) መጠቀም ይችላሉ. ለምሳሌ፣ “ትዕዛዝ” ሰነድ መስክ ሊኖረው ይችላል “አስፈላጊ የትዕዛዝ ማስፈጸሚያ ጊዜ” - delivery_time. የዚህ መፍትሔ ችግር በዚህ መስክ ውስጥ ያሉት ዋጋዎች ከትእዛዞች መፈጠር ጋር በተዛመደ ቅደም ተከተል ውስጥ መሆን የለባቸውም. ስለዚህ ከፍተኛውን የመስክ ዋጋ ማስታወስ አንችልም። delivery_time, በቀድሞው የልውውጥ ክፍለ ጊዜ የተላለፈ, እና በሚቀጥለው የልውውጥ ክፍለ ጊዜ ሁሉንም መዝገቦች ከፍ ያለ የመስክ ዋጋ ይምረጡ delivery_time. ዝቅተኛ የመስክ ዋጋ ያላቸው መዝገቦች በተለዋዋጭ ክፍለ-ጊዜዎች መካከል ተጨምረው ሊሆን ይችላል። delivery_time. እንዲሁም፣ ትዕዛዙ ለውጦችን ማድረግ ይችል ነበር፣ ሆኖም ግን በመስክ ላይ ተጽዕኖ አላሳደረም። delivery_time. በሁለቱም ሁኔታዎች ለውጦቹ ከምንጩ ወደ መድረሻው አይተላለፉም. እነዚህን ችግሮች ለመፍታት, "ተደራራቢ" ውሂብ ማስተላለፍ ያስፈልገናል. እነዚያ። በእያንዳንዱ የልውውጥ ክፍለ ጊዜ ሁሉንም ውሂብ በመስክ ዋጋ እናስተላልፋለን delivery_time, ባለፈው ከተወሰነ ነጥብ በላይ (ለምሳሌ, አሁን ካለው ቅጽበት N ሰዓቶች). ይሁን እንጂ ለትላልቅ ስርዓቶች ይህ አቀራረብ በጣም ብዙ ጊዜ የማይፈለግ እና የምንፈልገውን የትራፊክ ቁጠባ ወደ ምንም ነገር ሊቀንስ እንደሚችል ግልጽ ነው. በተጨማሪም፣ እየተዘዋወረ ያለው ሠንጠረዥ ከቀን-ጊዜ ጋር የተያያዘ መስክ ላይኖረው ይችላል።

ሌላው መፍትሔ፣ በአተገባበር ረገድ የበለጠ ውስብስብ፣ መረጃ መቀበሉን መቀበል ነው። በዚህ ሁኔታ, በእያንዳንዱ ልውውጥ ክፍለ ጊዜ, ሁሉም መረጃዎች ይተላለፋሉ, ደረሰኙ በተቀባዩ ያልተረጋገጠ ነው. ይህንን ለመተግበር የቦሊያን አምድ ወደ ምንጭ ሠንጠረዥ ማከል ያስፈልግዎታል (ለምሳሌ ፣ is_transferred). ተቀባዩ መዝገቡን መቀበሉን ካወቀ, ተዛማጅው መስክ ዋጋውን ይወስዳል true, ከዚያ በኋላ መግባቱ በልውውጦች ውስጥ አይሳተፍም. ይህ የማስፈጸሚያ አማራጭ የሚከተሉት ጉዳቶች አሉት። በመጀመሪያ፣ ለእያንዳንዱ የተላለፈ መዝገብ፣ እውቅና መፈጠር እና መላክ አለበት። በመጠኑ አነጋገር፣ ይህ የተላለፈውን የውሂብ መጠን በእጥፍ በመጨመር እና የጉዞውን ቁጥር በእጥፍ ከማድረስ ጋር ሊወዳደር ይችላል። በሁለተኛ ደረጃ, ተመሳሳዩን መዝገብ ለብዙ ተቀባዮች የመላክ እድል የለም (የመጀመሪያው ተቀባይ ለራሱ እና ለሌሎች ሁሉ ደረሰኝ ያረጋግጣል).

ከላይ የተጠቀሱትን ድክመቶች የሌሉበት ዘዴ የረድፎችን ለውጦች ለመከታተል በተላለፈው ሰንጠረዥ ላይ አንድ አምድ ማከል ነው. እንዲህ ዓይነቱ ዓምድ የቀን-ጊዜ ዓይነት ሊሆን ይችላል እና በእያንዳንዱ ጊዜ መዝገቦች ሲጨመሩ / ሲቀየሩ (በአቶሚክ ከመደመር / ለውጥ ጋር) በመተግበሪያው ማዋቀር / ማዘመን አለበት. እንደ ምሳሌ, ዓምዱን እንጥራ update_time. የዚህን አምድ ከፍተኛውን የመስክ ዋጋ ለተዘዋወሩ መዝገቦች በማስቀመጥ ቀጣዩን የልውውጥ ክፍለ ጊዜ በዚህ እሴት መጀመር እንችላለን (የመስክ ዋጋ ያላቸውን መዝገቦች ይምረጡ) update_time, ቀደም ሲል ከተከማቸ ዋጋ በላይ). የኋለኛው አቀራረብ ችግር የውሂብ ለውጦች በቡድኖች ውስጥ ሊከሰቱ ይችላሉ. በአምዱ ውስጥ ባለው የመስክ እሴቶች ምክንያት update_time ልዩ ላይሆን ይችላል. ስለዚህ ይህ አምድ ለተከፋፈለ (ገጽ-በገጽ) የውሂብ ውፅዓት መጠቀም አይቻልም። የውሂብ ገጽ በገጽ ለማሳየት፣ በጣም ዝቅተኛ ቅልጥፍና ሊኖራቸው የሚችሉ ተጨማሪ ስልቶችን መፍጠር አለቦት (ለምሳሌ፣ ከመረጃ ቋቱ ሁሉንም መዛግብት ከዋጋው ሰርስሮ ማውጣት) update_time ከተጠቀሰው በላይ ከፍ ያለ እና የተወሰኑ መዝገቦችን በማፍራት, ከናሙናው መጀመሪያ ጀምሮ ከተወሰነ ማካካሻ ጀምሮ).

የቀደመውን አካሄድ በትንሹ በማሻሻል የውሂብ ማስተላለፍን ውጤታማነት ማሻሻል ይችላሉ። ይህንን ለማድረግ የኢንቲጀር አይነትን (ረጅም ኢንቲጀር) እንደ የአምድ መስክ እሴቶች እንጠቀማለን ለውጦችን መከታተል። ዓምዱን እንሰይመው row_ver. መዝገብ በተፈጠረ/በተሻሻለ ቁጥር የዚህ አምድ የመስክ ዋጋ አሁንም መዋቀር/መዘመን አለበት። ነገር ግን በዚህ ሁኔታ, መስኩ የአሁኑን ቀን-ሰዓት አይመደብም, ነገር ግን የአንዳንድ ቆጣሪ ዋጋ በአንድ ጨምሯል. በውጤቱም, ዓምዱ row_ver ልዩ እሴቶችን ይይዛል እና የ “ዴልታ” መረጃን ለማሳየት ብቻ ሳይሆን (ከቀደመው የልውውጥ ክፍለ ጊዜ መጨረሻ ጀምሮ የተጨመረው/የተቀየረ መረጃ) ብቻ ሳይሆን በቀላሉ እና በብቃት ወደ ገፆች ለመከፋፈልም ሊያገለግል ይችላል።

በከፍተኛ ደረጃ ማባዛት ማዕቀፍ ውስጥ የተላለፈውን የውሂብ መጠን ለመቀነስ የመጨረሻው የታቀደ ዘዴ ለእኔ በጣም ጥሩ እና ሁለንተናዊ ይመስላል። በዝርዝር እንመልከተው።

የረድፍ ሥሪት ቆጣሪን በመጠቀም ውሂብ ማስተላለፍ

የአገልጋይ / ዋና ክፍል መተግበር

በ MS SQL አገልጋይ ውስጥ ይህንን አሰራር ለመተግበር ልዩ የአምድ ዓይነት አለ - rowversion. እያንዳንዱ የውሂብ ጎታ እንደ አምድ ባለው ሠንጠረዥ ውስጥ መዝገብ በተጨመረ/በተለወጠ ቁጥር አንድ የሚጨምር ቆጣሪ አለው። rowversion. የዚህ ቆጣሪ ዋጋ በተጨመረው / በተለወጠው መዝገብ ውስጥ በዚህ አምድ መስክ ላይ በራስ-ሰር ይመደባል. የ Tarantool DBMS ተመሳሳይ አብሮገነብ ዘዴ የለውም። ሆኖም ግን, በ Tarantool ውስጥ በእጅ መተግበር አስቸጋሪ አይደለም. ይህ እንዴት እንደሚደረግ እንመልከት.

በመጀመሪያ, ትንሽ የቃላት አገባብ: በ Tarantool ውስጥ ያሉ ጠረጴዛዎች ክፍተት ይባላሉ, እና መዝገቦች ቱፕልስ ይባላሉ. በ Tarantool ውስጥ ቅደም ተከተሎችን መፍጠር ይችላሉ. ቅደም ተከተሎች የታዘዙ የኢንቲጀር እሴቶች ከተሰየሙ ጄነሬተሮች የበለጠ ምንም አይደሉም። እነዚያ። ለዓላማችን የምንፈልገው ይህ ነው። ከታች እንደዚህ አይነት ቅደም ተከተል እንፈጥራለን.

በ Tarantool ውስጥ ማንኛውንም የውሂብ ጎታ ሥራ ከማከናወንዎ በፊት የሚከተለውን ትዕዛዝ ማስኬድ ያስፈልግዎታል:

box.cfg{}

በዚህ ምክንያት Tarantool የውሂብ ጎታ ቅጽበተ-ፎቶዎችን እና የግብይት ምዝግብ ማስታወሻዎችን አሁን ባለው ማውጫ ላይ መጻፍ ይጀምራል።

ቅደም ተከተል እንፍጠር row_version:

box.schema.sequence.create('row_version',
    { if_not_exists = true })

አማራጭ if_not_exists የፍጥረት ስክሪፕት ብዙ ጊዜ እንዲተገበር ይፈቅዳል፡ ነገሩ ካለ Tarantool እንደገና ለመፍጠር አይሞክርም። ይህ አማራጭ በሁሉም በሚቀጥሉት የዲዲኤል ትዕዛዞች ውስጥ ጥቅም ላይ ይውላል።

እንደ ምሳሌ ቦታ እንፍጠር።

box.schema.space.create('goods', {
    format = {
        {
            name = 'id',
            type = 'unsigned'

        },
        {
            name = 'name',
            type = 'string'

        },
        {
            name = 'code',
            type = 'unsigned'

        },
        {
            name = 'row_ver',
            type = 'unsigned'

        }
    },
    if_not_exists = true
})

እዚህ የቦታውን ስም አዘጋጅተናል (goods), የመስክ ስሞች እና ዓይነቶች.

በ Tarantool ውስጥ በራስ-ሰር የሚጨምሩ መስኮች እንዲሁ የተፈጠሩት ቅደም ተከተሎችን በመጠቀም ነው። በራስ የሚጨምር ቀዳሚ ቁልፍ በመስክ እንፍጠር id:

box.schema.sequence.create('goods_id',
    { if_not_exists = true })
box.space.goods:create_index('primary', {
    parts = { 'id' },
    sequence = 'goods_id',
    unique = true,
    type = 'HASH',
    if_not_exists = true
})

Tarantool ብዙ አይነት ኢንዴክሶችን ይደግፋል። በብዛት ጥቅም ላይ የሚውሉት ኢንዴክሶች TREE እና HASH አይነቶች ናቸው፣ እነሱም ከስሙ ጋር በተዛመደ አወቃቀሮች ላይ የተመሰረቱ ናቸው። TREE በጣም ሁለገብ የመረጃ ጠቋሚ ዓይነት ነው። በተደራጀ መልኩ መረጃን ሰርስሮ ለማውጣት ያስችላል። ግን ለእኩልነት ምርጫ, HASH የበለጠ ተስማሚ ነው. በዚህ መሠረት HASH ለዋና ቁልፍ (ያደረግነው ያደረግነው) መጠቀም ተገቢ ነው.

ዓምዱን ለመጠቀም row_ver የተቀየረ ውሂብን ለማስተላለፍ ተከታታይ እሴቶችን ከዚህ አምድ መስኮች ጋር ማያያዝ ያስፈልግዎታል row_ver. ግን ከዋናው ቁልፍ በተቃራኒ የአምድ መስክ ዋጋ row_ver አዲስ መዝገቦችን ሲጨምሩ ብቻ ሳይሆን ነባሮቹን በሚቀይሩበት ጊዜም በአንድ መጨመር አለበት. ለዚህ ቀስቅሴዎችን መጠቀም ይችላሉ. Tarantool ሁለት አይነት የጠፈር ቀስቅሴዎች አሉት፡- before_replace и on_replace. በቦታ ውስጥ ያለው መረጃ በተቀየረ ቁጥር ቀስቅሴዎች ይቃጠላሉ (ለውጦቹ ለተጎዳው ለእያንዳንዱ ቱፕል የመቀስቀስ ተግባር ይጀመራል)። የማይመሳስል on_replace, before_replace- ቀስቅሴዎች ቀስቅሴው የሚከናወንበትን የ tuple ውሂብ እንዲቀይሩ ያስችሉዎታል። በዚህ መሠረት, የመጨረሻው አይነት ቀስቅሴዎች ይስማማናል.

box.space.goods:before_replace(function(old, new)
    return box.tuple.new({new[1], new[2], new[3],
        box.sequence.row_version:next()})
end)

የሚከተለው ቀስቅሴ የመስክ ዋጋን ይተካል። row_ver የተከማቸ tuple ወደ ተከታዩ ተከታታይ እሴት row_version.

መረጃን ከጠፈር ማውጣት እንዲቻል goods በአምድ row_verኢንዴክስ እንፍጠር፡-

box.space.goods:create_index('row_ver', {
    parts = { 'row_ver' },
    unique = true,
    type = 'TREE',
    if_not_exists = true
})

የመረጃ ጠቋሚ ዓይነት - ዛፍ (TREE), ምክንያቱም በአምዱ ውስጥ ባለው የእሴቶች ቅደም ተከተል ውሂቡን ማውጣት አለብን row_ver.

ወደ ቦታው የተወሰነ ውሂብ እንጨምር፡-

box.space.goods:insert{nil, 'pen', 123}
box.space.goods:insert{nil, 'pencil', 321}
box.space.goods:insert{nil, 'brush', 100}
box.space.goods:insert{nil, 'watercolour', 456}
box.space.goods:insert{nil, 'album', 101}
box.space.goods:insert{nil, 'notebook', 800}
box.space.goods:insert{nil, 'rubber', 531}
box.space.goods:insert{nil, 'ruler', 135}

ምክንያቱም የመጀመሪያው መስክ በራስ-የሚጨምር ቆጣሪ ነው፤ በምትኩ ኒል እናልፋለን። Tarantool የሚቀጥለውን እሴት በራስ-ሰር ይተካል። በተመሳሳይም እንደ የአምድ መስኮች ዋጋ row_ver ማለፍ ይችላሉ - ወይም ዋጋውን በጭራሽ አይግለጹ ፣ ምክንያቱም ይህ አምድ በጠፈር ውስጥ የመጨረሻውን ቦታ ይይዛል.

የማስገባቱን ውጤት እንፈትሽ፡-

tarantool> box.space.goods:select()
---
- - [1, 'pen', 123, 1]
  - [2, 'pencil', 321, 2]
  - [3, 'brush', 100, 3]
  - [4, 'watercolour', 456, 4]
  - [5, 'album', 101, 5]
  - [6, 'notebook', 800, 6]
  - [7, 'rubber', 531, 7]
  - [8, 'ruler', 135, 8]
...

እንደሚመለከቱት, የመጀመሪያዎቹ እና የመጨረሻዎቹ መስኮች በራስ-ሰር ይሞላሉ. አሁን የቦታ ለውጦችን ከገጽ በገጽ ለመጫን ተግባር መፃፍ ቀላል ይሆናል። goods:

local page_size = 5
local function get_goods(row_ver)
    local index = box.space.goods.index.row_ver
    local goods = {}
    local counter = 0
    for _, tuple in index:pairs(row_ver, {
        iterator = 'GT' }) do
        local obj = tuple:tomap({ names_only = true })
        table.insert(goods, obj)
        counter = counter + 1
        if counter >= page_size then
            break
        end
    end
    return goods
end

ተግባሩ እሴቱን እንደ መለኪያ ይወስዳል row_ver, ከእሱ ጀምሮ ለውጦችን ማውረድ አስፈላጊ ነው, እና የተለወጠውን ውሂብ የተወሰነ ክፍል ይመልሳል.

በ Tarantool ውስጥ የውሂብ ናሙና የሚከናወነው በመረጃ ጠቋሚዎች ነው። ተግባር get_goods ተደጋጋሚ መረጃን በመረጃ ጠቋሚ ይጠቀማል row_ver የተለወጠ ውሂብ ለመቀበል. የመድገም አይነት GT ነው (ከሚበልጥ ይበልጣል፣ከሚበልጥ)። ይህ ማለት ድግግሞሹ ከተላለፈው ቁልፍ (የመስክ እሴት) ጀምሮ የኢንዴክስ እሴቶችን በቅደም ተከተል ይሻገራል ማለት ነው። row_ver).

ተደጋጋሚው ቱፕልስ ይመልሳል። በመቀጠል በኤችቲቲፒ በኩል መረጃን ለማስተላለፍ ቱፕልቹን ለቀጣይ ተከታታይነት ወደሚመች መዋቅር መለወጥ አስፈላጊ ነው። ምሳሌው ለዚህ መደበኛ ተግባር ይጠቀማል tomap. ከመጠቀም ይልቅ tomap የእራስዎን ተግባር መፃፍ ይችላሉ. ለምሳሌ የመስክን ስም መቀየር እንፈልጋለን name, ሜዳውን አያልፉ code እና መስክ ይጨምሩ comment:

local function unflatten_goods(tuple)
    local obj = {}
    obj.id = tuple.id
    obj.goods_name = tuple.name
    obj.comment = 'some comment'
    obj.row_ver = tuple.row_ver
    return obj
end

የውጤቱ ውሂብ ገጽ መጠን (በአንድ ክፍል ውስጥ ያሉ የመዝገቦች ብዛት) በተለዋዋጭ ይወሰናል page_size. በምሳሌው ውስጥ እሴቱ page_size ነው 5. በእውነተኛ ፕሮግራም ውስጥ, የገጹ መጠን አብዛኛውን ጊዜ የበለጠ አስፈላጊ ነው. በቦታው tuple አማካኝ መጠን ይወሰናል. የውሂብ ማስተላለፍ ጊዜን በመለካት ጥሩው የገጽ መጠን በተጨባጭ ሊወሰን ይችላል። የገጹ መጠን በትልቁ፣ በተላኪው እና በተቀባዩ ጎኖች መካከል ያለው የመዞሪያ ብዛት አነስተኛ ይሆናል። በዚህ መንገድ ለውጦችን ለማውረድ አጠቃላይ ጊዜን መቀነስ ይችላሉ። ነገር ግን፣ የገጹ መጠን በጣም ትልቅ ከሆነ፣ ናሙናውን ሲሪያል በአገልጋዩ ላይ በጣም ረጅም ጊዜ እናሳልፋለን። በዚህ ምክንያት ወደ አገልጋዩ የሚመጡ ሌሎች ጥያቄዎችን ለማስኬድ መዘግየቶች ሊኖሩ ይችላሉ። መለኪያ page_size ከማዋቀሪያው ፋይል ሊጫን ይችላል. ለእያንዳንዱ የተላለፈ ቦታ, የራሱን ዋጋ ማዘጋጀት ይችላሉ. ነገር ግን፣ ለአብዛኛዎቹ ቦታዎች ነባሪ እሴቱ (ለምሳሌ 100) ተስማሚ ሊሆን ይችላል።

ተግባሩን እናከናውን get_goods:

tarantool> get_goods(0)

---
- - row_ver: 1
    code: 123
    name: pen
    id: 1
  - row_ver: 2
    code: 321
    name: pencil
    id: 2
  - row_ver: 3
    code: 100
    name: brush
    id: 3
  - row_ver: 4
    code: 456
    name: watercolour
    id: 4
  - row_ver: 5
    code: 101
    name: album
    id: 5
...

የመስክ ዋጋን እንውሰድ row_ver ከመጨረሻው መስመር እና ተግባሩን እንደገና ይደውሉ:

tarantool> get_goods(5)

---
- - row_ver: 6
    code: 800
    name: notebook
    id: 6
  - row_ver: 7
    code: 531
    name: rubber
    id: 7
  - row_ver: 8
    code: 135
    name: ruler
    id: 8
...

አንዴ እንደገና:

tarantool> get_goods(8)
---
- []
...

እንደሚመለከቱት ፣ በዚህ መንገድ ጥቅም ላይ ሲውል ፣ ተግባሩ ሁሉንም የቦታ መዝገቦችን ገጽ በገጽ ይመልሳል goods. የመጨረሻው ገጽ ባዶ ምርጫ ይከተላል።

በቦታ ላይ ለውጦችን እናድርግ፡-

box.space.goods:update(4, {{'=', 6, 'copybook'}})
box.space.goods:insert{nil, 'clip', 234}
box.space.goods:insert{nil, 'folder', 432}

የመስክ ዋጋን ቀይረናል። name ለአንድ ግቤት እና ሁለት አዳዲስ ግቤቶችን አክለዋል.

የመጨረሻውን የተግባር ጥሪ እንድገመው፡-

tarantool> get_goods(8)
---



- - row_ver: 9
    code: 800
    name: copybook
    id: 6
  - row_ver: 10
    code: 234
    name: clip
    id: 9
  - row_ver: 11
    code: 432
    name: folder
    id: 10
...

ተግባሩ የተቀየሩትን እና የተጨመሩትን መዝገቦችን መለሰ. ስለዚህ ተግባሩ get_goods ከመጨረሻው ጥሪ በኋላ የተቀየረ ውሂብ እንዲቀበሉ ይፈቅድልዎታል ፣ ይህም ከግምት ውስጥ ያለው የማባዛት ዘዴ መሠረት ነው።

የውጤት አሰጣጥን በ HTTP በኩል በJSON መልክ ከዚህ ጽሁፍ ወሰን ውጭ እንተዋለን። ስለዚህ ጉዳይ እዚህ ማንበብ ይችላሉ- https://habr.com/ru/company/mailru/blog/272141/

የደንበኛው / የባሪያ ክፍል መተግበር

የተቀባዩ ወገን አተገባበር ምን እንደሚመስል እንመልከት። የወረደውን ውሂብ ለማከማቸት በተቀባዩ በኩል ቦታ እንፍጠር፡-

box.schema.space.create('goods', {
    format = {
        {
            name = 'id',
            type = 'unsigned'

        },
        {
            name = 'name',
            type = 'string'

        },
        {
            name = 'code',
            type = 'unsigned'

        }
    },
    if_not_exists = true
})

box.space.goods:create_index('primary', {
    parts = { 'id' },
    sequence = 'goods_id',
    unique = true,
    type = 'HASH',
    if_not_exists = true
})

የቦታው መዋቅር ከምንጩ ውስጥ ካለው የቦታ አሠራር ጋር ይመሳሰላል. ነገር ግን የተቀበለውን ውሂብ ወደ ሌላ ቦታ ስለማያስተላልፉ, አምድ row_ver በተቀባዩ ቦታ ላይ አይደለም። በመስክ ላይ id የምንጭ መለያዎች ይመዘገባሉ. ስለዚህ, በተቀባዩ በኩል በራስ-ሰር እንዲጨምር ማድረግ አያስፈልግም.

በተጨማሪም, እሴቶችን ለማስቀመጥ ቦታ እንፈልጋለን row_ver:

box.schema.space.create('row_ver', {
    format = {
        {
            name = 'space_name',
            type = 'string'

        },
        {
            name = 'value',
            type = 'string'

        }
    },
    if_not_exists = true
})

box.space.row_ver:create_index('primary', {
    parts = { 'space_name' },
    unique = true,
    type = 'HASH',
    if_not_exists = true
})

ለእያንዳንዱ የተጫነ ቦታ (መስክ space_name) የመጨረሻውን የተጫነውን ዋጋ እዚህ እናስቀምጠዋለን row_ver (ሜዳ value). ዓምዱ እንደ ዋና ቁልፍ ነው የሚሰራው። space_name.

የቦታ ውሂብን ለመጫን ተግባር እንፍጠር goods በ HTTP በኩል. ይህንን ለማድረግ የኤችቲቲፒ ደንበኛን የሚተገበር ቤተ-መጽሐፍት እንፈልጋለን። የሚከተለው መስመር ቤተ መፃህፍቱን ይጭናል እና የኤችቲቲፒ ደንበኛን ያፋጥናል፡

local http_client = require('http.client').new()

ለ json ዲሴሪያላይዜሽን እንዲሁ ቤተ-መጽሐፍት እንፈልጋለን፡-

local json = require('json')

ይህ የውሂብ ጭነት ተግባር ለመፍጠር በቂ ነው-

local function load_data(url, row_ver)
    local url = ('%s?rowVer=%s'):format(url,
        tostring(row_ver))
    local body = nil
    local data = http_client:request('GET', url, body, {
        keepalive_idle =  1,
        keepalive_interval = 1
    })
    return json.decode(data.body)
end

ተግባሩ የኤችቲቲፒ ጥያቄን ወደ ዩአርኤል አድራሻ ያከናውናል እና ይልካል row_ver እንደ ልኬት እና የጥያቄውን ያልተጠበቀ ውጤት ይመልሳል።

የተቀበለውን ውሂብ የማስቀመጥ ተግባር ይህንን ይመስላል።

local function save_goods(goods)
    local n = #goods
    box.atomic(function()
        for i = 1, n do
            local obj = goods[i]
            box.space.goods:put(
                obj.id, obj.name, obj.code)
        end
    end)
end

ውሂብን ወደ ቦታ የማስቀመጥ ዑደት goods በግብይት ውስጥ የተቀመጠ (ተግባሩ ለዚህ ጥቅም ላይ ይውላል box.atomic) የዲስክ ስራዎችን ቁጥር ለመቀነስ.

በመጨረሻም, የአካባቢያዊ ቦታ ማመሳሰል ተግባር goods ከምንጩ ጋር እንደሚከተለው ተግባራዊ ማድረግ ይችላሉ-

local function sync_goods()
    local tuple = box.space.row_ver:get('goods')
    local row_ver = tuple and tuple.value or 0

    —— set your url here:
    local url = 'http://127.0.0.1:81/test/goods/list'

    while true do
        local goods = load_goods(url, row_ver)

        local count = #goods
        if count == 0 then
            return
        end

        save_goods(goods)

        row_ver = goods[count].rowVer
        box.space.row_ver:put({'goods', row_ver})
    end
end

በመጀመሪያ ቀደም ሲል የተቀመጠውን እሴት እናነባለን row_ver ለቦታ goods. ከጠፋ (የመጀመሪያው የልውውጥ ክፍለ ጊዜ), ከዚያም እንደ እንወስዳለን row_ver ዜሮ. በመቀጠል በዑደቱ ውስጥ በተጠቀሰው ዩአርኤል ላይ ካለው ምንጭ የተለወጠውን መረጃ ከገጽ በገጽ ማውረድ እናከናውናለን። በእያንዳንዱ ድግግሞሽ, የተቀበለውን ውሂብ ወደ ተገቢው የአካባቢ ቦታ እናስቀምጠዋለን እና እሴቱን እናዘምነዋለን row_ver (በጠፈር ውስጥ row_ver እና በተለዋዋጭ row_ver) - ዋጋውን ይውሰዱ row_ver ከተጫነው የመጨረሻው መስመር.

በአጋጣሚ ማዞርን ለመከላከል (በፕሮግራሙ ውስጥ ስህተት ከተፈጠረ) ምልልሱ while ሊተካ ይችላል for:

for _ = 1, max_req do ...

ተግባሩን በመፈፀም ምክንያት sync_goods ክፍተት goods ተቀባዩ የሁሉም የጠፈር መዛግብት የቅርብ ጊዜ ስሪቶችን ይይዛል goods ምንጩ ውስጥ.

በግልጽ እንደሚታየው, የውሂብ መሰረዝ በዚህ መንገድ ሊሰራጭ አይችልም. እንደዚህ አይነት ፍላጎት ካለ, የስረዛ ምልክት መጠቀም ይችላሉ. ወደ ቦታ ያክሉ goods ቡሊያን መስክ is_deleted እና መዝገብን በአካል ከመሰረዝ ይልቅ ሎጂካዊ ስረዛን እንጠቀማለን - የመስክ ዋጋን እናስቀምጣለን። is_deleted ወደ ትርጉም true. አንዳንድ ጊዜ ከቦሊያን መስክ ይልቅ is_deleted ሜዳውን ለመጠቀም የበለጠ አመቺ ነው deleted, ይህም የመዝገቡ ምክንያታዊ ስረዛ ቀን-ሰዓት ያከማቻል. አመክንዮአዊ መሰረዝን ካደረጉ በኋላ, ለመሰረዝ ምልክት የተደረገበት መዝገብ ከምንጩ ወደ መድረሻው (ከላይ በተገለጸው ሎጂክ መሰረት) ይተላለፋል.

ቅደም ተከተል row_ver ከሌሎች ቦታዎች መረጃን ለማስተላለፍ ጥቅም ላይ ሊውል ይችላል: ለእያንዳንዱ የሚተላለፍ ቦታ የተለየ ቅደም ተከተል መፍጠር አያስፈልግም.

Tarantool DBMS ን በመጠቀም በመተግበሪያዎች ውስጥ ባለ ከፍተኛ ደረጃ የውሂብ ማባዛት ውጤታማ መንገድን ተመልክተናል።

ግኝቶች

Tarantool DBMS ከፍተኛ ጭነት ያላቸው መተግበሪያዎችን ለመፍጠር የሚስብ፣ ተስፋ ሰጪ ምርት ነው።
የከፍተኛ ደረጃ የውሂብ ማባዛት ከዝቅተኛ ደረጃ ማባዛት ይልቅ በርካታ ጥቅሞች አሉት።
በአንቀጹ ውስጥ የተብራራው የከፍተኛ ደረጃ የማባዛት ዘዴ ከመጨረሻው የልውውጥ ክፍለ ጊዜ በኋላ የተቀየሩትን መዝገቦች ብቻ በማስተላለፍ የተላለፈውን ውሂብ መጠን ለመቀነስ ያስችልዎታል።

ምንጭ: hab.com