PostgreSQL प्रश्नहरूको बल्क अप्टिमाइजेसन। किरिल बोरोविकोभ (टेन्सर)

प्रतिवेदनले अनुमति दिने केही दृष्टिकोणहरू प्रस्तुत गर्दछ SQL प्रश्नहरूको प्रदर्शन निगरानी गर्नुहोस् जब त्यहाँ प्रति दिन लाखौं हुन्छन्, र त्यहाँ सयौं निगरानी गरिएको PostgreSQL सर्भरहरू छन्।

कुन प्राविधिक समाधानहरूले हामीलाई जानकारीको यस्तो मात्रालाई कुशलतापूर्वक प्रशोधन गर्न अनुमति दिन्छ, र यसले कसरी साधारण विकासकर्ताको जीवनलाई सजिलो बनाउँछ?

कसलाई चासो छ? विशिष्ट समस्याहरू र विभिन्न अनुकूलन प्रविधिहरूको विश्लेषण SQL प्रश्नहरू र PostgreSQL मा विशिष्ट DBA समस्याहरू समाधान - तपाईं पनि सक्नुहुन्छ लेखहरूको श्रृंखला पढ्नुहोस् यस विषयमा।


मेरो नाम Kirill Borovikov हो, म प्रतिनिधित्व गर्छु टेन्सर कम्पनी। विशेष गरी, म हाम्रो कम्पनीमा डाटाबेसहरूसँग काम गर्न विशेषज्ञ छु।

आज म तपाईलाई बताउनेछु कि हामी कसरी क्वेरीहरू अप्टिमाइज गर्छौं, जब तपाईलाई एकल क्वेरीको कार्यसम्पादन "छुट्टै" गर्न आवश्यक छैन, तर सामूहिक रूपमा समस्या समाधान गर्नुहोस्। जब लाखौं अनुरोधहरू छन्, र तपाईंले केही फेला पार्न आवश्यक छ समाधान को दृष्टिकोण यो ठूलो समस्या।

सामान्यतया, हाम्रा लाखौं ग्राहकहरूको लागि टेन्सर हो VLSI हाम्रो आवेदन हो: कर्पोरेट सामाजिक सञ्जाल, भिडियो सञ्चारका लागि समाधानहरू, आन्तरिक र बाह्य कागजात प्रवाहका लागि, लेखा र गोदामहरूका लागि लेखा प्रणालीहरू,... अर्थात्, एकीकृत व्यापार व्यवस्थापनका लागि यस्तो "मेगा-कम्बाइन", जसमा १०० भन्दा बढी फरक छन्। आन्तरिक परियोजनाहरू।

तिनीहरू सबैले काम गर्छन् र सामान्य रूपमा विकास गर्छन् भनी सुनिश्चित गर्न, हामीसँग देशभर 10 विकास केन्द्रहरू छन्, तिनीहरूमा थप छन् 1000 विकासकर्ताहरू.

हामीले 2008 देखि PostgreSQL सँग काम गर्दै आएका छौं र हामीले के प्रक्रिया गर्छौं - क्लाइन्ट डेटा, सांख्यिकीय, विश्लेषणात्मक, बाह्य सूचना प्रणालीहरूबाट डेटा - को एक ठूलो रकम जम्मा गरेका छौं। 400TB भन्दा बढी। त्यहाँ उत्पादनमा मात्र 250 सर्भरहरू छन्, र कुलमा त्यहाँ लगभग 1000 डाटाबेस सर्भरहरू छन् जुन हामीले निगरानी गर्छौं।

SQL एक घोषणात्मक भाषा हो। तपाइँ "कसरी" केहि काम गर्नुपर्छ भनेर वर्णन गर्दैन, तर "के" तपाइँ हासिल गर्न चाहानुहुन्छ। DBMS लाई कसरी सामेल हुने भन्ने राम्रोसँग थाहा छ - कसरी तपाइँको तालिकाहरू जडान गर्ने, कुन सर्तहरू लागू गर्ने, के अनुक्रमणिका मार्फत जान्छ, के गर्दैन...

केही DBMS हरू संकेतहरू स्वीकार गर्छन्: "होइन, यी दुई तालिकाहरू यस्तो र यस्तो लाममा जडान गर्नुहोस्," तर PostgreSQL ले यो गर्न सक्दैन। यो अग्रणी विकासकर्ताहरूको सचेत स्थिति हो: "हामी विकासकर्ताहरूलाई केही प्रकारका संकेतहरू प्रयोग गर्न अनुमति दिनु भन्दा बरु क्वेरी अप्टिमाइजर समाप्त गर्छौं।"

तर, PostgreSQL ले "बाहिर" आफैलाई नियन्त्रण गर्न अनुमति दिँदैन भन्ने तथ्यको बावजुद, यसले पूर्ण रूपमा अनुमति दिन्छ। उहाँ भित्र के भइरहेको छ हेर्नुहोस्जब तपाइँ तपाइँको क्वेरी चलाउनुहुन्छ, र कहाँ समस्या भइरहेको छ।

सामान्यतया, विकासकर्ता [DBA मा] सामान्यतया कुन क्लासिक समस्याहरू आउँछन्? "यहाँ हामीले अनुरोध पूरा गर्यौं, र हामीसँग सबै ढिलो छ, सबै कुरा झुन्डिएको छ, केहि भइरहेको छ ... केहि प्रकारको समस्या!"

कारणहरू लगभग सधैं समान छन्:

• अकुशल क्वेरी एल्गोरिथ्म
  विकासकर्ता: "अब म उसलाई 10 टेबलहरू SQL मा JOIN मार्फत दिँदैछु..." - र आशा गर्दछ कि उसको अवस्था चमत्कारी रूपमा प्रभावकारी रूपमा "खुल्ला" हुनेछ र उसले सबै कुरा चाँडै प्राप्त गर्नेछ। तर चमत्कारहरू हुँदैनन्, र यस्तो परिवर्तनशीलताको साथ कुनै पनि प्रणाली (एक बाट 10 तालिकाहरू) सधैं केहि प्रकारको त्रुटि दिन्छ। [लेख]
• अप्रासंगिक तथ्याङ्क
  यो बिन्दु विशेष गरी PostgreSQL को लागी धेरै सान्दर्भिक छ, जब तपाईले सर्भरमा ठूलो डेटासेट "खन्याउनुहुन्छ", अनुरोध गर्नुहोस्, र यसले तपाइँको ट्याब्लेट "सेक्सकानिट" गर्छ। किनभने हिजो त्यहाँ 10 रेकर्डहरू थिए, र आज त्यहाँ 10 मिलियन छन्, तर PostgreSQL अझै यस बारे सचेत छैन, र हामीले यसको बारेमा बताउन आवश्यक छ। [लेख]
• स्रोतहरूमा "प्लग"
  तपाईंले कमजोर सर्भरमा ठूलो र भारी लोड गरिएको डाटाबेस स्थापना गर्नुभएको छ जसमा पर्याप्त डिस्क, मेमोरी, वा प्रोसेसर कार्यसम्पादन छैन। र यो सबै हो ... कतै त्यहाँ एक प्रदर्शन छत माथि छ जुन तपाईं अब उफ्रन सक्नुहुन्न।
• अवरुद्ध
  यो एक कठिन बिन्दु हो, तर तिनीहरू विभिन्न परिमार्जन प्रश्नहरूको लागि सबैभन्दा सान्दर्भिक छन् (INSERT, UPDATE, DELETE) - यो एक अलग ठूलो विषय हो।

योजना प्राप्त गर्दै

...र सबै कुराको लागि हामी योजना चाहिन्छ! हामीले सर्भर भित्र के भइरहेको छ हेर्नु पर्छ।

PostgreSQL का लागि क्वेरी कार्यान्वयन योजना पाठ प्रतिनिधित्वमा क्वेरी कार्यान्वयन एल्गोरिदमको रूख हो। यो ठ्याक्कै एल्गोरिथ्म हो कि, योजनाकार द्वारा विश्लेषण को परिणाम को रूप मा, सबै भन्दा प्रभावकारी फेला पर्यो।

प्रत्येक रूख नोड एक अपरेशन हो: तालिका वा अनुक्रमणिकाबाट डेटा पुन: प्राप्त गर्दै, बिटम्याप निर्माण गर्दै, दुई तालिकाहरू जोड्ने, जोड्ने, प्रतिच्छेदन गर्ने, वा चयनहरू बाहेक। क्वेरी कार्यान्वयन गर्दा यो रूखको नोडहरू मार्फत हिंड्नु समावेश छ।

क्वेरी योजना प्राप्त गर्न, सबैभन्दा सजिलो तरीका भनेको बयान कार्यान्वयन गर्नु हो EXPLAIN। सबै वास्तविक विशेषताहरू प्राप्त गर्न, त्यो हो, वास्तवमा आधारमा क्वेरी कार्यान्वयन गर्न - EXPLAIN (ANALYZE, BUFFERS) SELECT ....

खराब भाग: जब तपाइँ यसलाई चलाउनुहुन्छ, यो "यहाँ र अहिले" हुन्छ, त्यसैले यो स्थानीय डिबगिङको लागि मात्र उपयुक्त छ। यदि तपाईले अत्यधिक लोड गरिएको सर्भर लिनुभयो जुन डेटा परिवर्तनहरूको बलियो प्रवाह अन्तर्गत छ, र तपाईले देख्नुहुन्छ: "ओह! यहाँ हामीसँग ढिलो कार्यान्वयन छक्याम्पिङ अनुरोध।" आधा घण्टा, एक घण्टा अघि - जब तपाईं दौडिरहनुभएको थियो र लगहरूबाट यो अनुरोध प्राप्त गर्दै, सर्भरमा फिर्ता ल्याउँदै, तपाईंको सम्पूर्ण डेटासेट र तथ्याङ्कहरू परिवर्तन भयो। तपाइँ यसलाई डिबग गर्न चलाउनुहुन्छ - र यो छिटो चल्छ! र तपाईं बुझ्न सक्नुहुन्न किन, किन यो थियो बिस्तारी।

सर्भरमा अनुरोध कार्यान्वयन भएको क्षणमा के भयो भनेर बुझ्नको लागि, स्मार्ट मानिसहरूले लेखे auto_explain मोड्युल। यो लगभग सबै भन्दा साधारण PostgreSQL वितरण मा उपस्थित छ, र केवल कन्फिग फाइल मा सक्रिय गर्न सकिन्छ।

यदि यो थाहा छ कि केहि अनुरोध तपाईले बताउनुभएको सीमा भन्दा लामो चलिरहेको छ, यो गर्छ यो अनुरोधको योजनाको "स्न्यापसट" र लगमा सँगै लेख्छ.

अब सबै ठिक छ जस्तो देखिन्छ, हामी लगमा जान्छौं र त्यहाँ हेर्छौं ... [पाठ फुटक्लोथ]। तर हामी यसको बारेमा केहि भन्न सक्दैनौं, यो एक उत्कृष्ट योजना हो भन्ने तथ्य बाहेक किनभने यसले कार्यान्वयन गर्न 11ms लियो।

सबै ठीक छ जस्तो देखिन्छ - तर वास्तवमा के भयो भनेर केहि पनि स्पष्ट छैन। सामान्य समय बाहेक, हामी वास्तवमा केहि देख्दैनौं। किनभने सादा पाठको यस्तो "भेडा" हेर्दा सामान्यतया दृश्य हुँदैन।

तर यो स्पष्ट नभए पनि, असुविधाजनक भए पनि, त्यहाँ थप आधारभूत समस्याहरू छन्:

• नोडले संकेत गर्दछ सम्पूर्ण सबट्रीको स्रोतहरूको योगफल उनको अन्तर्गत। त्यो हो, तपाईले यो विशेष अनुक्रमणिका स्क्यानमा कति समय बिताएको थियो भनेर पत्ता लगाउन सक्नुहुन्न यदि त्यहाँ केही नेस्टेड अवस्था छ भने। हामीले गतिशील रूपमा हेर्नु पर्छ कि त्यहाँ "बच्चाहरू" र सशर्त चरहरू, CTEs भित्र छन् - र यी सबैलाई "हाम्रो दिमागमा" घटाउनुपर्छ।
• दोस्रो बिन्दु: नोडमा संकेत गरिएको समय हो एकल नोड कार्यान्वयन समय। यदि यो नोड परिणामको रूपमा कार्यान्वयन गरिएको थियो, उदाहरणका लागि, तालिका रेकर्डहरू मार्फत लुप धेरै पटक, त्यसपछि लूपहरूको संख्या - यो नोडको चक्र - योजनामा ​​बढ्छ। तर आणविक कार्यान्वयन समय योजनाको सन्दर्भमा उस्तै रहन्छ। त्यो हो, यो नोड कुलमा कति लामो समयसम्म प्रदर्शन गरिएको थियो बुझ्नको लागि, तपाईंले एक चीजलाई अर्कोले गुणा गर्न आवश्यक छ - फेरि, "तपाईंको टाउकोमा।"

यस्तो अवस्थामा, "सबैभन्दा कमजोर लिङ्क को हो?" बुझ्नुहोस्। लगभग असम्भव। त्यसकारण, विकासकर्ताहरूले पनि "म्यानुअल" मा लेख्छन् "योजना बुझ्नु एउटा कला हो जुन सिक्नु पर्छ, अनुभव...".

तर हामीसँग 1000 विकासकर्ताहरू छन्, र तपाईंले ती प्रत्येकलाई यो अनुभव बताउन सक्नुहुन्न। म, तिमी, उसलाई थाहा छ, तर त्यहाँको कसैलाई थाहा छैन। हुनसक्छ उसले सिक्न सक्छ, वा हुन सक्छ, तर उसले अहिले काम गर्न आवश्यक छ - र उसले यो अनुभव कहाँ पाउँछ?

योजना दृश्य

तसर्थ, हामीले महसुस गर्यौं कि यी समस्याहरूको सामना गर्न हामीले आवश्यक छ योजना को राम्रो दृश्य. [लेख]

हामी पहिले "बजार मार्फत" गयौं - के अवस्थित छ भनेर इन्टरनेटमा हेरौं।

तर यो बाहिर आयो कि त्यहाँ धेरै कम अपेक्षाकृत "प्रत्यक्ष" समाधानहरू छन् जुन कम वा कम विकासशील छन् - शाब्दिक रूपमा, केवल एक: explain.depesz.com Hubert Lubaczewski द्वारा। जब तपाइँ "फिड" फिल्डमा योजनाको पाठ प्रतिनिधित्व प्रविष्ट गर्नुहुन्छ, यसले तपाइँलाई पार्स गरिएको डेटाको साथ तालिका देखाउँदछ:

• नोडको आफ्नै प्रशोधन समय
• सम्पूर्ण सबट्रीको लागि कुल समय
• पुन: प्राप्त भएका रेकर्डहरूको संख्या जुन सांख्यिकीय रूपमा अपेक्षित थियो
• नोड शरीर आफै

यस सेवासँग लिङ्कहरूको संग्रह साझा गर्ने क्षमता पनि छ। तपाईंले आफ्नो योजना त्यहाँ फ्याँक्नुभयो र भन्नुभयो: "हे, वस्या, यहाँ एउटा लिङ्क छ, त्यहाँ केही गडबड छ।"

तर सानातिना समस्या पनि छन् ।

पहिलो, ठूलो मात्रामा "कपी-पेस्ट"। तपाईंले लगको टुक्रा लिनुहोस्, यसलाई त्यहाँ टाँस्नुहोस्, र फेरि, र फेरि।

दोश्रो, पढ्ने डाटाको मात्राको कुनै विश्लेषण छैन - उही बफर कि आउटपुट EXPLAIN (ANALYZE, BUFFERS), हामी यसलाई यहाँ देख्दैनौं। उसलाई थाहा छैन कसरी तिनीहरूलाई छुट्याउन, तिनीहरूलाई बुझ्न र तिनीहरूसँग काम गर्ने। जब तपाइँ धेरै डाटा पढ्दै हुनुहुन्छ र महसुस गर्नुहुन्छ कि तपाइँ डिस्क र मेमोरी क्यास गलत आवंटन गर्दै हुनुहुन्छ, यो जानकारी धेरै महत्त्वपूर्ण छ।

तेस्रो नकारात्मक बिन्दु यो परियोजनाको धेरै कमजोर विकास हो। कमिटहरू धेरै सानो छन्, यो राम्रो छ यदि प्रत्येक छ महिनामा एक पटक, र कोड पर्लमा छ।

तर यो सबै "गीत" हो, हामी कुनै न कुनै रूपमा यससँग बाँच्न सक्छौं, तर त्यहाँ एउटा कुरा छ जसले हामीलाई यस सेवाबाट धेरै टाढा बनायो। यी सामान्य तालिका अभिव्यक्ति (CTE) र विभिन्न गतिशील नोडहरू जस्तै InitPlan/SubPlan को विश्लेषणमा त्रुटिहरू हुन्।

यदि तपाइँ यो चित्रमा विश्वास गर्नुहुन्छ भने, प्रत्येक व्यक्तिगत नोडको कुल कार्यान्वयन समय सम्पूर्ण अनुरोधको कुल कार्यान्वयन समय भन्दा ठूलो छ। यो सरल छ - यस CTE को उत्पादन समय CTE स्क्यान नोडबाट घटाइएको छैन। त्यसकारण, हामी अब उप्रान्त CTE स्क्यान आफैले कति समय लिएको सही जवाफ थाहा छैन।

त्यसपछि हामीले महसुस गर्यौं कि यो हाम्रो आफ्नै लेख्ने समय हो - हुर्रे! प्रत्येक विकासकर्ता भन्छन्: "अब हामी आफ्नै लेख्नेछौं, यो धेरै सजिलो हुनेछ!"

हामीले वेब सेवाहरूको लागि सामान्य स्ट्याक लियौं: Node.js + Express मा आधारित कोर, सुन्दर रेखाचित्रहरूको लागि Bootstrap र D3.js भरिएको। र हाम्रा अपेक्षाहरू पूर्ण रूपमा जायज थिए - हामीले 2 हप्तामा पहिलो प्रोटोटाइप प्राप्त गर्यौं:

• अनुकूलन योजना पार्सर
  त्यो हो, अब हामी PostgreSQL द्वारा उत्पन्न गरिएका कुनै पनि योजनालाई पार्स गर्न सक्छौं।
• डायनामिक नोड्स को सही विश्लेषण - CTE स्क्यान, InitPlan, SubPlan
• बफर वितरण को विश्लेषण - जहाँ डाटा पृष्ठहरू मेमोरीबाट पढिन्छ, जहाँ स्थानीय क्यासबाट, जहाँ डिस्कबाट
• स्पष्टता प्राप्त भयो
  लगमा यी सबै "खन्न" नभई तस्विरमा तुरुन्तै "कमजोर लिङ्क" हेर्नको लागि।

हामीले यो जस्तै केहि पायौं, सिन्ट्याक्स हाइलाइट सहित। तर सामान्यतया हाम्रा विकासकर्ताहरूले योजनाको पूर्ण प्रतिनिधित्वको साथ काम गर्दैनन्, तर छोटोसँग। आखिर, हामीले पहिले नै सबै नम्बरहरू पार्स गरिसकेका छौं र तिनीहरूलाई बायाँ र दायाँ फ्याँक्यौं, र बीचमा हामीले पहिलो लाइन मात्र छोड्यौं, यो कस्तो प्रकारको नोड हो: सीटीई स्क्यान, सीटीई जेनेरेशन वा सेक स्क्यान केही चिन्ह अनुसार।

यो हामीले बोलाउने संक्षिप्त प्रतिनिधित्व हो योजना टेम्प्लेट.

अरू के सुविधाजनक हुन्थ्यो? हाम्रो कुल समयको कति हिस्सा कुन नोडमा छुट्याइएको छ भनेर हेर्नको लागि यो सुविधाजनक हुनेछ - र छेउमा "यसलाई टाँस्नुहोस्" पाइ चार्ट.

हामी नोडमा पोइन्ट गर्छौं र हेर्छौं - यो थाहा हुन्छ कि Seq स्क्यानले कुल समयको एक चौथाई भन्दा कम समय लियो, र बाँकी 3/4 CTE स्क्यान द्वारा लिइएको थियो। डरलाग्दो! यो CTE स्क्यानको "आगोको दर" को बारेमा एउटा सानो नोट हो यदि तपाईंले तिनीहरूलाई सक्रिय रूपमा आफ्नो प्रश्नहरूमा प्रयोग गर्नुहुन्छ भने। तिनीहरू धेरै छिटो छैनन् - तिनीहरू नियमित तालिका स्क्यानिङमा पनि कम छन्। [लेख] [लेख]

तर सामान्यतया त्यस्ता रेखाचित्रहरू अधिक रोचक, अधिक जटिल हुन्छन्, जब हामी तुरुन्तै खण्डमा औंल्याउँछौं र देख्छौं, उदाहरणका लागि, आधा भन्दा बढी समय केही Seq स्क्यान "खाए"। यसबाहेक, त्यहाँ कुनै प्रकारको फिल्टर थियो, त्यस अनुसार धेरै रेकर्डहरू खारेज गरिएको थियो... तपाईंले यो तस्बिर सिधै विकासकर्तालाई फ्याँक्न सक्नुहुन्छ र भन्न सक्नुहुन्छ: "वास्या, यहाँ तपाईंको लागि सबै खराब छ! यो पत्ता लगाउनुहोस्, हेर्नुहोस् - केहि गलत छ! ”

स्वाभाविक रूपमा, त्यहाँ केही "रेकहरू" संलग्न थिए।

हामीले भेट्टाएको पहिलो कुरा राउन्डिङ समस्या थियो। योजनामा ​​प्रत्येक व्यक्तिगत नोडको समय 1 μs को शुद्धता संग संकेत गरिएको छ। र जब नोड चक्रहरूको संख्या बढ्छ, उदाहरणका लागि, 1000 - कार्यान्वयन पछि PostgreSQL "शुद्धता भित्र" विभाजित हुन्छ, तब फिर्ता गणना गर्दा हामीले "कतै 0.95ms र 1.05ms बीच" कुल समय पाउँछौं। जब गणना माइक्रोसेकेन्डमा जान्छ, त्यो ठीक छ, तर जब यो पहिले नै [मिली] सेकेन्ड हुन्छ, तपाईंले यो जानकारीलाई ध्यानमा राख्नुपर्छ जब "कसले कति खपत गर्यो" योजनाको नोडहरूमा स्रोतहरू "खोल्दै"।

दोस्रो बिन्दु, अधिक जटिल, गतिशील नोडहरू बीच स्रोतहरू (ती बफरहरू) को वितरण हो। यसले हामीलाई प्रोटोटाइपको पहिलो २ हप्ता र अर्को ४ हप्ता खर्च गर्यो।

यस प्रकारको समस्या प्राप्त गर्न यो एकदम सजिलो छ - हामी CTE गर्छौं र यसमा केहि पढ्छौं। वास्तवमा, PostgreSQL "स्मार्ट" हो र त्यहाँ सिधै केहि पढ्ने छैन। त्यसपछि हामी यसबाट पहिलो रेकर्ड लिन्छौं, र त्यसमा एउटै CTE बाट एक सय र पहिलो।

हामी योजना हेर्छौं र बुझ्छौं - यो अनौठो छ, हामीसँग Seq स्क्यानमा 3 बफरहरू (डेटा पृष्ठहरू) "उपभोग" छन्, 1 थप CTE स्क्यानमा, र 2 थप दोस्रो CTE स्क्यानमा। त्यो हो, यदि हामीले केवल सबै कुरालाई जोड्यौं भने, हामीले 6 पाउनेछौं, तर ट्याब्लेटबाट हामीले 3 मात्र पढ्छौं! CTE स्क्यानले कतैबाट केहि पनि पढ्दैन, तर प्रक्रिया मेमोरीसँग सीधा काम गर्दछ। त्यो हो, यहाँ केहि स्पष्ट रूपमा गलत छ!

वास्तवमा, यो बाहिर जान्छ कि यहाँ ती सबै 3 पृष्ठहरू डाटा छन् जुन Seq स्क्यानबाट अनुरोध गरिएको थियो, पहिले 1 ले 1st CTE स्क्यानको लागि सोधेको थियो, र त्यसपछि 2 र थप 2 उहाँलाई पढेर गरिएको थियो। अर्थात्, कुल 3 पृष्ठहरू डेटा पढेका थिए, 6 होइन।

र यो तस्विरले हामीलाई योजनाको कार्यान्वयन अब रूख होइन, तर केवल एक प्रकारको एसाइक्लिक ग्राफको रूपमा बुझेको छ। र हामीले यस्तो रेखाचित्र पायौं, ताकि हामीले "पहिले कहाँबाट के आयो" भनेर बुझौं। त्यो हो, यहाँ हामीले pg_class बाट CTE सिर्जना गर्यौं, र दुई पटक सोध्यौं, र हामीले दोस्रो पटक सोध्दा हाम्रो लगभग सबै समय शाखामा बित्यो। यो स्पष्ट छ कि 2 औं प्रविष्टि पढ्नु ट्याब्लेटबाट पहिलो प्रविष्टि पढ्नु भन्दा धेरै महँगो छ।

हामीले केही बेर श्वास छोड्यौं। तिनीहरूले भने: "अब, नियो, तपाईलाई कुङ्ग फु थाहा छ! अब हाम्रो अनुभव तपाईंको स्क्रिनमा छ। अब तपाईं यसलाई प्रयोग गर्न सक्नुहुन्छ।" [लेख]

लग एकीकरण

हाम्रा 1000 विकासकर्ताहरूले राहतको सास फेरे। तर हामीले बुझ्यौं कि हामीसँग सयौं "लडाई" सर्भरहरू मात्र छन्, र विकासकर्ताहरूको तर्फबाट यो सबै "प्रतिलिपि-पेस्ट" कुनै पनि सुविधाजनक छैन। हामीले बुझ्यौं कि हामीले यसलाई आफैं सङ्कलन गर्नुपर्छ।

सामान्यतया, त्यहाँ एक मानक मोड्युल छ जसले तथ्याङ्कहरू सङ्कलन गर्न सक्छ, तथापि, यसलाई कन्फिगरेसनमा सक्रिय गर्न आवश्यक छ - यो मोड्युल pg_stat_statements। तर उहाँ हामीलाई सुहाउनुभएन।

पहिले, यसले एउटै डाटाबेस भित्र विभिन्न योजनाहरू प्रयोग गरेर एउटै प्रश्नहरूलाई असाइन गर्दछ विभिन्न QueryIds। त्यो हो, यदि तपाइँ पहिले गर्नुहुन्छ SET search_path = '01'; SELECT * FROM user LIMIT 1;र त्यसपछि SET search_path = '02'; र उही अनुरोध, तब यस मोड्युलको तथ्याङ्कमा फरक अभिलेख हुनेछ, र म योजनाहरूलाई ध्यानमा नलिई यो अनुरोध प्रोफाइलको सन्दर्भमा विशेष रूपमा सामान्य तथ्याङ्कहरू सङ्कलन गर्न सक्षम हुने छैन।

दोस्रो बिन्दु जसले हामीलाई यसलाई प्रयोग गर्नबाट रोकेको छ योजनाहरूको अभाव। अर्थात्, त्यहाँ कुनै योजना छैन, त्यहाँ केवल अनुरोध छ। हामी हेर्छौं के सुस्त थियो, तर हामी किन बुझ्दैनौं। र यहाँ हामी द्रुत रूपमा परिवर्तन हुने डेटासेटको समस्यामा फर्कन्छौं।

र अन्तिम क्षण - "तथ्य" को अभाव। त्यो हो, तपाईले क्वेरी कार्यान्वयनको एक विशेष उदाहरणलाई सम्बोधन गर्न सक्नुहुन्न - त्यहाँ कुनै पनि छैन, त्यहाँ केवल एकत्रित तथ्याङ्कहरू छन्। यद्यपि यो संग काम गर्न सम्भव छ, यो धेरै गाह्रो छ।

त्यसैले हामीले प्रतिलिपि-पेस्ट लड्ने निर्णय गर्यौं र लेख्न थाल्यौं सor्कलनकर्ता.

कलेक्टरले SSH मार्फत जडान गर्दछ, प्रमाणपत्र प्रयोग गरेर डाटाबेससँग सर्भरमा सुरक्षित जडान स्थापना गर्दछ, र tail -F लग फाइलमा यसलाई "clings"। त्यसैले यस सत्रमा हामीले सम्पूर्ण लग फाइलको पूर्ण "मिरर" पाउँछौं, जुन सर्भरले उत्पन्न गर्दछ। सर्भरमा लोड आफैंमा न्यूनतम छ, किनकि हामी त्यहाँ केहि पनि पार्स गर्दैनौं, हामी केवल ट्राफिक दर्पण गर्छौं।

हामीले Node.js मा इन्टरफेस लेख्न सुरु गरिसकेकाले, हामीले यसमा कलेक्टर लेख्न जारी राख्यौं। र यो प्रविधिले आफैलाई उचित ठहराएको छ, किनभने यो जाभास्क्रिप्ट प्रयोग गर्न को लागी कमजोर ढाँचा गरिएको पाठ डाटा संग काम गर्न को लागी धेरै सुविधाजनक छ, जुन लग हो। र ब्याकइन्ड प्लेटफर्मको रूपमा Node.js पूर्वाधारले तपाईंलाई नेटवर्क जडानहरू र वास्तवमा कुनै पनि डाटा स्ट्रिमहरूसँग सजिलै र सहज रूपमा काम गर्न अनुमति दिन्छ।

तदनुसार, हामी दुई जडानहरू "तान्त्रित" गर्छौं: पहिलो लग आफैलाई "सुन्न" र यसलाई आफैंमा लैजान, र दोस्रो आवधिक रूपमा आधार सोध्न। "तर लगले देखाउँछ कि oid 123 को साथ साइन ब्लक गरिएको छ," तर यसले विकासकर्तालाई केहि मतलब गर्दैन, र डाटाबेसलाई सोध्नु राम्रो हुन्छ, "OID = 123 के हो?" र यसैले हामी आवधिक रूपमा आधारलाई सोध्छौं कि हामीले आफ्नो बारेमा अझै थाहा छैनौं।

"तपाईले ध्यान नदिनुभएको एउटा मात्र कुरा छ, त्यहाँ हात्ती जस्तो मौरीको प्रजाति छ!...।" हामीले यो प्रणाली विकास गर्न थाल्यौं जब हामी 10 सर्भरहरू निगरानी गर्न चाहन्छौं। हाम्रो बुझाइमा सबैभन्दा महत्त्वपूर्ण, जहाँ केही समस्याहरू देखा परेका थिए जुन सामना गर्न गाह्रो थियो। तर पहिलो क्वाटरमा, हामीले अनुगमनका लागि सय प्राप्त गर्‍यौं - किनभने प्रणालीले काम गर्‍यो, सबैले यो चाहन्थे, सबैलाई सहज थियो।

यो सबै थप्न आवश्यक छ, डाटा प्रवाह ठूलो र सक्रिय छ। वास्तवमा, हामीले के अनुगमन गर्छौं, केसँग व्यवहार गर्न सक्छौं, हामीले के प्रयोग गर्छौं। हामी PostgreSQL लाई डाटा भण्डारणको रूपमा पनि प्रयोग गर्छौं। र अपरेटर भन्दा यसमा डाटा "खन्याउन" छिटो केहि छैन COPY अझै छैन।

तर केवल "खन्याउने" डाटा वास्तवमा हाम्रो प्रविधि होइन। किनकि यदि तपाइँसँग सय सर्भरहरूमा प्रति सेकेन्ड लगभग 50k अनुरोधहरू छन् भने, त्यसपछि यसले प्रति दिन 100-150GB लगहरू उत्पन्न गर्नेछ। त्यसकारण, हामीले ध्यानपूर्वक आधार "कट" गर्नुपर्‍यो।

पहिलो, हामीले गर्यौं दिन द्वारा विभाजन, किनकि, समग्रमा, दिनहरू बीचको सम्बन्धमा कसैलाई चासो छैन। के फरक पार्छ तपाईसँग हिजो के थियो, यदि आज राति तपाईले अनुप्रयोगको नयाँ संस्करण रोल आउट गर्नुभयो - र पहिले नै केही नयाँ तथ्याङ्कहरू।

दोस्रो, हामीले सिकेका थियौं (बाध्य) धेरै, धेरै छिटो प्रयोग गरेर लेख्न COPY। अर्थात् मात्र होइन COPYकिनभने ऊ भन्दा छिटो छ INSERT, र अझ छिटो।

तेस्रो बिन्दु - मलाई थियो क्रमशः ट्रिगरहरू र विदेशी कुञ्जीहरू त्याग्नुहोस्। अर्थात्, हामीसँग कुनै सन्दर्भात्मक अखण्डता छैन। किनभने यदि तपाइँसँग FKs को एक जोडी भएको तालिका छ, र तपाइँ डाटाबेस संरचनामा भन्नुहुन्छ कि "यहाँ एउटा लग रेकर्ड छ जुन FK द्वारा सन्दर्भ गरिएको छ, उदाहरणका लागि, रेकर्डहरूको समूहमा," तब जब तपाइँ यसलाई सम्मिलित गर्नुहुन्छ, PostgreSQL यसलाई कसरी लिने र इमान्दारीपूर्वक गर्ने बाहेक केही बाँकी छैन SELECT 1 FROM master_fk1_table WHERE ... तपाईले सम्मिलित गर्न खोज्नु भएको पहिचानकर्ताको साथ - यो रेकर्ड त्यहाँ अवस्थित छ भनेर जाँच गर्नको लागि, तपाईले आफ्नो प्रविष्टिको साथ यो विदेशी कुञ्जी "ब्रेक अफ" नगर्नु भएको छ।

लक्ष्य तालिका र यसको अनुक्रमणिकामा एउटै रेकर्डको सट्टा, हामीले यसले सन्दर्भ गर्ने सबै तालिकाहरूबाट पढ्नको थप लाभ पाउँछौं। तर हामीलाई यो आवश्यक पर्दैन - हाम्रो कार्य भनेको सकेसम्म धेरै र सकेसम्म चाँडो न्यूनतम लोडको साथ रेकर्ड गर्नु हो। त्यसैले FK - तल!

अर्को बिन्दु एकीकरण र ह्यासिङ हो। सुरुमा, हामीले तिनीहरूलाई डाटाबेसमा लागू गर्यौं - आखिर, यो तुरुन्तै सुविधाजनक छ, जब रेकर्ड आउँछ, यसलाई कुनै प्रकारको ट्याब्लेटमा गर्नुहोस्। ट्रिगरमा "प्लस वन"। खैर, यो सुविधाजनक छ, तर एउटै खराब कुरा - तपाइँ एउटा रेकर्ड सम्मिलित गर्नुहुन्छ, तर अर्को तालिकाबाट केहि पढ्न र लेख्न बाध्य छन्। यसबाहेक, तपाईं पढ्न र लेख्न मात्र होइन, तपाईं पनि हरेक पटक गर्नुहुन्छ।

अब कल्पना गर्नुहोस् कि तपाइँसँग एउटा तालिका छ जसमा तपाइँ केवल एक विशेष होस्ट मार्फत पारित भएका अनुरोधहरूको संख्या गणना गर्नुहुन्छ: +1, +1, +1, ..., +1। र तपाइँ, सिद्धान्त मा, यो आवश्यक छैन - यो सबै सम्भव छ कलेक्टरमा मेमोरीमा योग र डाटाबेसमा एकै पटक पठाउनुहोस् +10.

हो, केहि समस्याहरूको अवस्थामा, तपाइँको तार्किक अखण्डता "छुट्टै खस्न" सक्छ, तर यो लगभग अवास्तविक मामला हो - किनकि तपाइँसँग सामान्य सर्भर छ, यसको नियन्त्रकमा ब्याट्री छ, तपाइँसँग लेनदेन लग छ, लगमा लग छ। फाइल प्रणाली... सामान्यतया, यो यसको लायक छैन। तपाईंले चालु ट्रिगरहरू/FK बाट प्राप्त गर्ने उत्पादकताको हानि तपाईंले गर्नुहुने खर्चको लायक छैन।

ह्यासिङको कुरा पनि त्यस्तै हो। एउटा निश्चित अनुरोध तपाईलाई आउँछ, तपाईले डेटाबेसमा त्यसबाट निश्चित पहिचानकर्ता गणना गर्नुहुन्छ, यसलाई डेटाबेसमा लेख्नुहोस् र त्यसपछि सबैलाई बताउनुहोस्। सबै कुरा ठीक छ जबसम्म, रेकर्डिङको समयमा, एक दोस्रो व्यक्ति तपाईंकहाँ आउँछ जसले एउटै कुरा रेकर्ड गर्न चाहन्छ - र तपाईंलाई रोक लगाइन्छ, र यो पहिले नै खराब छ। तसर्थ, यदि तपाइँ ग्राहकमा (डेटाबेसको सापेक्ष) को लागी केहि आईडी को उत्पादन स्थानान्तरण गर्न सक्नुहुन्छ, यो गर्न राम्रो छ।

हाम्रो लागि पाठ - अनुरोध, योजना, टेम्प्लेट, ... बाट MD5 प्रयोग गर्नको लागि यो एकदम सही थियो। हामी यसलाई कलेक्टर साइडमा गणना गर्छौं, र डाटाबेसमा तयार-निर्मित ID "खन्याउछौं"। MD5 को लम्बाइ र दैनिक विभाजनले हामीलाई सम्भावित टक्करहरूको बारेमा चिन्ता नगर्न अनुमति दिन्छ।

तर यो सबै छिटो रेकर्ड गर्न, हामीले रेकर्डिङ प्रक्रिया आफै परिमार्जन गर्न आवश्यक थियो।

तपाइँ सामान्यतया डाटा कसरी लेख्नुहुन्छ? हामीसँग केहि प्रकारको डेटासेट छ, हामीले यसलाई धेरै तालिकाहरूमा विभाजन गर्छौं, र त्यसपछि यसलाई प्रतिलिपि गर्छौं - पहिले पहिलोमा, त्यसपछि दोस्रोमा, तेस्रोमा... यो असुविधाजनक छ, किनकि हामीले तीन चरणहरूमा एउटा डेटा स्ट्रिम लेखिरहेका छौं जस्तो देखिन्छ। क्रमशः। अप्रिय। के यो छिटो गर्न सकिन्छ? सक्छ!

यो गर्नका लागि, यी प्रवाहहरूलाई एकअर्कासँग समानान्तरमा विघटन गर्न पर्याप्त छ। हामीसँग त्रुटिहरू, अनुरोधहरू, टेम्प्लेटहरू, अवरुद्धहरू, ... छुट्टै थ्रेडहरूमा उडिरहेका छन् - र हामी यो सबै समानान्तरमा लेख्छौं। यसको लागि पर्याप्त छ प्रत्येक व्यक्तिगत लक्ष्य तालिकाको लागि एक प्रतिलिपि च्यानल निरन्तर खुला राख्नुहोस्.

अर्थात् कलेक्टरमा त्यहाँ सधैं एक धारा छ, जसमा म मलाई चाहिने डाटा लेख्न सक्छु। तर ताकि डाटाबेसले यो डाटा देख्छ, र कोही यो डाटा लेख्नको लागि पर्खँदै अड्किएन, COPY निश्चित अन्तरालहरूमा अवरुद्ध हुनुपर्छ। हाम्रो लागि, सबैभन्दा प्रभावकारी अवधि लगभग 100ms थियो - हामी यसलाई बन्द गर्छौं र तुरुन्तै उही तालिकामा फेरि खोल्छौं। र यदि हामीसँग केही चुचुराहरूमा एक प्रवाह पर्याप्त छैन भने, त्यसपछि हामी एक निश्चित सीमा सम्म पूलिङ गर्छौं।

थप रूपमा, हामीले पत्ता लगायौं कि यस्तो लोड प्रोफाइलको लागि, कुनै पनि एकत्रीकरण, जब रेकर्डहरू ब्याचहरूमा सङ्कलन गरिन्छ, खराब हुन्छ। क्लासिक खराब छ INSERT ... VALUES र थप 1000 रेकर्डहरू। किनभने त्यस बिन्दुमा तपाइँसँग मिडियामा लेखन शिखर छ, र डिस्कमा केहि लेख्ने प्रयास गर्ने सबैजना पर्खिरहेका छन्।

त्यस्ता विसंगतिहरूबाट छुटकारा पाउन, केवल केहि पनि जम्मा नगर्नुहोस्, बिल्कुल बफर नगर्नुहोस्। र यदि डिस्कमा बफरिङ हुन्छ (भाग्यवश, Node.js मा स्ट्रिम API ले तपाईंलाई पत्ता लगाउन अनुमति दिन्छ) - यो जडान स्थगित गर्नुहोस्। जब तपाइँ एक घटना प्राप्त गर्नुहुन्छ कि यो फेरि नि: शुल्क छ, संचित लामबाट यसलाई लेख्नुहोस्। र यो व्यस्त हुँदा, पूलबाट अर्को नि:शुल्क लिनुहोस् र यसमा लेख्नुहोस्।

डाटा रेकर्डिङमा यो दृष्टिकोण प्रस्तुत गर्नु अघि, हामीसँग लगभग 4K लेखन अपहरू थिए, र यस तरिकाले हामीले लोडलाई 4 पटक घटायौं। अब तिनीहरू नयाँ निगरानी गरिएका डाटाबेसहरूको कारणले अर्को 6 गुणा बढेका छन् - 100MB/s सम्म। र अब हामी लगभग 3-10TB को भोल्युममा पछिल्लो 15 महिनाको लगहरू भण्डारण गर्छौं, आशा छ कि केवल तीन महिनामा कुनै पनि विकासकर्ताले कुनै पनि समस्या समाधान गर्न सक्षम हुनेछ।

हामीले समस्या बुझेका छौं

तर केवल यो सबै डाटा सङ्कलन राम्रो, उपयोगी, सान्दर्भिक छ, तर पर्याप्त छैन - यो बुझ्न आवश्यक छ। किनभने यी प्रति दिन लाखौं विभिन्न योजनाहरू हुन्।

तर लाखौं अव्यवस्थित छन्, हामीले पहिले "सानो" गर्नुपर्छ। र, सबै भन्दा पहिले, तपाईंले यो "सानो" कुरालाई कसरी व्यवस्थित गर्ने भनेर निर्णय गर्न आवश्यक छ।

हामीले तीन मुख्य बुँदाहरू पहिचान गरेका छौं:

• को यो अनुरोध पठायो
  त्यो हो, कुन अनुप्रयोगबाट यो "आगमन" भयो: वेब इन्टरफेस, ब्याकइन्ड, भुक्तानी प्रणाली वा अन्य केहि।
• जहाँ यो भयो
  कुन विशिष्ट सर्भरमा? किनभने यदि तपाइँसँग एउटै एप्लिकेसन अन्तर्गत धेरै सर्भरहरू छन्, र अचानक एउटा "बेवकूफ जान्छ" (किनकि "डिस्क सडेको छ", "मेमोरी लीक भयो", केहि अन्य समस्या), त्यसपछि तपाइँले विशेष रूपमा सर्भरलाई सम्बोधन गर्न आवश्यक छ।
• कसरी समस्या एक वा अर्को तरिकामा प्रकट भएको छ

"कसले" हामीलाई अनुरोध पठाएको बुझ्नको लागि, हामी एक मानक उपकरण प्रयोग गर्छौं - एक सत्र चर सेटिङ: SET application_name = '{bl-host}:{bl-method}'; - हामी अनुरोध आउँदै गरेको व्यवसाय तर्क होस्टको नाम, र यसलाई सुरु गर्ने विधि वा अनुप्रयोगको नाम पठाउँछौं।

हामीले अनुरोधको "मालिक" पास गरिसकेपछि, यो लगमा आउटपुट हुनुपर्छ - यसका लागि हामी चर कन्फिगर गर्छौं। log_line_prefix = ' %m [%p:%v] [%d] %r %a'। इच्छुक व्यक्तिहरूको लागि, हुनसक्छ म्यानुअलमा हेर्नुहोस्यो सबैको अर्थ के हो। यो बाहिर जान्छ कि हामी लग मा देख्छौं:

• время
• प्रक्रिया र लेनदेन पहिचानकर्ताहरू
• डाटाबेस नाम
• यो अनुरोध पठाउने व्यक्तिको IP
• र विधि नाम

त्यसपछि हामीले महसुस गर्यौं कि विभिन्न सर्भरहरू बीचको एक अनुरोधको लागि सहसंबंध हेर्न यो धेरै रोचक छैन। यो प्रायः होइन कि तपाइँसँग एक परिस्थिति छ जहाँ एक आवेदन यहाँ र त्यहाँ समान रूपमा स्क्रू हुन्छ। तर यदि यो समान छ भने, यी सर्भरहरू मध्ये कुनै पनि हेर्नुहोस्।

त्यसैले यहाँ कट छ "एक सर्भर - एक दिन" यो कुनै पनि विश्लेषणको लागि हाम्रो लागि पर्याप्त भयो।

पहिलो विश्लेषणात्मक खण्ड उस्तै छ "नमूना" - योजनाको प्रस्तुतीकरणको संक्षिप्त रूप, सबै संख्यात्मक सूचकहरूबाट हटाइएको। दोस्रो कट भनेको एप्लिकेसन वा विधि हो, र तेस्रो कट विशेष योजना नोड हो जसले हामीलाई समस्याहरू निम्त्यायो।

जब हामी विशिष्ट उदाहरणहरूबाट टेम्प्लेटहरूमा सारियो, हामीले एकैचोटि दुईवटा फाइदाहरू पायौं:

• विश्लेषणका लागि वस्तुहरूको संख्यामा धेरै कमी
  हामीले समस्यालाई हजारौं प्रश्न वा योजनाहरूद्वारा होइन, दर्जनौं टेम्प्लेटहरूद्वारा विश्लेषण गर्नुपर्छ।
• समय रेखा
  त्यो हो, एक निश्चित खण्ड भित्र "तथ्यहरू" संक्षेप गरेर, तपाईं दिनको समयमा तिनीहरूको उपस्थिति प्रदर्शन गर्न सक्नुहुन्छ। र यहाँ तपाइँ बुझ्न सक्नुहुन्छ कि यदि तपाइँसँग केहि प्रकारको ढाँचा छ जुन हुन्छ, उदाहरणका लागि, एक घण्टामा एक पटक, तर यो दिनमा एक पटक हुनुपर्दछ, तपाइँले के गल्ती भयो भनेर सोच्नु पर्छ - कसले गर्यो र किन, सायद यो यहाँ हुनुपर्छ। हुदैन। यो अर्को गैर-संख्यात्मक, विशुद्ध दृश्य, विश्लेषणको विधि हो।

बाँकी विधिहरू हामीले योजनाबाट निकाल्ने संकेतकहरूमा आधारित छन्: कति पटक यस्तो ढाँचा भयो, कुल र औसत समय, डिस्कबाट कति डाटा पढियो, र मेमोरीबाट कति...

किनभने, उदाहरणका लागि, तपाइँ होस्टको लागि विश्लेषण पृष्ठमा आउनुहुन्छ, हेर्नुहोस् - केहि डिस्कमा धेरै पढ्न सुरु हुँदैछ। सर्भरमा रहेको डिस्कले यसलाई ह्यान्डल गर्न सक्दैन - कसले यसलाई पढ्छ?

र तपाइँ कुनै पनि स्तम्भ द्वारा क्रमबद्ध गर्न सक्नुहुन्छ र निर्णय गर्न सक्नुहुन्छ कि तपाइँ अहिले केसँग व्यवहार गर्नुहुन्छ - प्रोसेसर वा डिस्कमा लोड, वा अनुरोधहरूको कुल संख्या... हामीले यसलाई क्रमबद्ध गर्यौं, "शीर्ष" लाई हेर्नुभयो, यसलाई निश्चित गर्नुभयो र अनुप्रयोगको नयाँ संस्करण रोल आउट।
[भिडियो व्याख्यान]

र तुरुन्तै तपाईले बिभिन्न एप्लिकेसनहरू देख्न सक्नुहुन्छ जुन अनुरोधबाट एउटै टेम्प्लेटको साथ आउँदछ SELECT * FROM users WHERE login = 'Vasya'। फ्रन्टएन्ड, ब्याकएन्ड, प्रशोधन... र तपाइँ आश्चर्यचकित हुनुहुन्छ कि किन प्रशोधनले प्रयोगकर्तासँग अन्तर्क्रिया गर्दैन भने उसले पढ्ने हो।

विपरित तरिका भनेको तुरुन्तै अनुप्रयोगबाट हेर्नु हो कि यसले के गर्छ। उदाहरणका लागि, फ्रन्टएन्ड यो, यो, यो, र यो एक घण्टामा एक पटक हो (समयरेखाले मद्दत गर्दछ)। र प्रश्न तुरुन्तै उठ्छ: यस्तो देखिन्छ कि यो एक घण्टामा एक पटक केहि गर्न फ्रन्टएन्डको काम होइन ...

केहि समय पछि, हामीले महसुस गर्‍यौं कि हामीसँग जम्मा भएको छैन योजना नोड्स द्वारा तथ्याङ्क। हामीले योजनाहरूबाट मात्र ती नोडहरू अलग गर्यौं जसले तालिकाहरूको डेटा आफैंसँग केही गर्छ (पढ्नुहोस्/सूचकाङ्कद्वारा लेख्नुहोस् वा होइन)। वास्तवमा, अघिल्लो तस्विरको सापेक्ष केवल एउटा पक्ष थपिएको छ - यो नोडले हामीलाई कति रेकर्डहरू ल्यायो?, र कति खारेज गरियो (फिल्टर द्वारा हटाइएका पङ्क्तिहरू)।

तपाइँसँग प्लेटमा उपयुक्त अनुक्रमणिका छैन, तपाइँ यसलाई अनुरोध गर्नुहुन्छ, यो अनुक्रमणिकाको पछाडि उड्छ, सेक स्क्यानमा पर्दछ ... तपाइँले एउटा बाहेक सबै रेकर्डहरू फिल्टर गर्नुभयो। तपाईलाई प्रति दिन 100M फिल्टर गरिएका रेकर्डहरू किन चाहिन्छ? अनुक्रमणिका रोल अप गर्नु राम्रो होइन?

नोडद्वारा सबै योजना नोडहरू विश्लेषण गरिसकेपछि, हामीले महसुस गर्यौं कि योजनाहरूमा केही विशिष्ट संरचनाहरू छन् जुन शंकास्पद देखिन्छन्। र यो विकासकर्तालाई भन्न राम्रो हुनेछ: "मित्र, यहाँ तपाइँ पहिले अनुक्रमणिका द्वारा पढ्नुहुन्छ, त्यसपछि क्रमबद्ध गर्नुहोस्, र त्यसपछि काट्नुहोस्" - नियमको रूपमा, त्यहाँ एउटा रेकर्ड छ।

प्रश्नहरू लेख्ने सबैले सायद यो ढाँचाको सामना गरेका छन्: "मलाई Vasya को लागि अन्तिम अर्डर दिनुहोस्, यसको मिति।" र यदि तपाईंसँग मिति अनुसार अनुक्रमणिका छैन, वा तपाईंले प्रयोग गर्नुभएको अनुक्रमणिकामा कुनै मिति छैन भने, तब तपाईंले ठ्याक्कै उही "रेक" मा कदम।

तर हामीलाई थाहा छ कि यो "रेक" हो - त्यसोभए किन तुरुन्तै विकासकर्तालाई उसले के गर्नु पर्छ भनेर बताउनुहुन्न। तदनुसार, अहिले एउटा योजना खोल्दा, हाम्रो विकासकर्ताले तुरुन्तै सुझावहरूको साथ एउटा सुन्दर तस्विर देख्छन्, जहाँ उनीहरूले तुरुन्तै उहाँलाई यसो भन्छन्: "तपाईंलाई यहाँ र त्यहाँ समस्याहरू छन्, तर तिनीहरू यसरी र त्यसरी समाधान हुन्छन्।"

नतिजाको रूपमा, अनुभवको मात्रा जुन सुरुमा समस्याहरू समाधान गर्न आवश्यक थियो र अहिले उल्लेखनीय रूपमा घटेको छ। यो हामीसँग भएको उपकरण हो।

स्रोत: www.habr.com