घर Instagram

1सी वर्चुअल टेबल बैलेंस और टर्नओवर। क्वेरी बैच टैब

मैंने अपना योगदान देने और भाषा की उन विशेषताओं का वर्णन करने का निर्णय लिया जिनकी चर्चा उपरोक्त लेखों में नहीं की गई थी। यह लेख शुरुआती डेवलपर्स के लिए लक्षित है।

1. "IZ" डिज़ाइन।

डेटाबेस से डेटा प्राप्त करने के लिए, "FROM" निर्माण का उपयोग करना बिल्कुल भी आवश्यक नहीं है।
उदाहरण: हमें बैंक निर्देशिका से बैंकों के बारे में सभी जानकारी का चयन करना होगा।
अनुरोध:

निर्देशिका चुनें.बैंक.*

बैंक निर्देशिका से सभी फ़ील्ड का चयन करता है। और अनुरोध के समान है:

बैंकों का चयन करें। * निर्देशिका से। बैंकों के रूप में बैंक

2. संदर्भ फ़ील्ड द्वारा डेटा ऑर्डर करना

जब हमें क्वेरी डेटा को आदिम प्रकारों द्वारा व्यवस्थित करने की आवश्यकता होती है: "स्ट्रिंग", "नंबर", "दिनांक", आदि, तो यदि आपको किसी संदर्भ फ़ील्ड द्वारा डेटा को ऑर्डर करने की आवश्यकता है तो "ऑर्डर बाय" निर्माण का उपयोग करके सब कुछ हल किया जाता है? संदर्भ फ़ील्ड एक लिंक, एक विशिष्ट पहचानकर्ता है, अर्थात। मोटे तौर पर कहें तो, पात्रों का कुछ मनमाना सेट और सामान्य क्रम ऐसा परिणाम दे सकता है जो पूरी तरह से अपेक्षित नहीं है। संदर्भ फ़ील्ड को ऑर्डर करने के लिए, "ऑटो ऑर्डर" निर्माण का उपयोग किया जाता है। ऐसा करने के लिए, आपको पहले "ऑर्डर बाय" निर्माण और फिर "ऑटो ऑर्डर" निर्माण का उपयोग करके सीधे संदर्भ प्रकार द्वारा डेटा को ऑर्डर करना होगा।

इस मामले में, दस्तावेज़ों के लिए ऑर्डर "दिनांक->संख्या" क्रम में होगा, संदर्भ पुस्तकों के लिए "मुख्य दृश्य" में होगा। यदि ऑर्डरिंग संदर्भ फ़ील्ड द्वारा नहीं होती है, तो "ऑटो ऑर्डर" निर्माण का उपयोग करने की अनुशंसा नहीं की जाती है।

कुछ मामलों में, "ऑटो ऑर्डर" निर्माण चयन प्रक्रिया को धीमा कर सकता है। इसी तरह, आप दस्तावेज़ों के लिए ऑटो-ऑर्डर किए बिना फिर से लिख सकते हैं:

3. एक संदर्भ प्रकार का पाठ प्रतिनिधित्व प्राप्त करना। "प्रस्तुति" डिज़ाइन.

जब आपको एक संदर्भ प्रकार का फ़ील्ड प्रदर्शित करने की आवश्यकता होती है, उदाहरण के लिए, "बैंक" फ़ील्ड, जो "बैंक" निर्देशिका के एक तत्व का लिंक है, तो आपको यह समझने की आवश्यकता है कि इस फ़ील्ड को प्रदर्शित करते समय, " निर्देशिका का दृश्य प्राप्त करने के लिए बैंक निर्देशिका स्वचालित रूप से निष्पादित की जाएगी। इससे डेटा आउटपुट धीमा हो जाएगा. इससे बचने के लिए, आपको ऑब्जेक्ट का प्रतिनिधित्व तुरंत प्राप्त करने और फिर उसे देखने के लिए प्रदर्शित करने के लिए अनुरोध में "प्रस्तुति" निर्माण का उपयोग करने की आवश्यकता है।

डेटा संरचना प्रणाली में, इस तंत्र का उपयोग डिफ़ॉल्ट रूप से किया जाता है, लेकिन कोशिकाओं में लेआउट बनाते समय, आपको संदर्भ फ़ील्ड का प्रतिनिधित्व निर्दिष्ट करना चाहिए, और, उदाहरण के लिए, लिंक को प्रतिलेख में ही रखना चाहिए।

4. टेम्पलेट के अनुसार डेटा का नमूना लेने की शर्त।

उदाहरण के लिए, आपको फॉर्म (8 -123- 456-78-912) के कर्मचारियों के मोबाइल फोन प्राप्त करने होंगे। ऐसा करने के लिए, आपको अनुरोध में निम्नलिखित शर्त निर्धारित करनी होगी:

निर्देशिका से कर्मचारी.नाम, कर्मचारी.फोन को फोन के रूप में चुनें। कर्मचारियों को कर्मचारियों के रूप में चुनें जहां फोन "____-___-__-__" जैसा हो।

"_" वर्ण एक सेवा वर्ण है और किसी भी वर्ण को प्रतिस्थापित करता है।

5. योग और समूह का एक साथ उपयोग।

योग का उपयोग अक्सर समूहों के साथ संयोजन में किया जाता है; इस मामले में, कुल कार्यों को योग में निर्दिष्ट नहीं किया जा सकता है।

सेवाओं का प्रावधान चुनें। संगठन के रूप में संगठन, सेवाओं का प्रावधान। नामकरण के रूप में नामकरण, एसयूएम (सेवाओं का प्रावधान। दस्तावेज़ की मात्रा) दस्तावेज़ से दस्तावेज़ का योग। सेवाओं का प्रावधान सेवाओं के प्रावधान के रूप में सेवाओं का समूह। सेवाओं का प्रावधान। संगठन, प्रावधान सेवाओं का नामकरण सामान्य, संगठन, नामकरण क्लातुरा द्वारा परिणाम

इस स्थिति में, क्वेरी लगभग निम्न क्वेरी के समान ही वापस आएगी:

सेवाओं के प्रावधान का चयन करें। संगठन के रूप में संगठन, सेवाओं का प्रावधान। नामकरण के रूप में नामकरण, सेवाओं का प्रावधान। दस्तावेज़ की मात्रा दस्तावेज़ से दस्तावेज़ की मात्रा। सेवाओं के प्रावधान के रूप में सेवाओं का प्रावधान परिणाम राशि (दस्तावेज़ की मात्रा) सामान्य, संगठन द्वारा, नामपद्धति

केवल पहली क्वेरी ही समान नामकरण वाले रिकॉर्ड को संक्षिप्त कर देगी।

6. असंदर्भित क्षेत्र।

किसी बिंदु के माध्यम से फ़ील्ड्स को संदर्भित करना रेफरेंस फ़ील्ड डीरेफ़रेंसिंग ऑपरेशन कहलाता है। उदाहरण के लिए भुगतान.संगठन.प्रशासनिक इकाई. इस मामले में, "भुगतान" दस्तावेज़ के संदर्भ क्षेत्र "संगठन" में, यह एक अन्य तालिका "संगठन" को संदर्भित करता है, जिसमें "प्रशासनिक इकाई" विशेषता का मूल्य प्राप्त किया जाएगा। यह समझना महत्वपूर्ण है कि एक बिंदु के माध्यम से फ़ील्ड तक पहुंचने पर, प्लेटफ़ॉर्म अंतर्निहित रूप से एक सबक्वेरी बनाता है और इन तालिकाओं में शामिल हो जाता है।

अनुरोध:

इस प्रकार दर्शाया जा सकता है:

भुगतान.लिंक, भुगतान.संगठन, भुगतान.संगठन, संगठन चुनें। दस्तावेज़ से प्रशासनिक इकाई। भुगतान के रूप में भुगतान बाईं ओर निर्देशिका में शामिल हों। संगठन सॉफ्टवेयर संगठनों के रूप में भुगतान। संगठन = संगठन। लिंक

किसी समग्र प्रकार के संदर्भ फ़ील्ड को डीरेफ़रेंस करते समय, फ़्रेमवर्क उन सभी तालिकाओं में अंतर्निहित जोड़ बनाने का प्रयास करता है जो उस फ़ील्ड के प्रकार का हिस्सा हैं। इस मामले में, क्वेरी इष्टतम नहीं होगी। यदि यह स्पष्ट रूप से ज्ञात है कि यह किस प्रकार का फ़ील्ड है, तो ऐसे फ़ील्ड को एक निर्माण के साथ प्रकार के अनुसार सीमित करना आवश्यक है अभिव्यक्त करना().

उदाहरण के लिए, एक संचय रजिस्टर "अवितरित भुगतान" है, जहां कई दस्तावेज़ रजिस्ट्रार के रूप में कार्य कर सकते हैं। इस मामले में, रजिस्ट्रार विवरण के मान इस प्रकार प्राप्त करना गलत है:

रजिस्टर संचयन से UnallocatedPayments.Register.Date, ..... का चयन UnallocatedPayments के रूप में करें।

आपको समग्र फ़ील्ड के प्रकार को लॉगर तक सीमित रखना चाहिए:

रजिस्टर एक्युमुलेशन से एक्सप्रेस(अनअलोकेटेडपेमेंट्स.रजिस्टर एज़ डॉक्यूमेंट.पेमेंट्स).दिनांक, ..... चुनें। अनअलोकेटेडपेमेंट्स एज़ अनअलोकेटेडपेमेंट्स

7. निर्माण "कहां"

दो तालिकाओं के बाएं जोड़ के साथ, जब आप दाहिनी तालिका पर "कहां" शर्त लगाते हैं, तो हमें तालिकाओं के आंतरिक जुड़ाव के परिणाम के समान परिणाम मिलेगा।

उदाहरण। ग्राहक निर्देशिका से सभी ग्राहकों का चयन करना आवश्यक है और उन ग्राहकों के लिए जिनके पास "संगठन" = &संगठन विशेषता के मूल्य के साथ भुगतान दस्तावेज़ है, दस्तावेज़ "भुगतान" प्रदर्शित करें, जिनके पास नहीं है, वे इसे प्रदर्शित न करें।

क्वेरी का परिणाम केवल उन ग्राहकों के लिए रिकॉर्ड लौटाएगा जिनके पास पैरामीटर में संगठन द्वारा भुगतान था, और अन्य ग्राहकों को फ़िल्टर कर देगा। इसलिए, आपको पहले "ऐसे और ऐसे" संगठन के लिए सभी भुगतान एक अस्थायी तालिका में प्राप्त करना होगा, और फिर इसे बाएं जोड़ का उपयोग करके "क्लाइंट" निर्देशिका से कनेक्ट करना होगा।

भुगतान का चयन करें। भुगतान के रूप में लिंक करें, भुगतान। ग्राहक के रूप में शेयरधारक दस्तावेज़ से भुगतान का स्थान। भुगतान के रूप में भुगतान जहां भुगतान। शाखा = &शाखा; ///////////////////////////////////////////// // /////////////////////////////////////////////////////////////////////////////////////////////////////////////////// चयन करें। ग्राहक के रूप में लिंक करें, ISNULL(tPayment.Payment, "") निर्देशिका से भुगतान के रूप में। ग्राहक AS ग्राहकों ने भुगतान से कनेक्शन छोड़ दिया, भुगतान सॉफ़्टवेयर क्लाइंट के रूप में। लिंक = भुगतान से।ग्राहक

आप इस स्थिति से दूसरे तरीके से निपट सकते हैं। दो तालिकाओं के बीच संबंध पर सीधे "कहां" शर्त लागू करना आवश्यक है। उदाहरण:

ग्राहकों का चयन करें। लिंक, भुगतान। निर्देशिका से लिंक। यूएस_सब्सक्राइबर के रूप में यूएस_सब्सक्राइबर ने कनेक्शन दस्तावेज़ छोड़ दिया। भुगतान सॉफ्टवेयर के रूप में भुगतान (क्लाइंट। लिंक = भुगतान। क्लाइंट और भुगतान। क्लाइंट का नाम "चीनी पैकेट" जैसा) ग्राहकों द्वारा समूह। लिंक, भुगतान। जोड़ना

8. नेस्टेड और वर्चुअल टेबल्स के साथ जुड़ता है

नेस्टेड क्वेरीज़कुछ स्थितियों के आधार पर डेटा पुनः प्राप्त करना अक्सर आवश्यक होता है। यदि आप उन्हें अन्य तालिकाओं के साथ संयोजन में उपयोग करते हैं, तो यह क्वेरी के निष्पादन को गंभीर रूप से धीमा कर सकता है।

उदाहरण के लिए, हमें कुछ ग्राहकों के लिए वर्तमान तिथि तक शेष राशि प्राप्त करने की आवश्यकता है।

UnallocatedPaymentsRemains.Customer का चयन करें, UnallocatedPaymentsRemains.AmountRemaining FROM (ग्राहकों का चयन करें। डायरेक्ट्री से लिंक के रूप में लिंक करें। क्लाइंट जहां क्लाइंट हैं वहां क्लाइंट के रूप में लिंक करें। (&Clients)) नेस्टेडक्वेरी के बाईं ओर रजिस्टर Accumulations.UnallocatedPayments.Balances को नेस्टेड अनुरोध द्वारा UnallocatedPayments के रूप में चुनें। लिंक = असंबद्ध भुगतान शेष। ग्राहक

ऐसी क्वेरी को निष्पादित करते समय, डीबीएमएस ऑप्टिमाइज़र एक योजना चुनते समय त्रुटियां कर सकता है, जिससे क्वेरी का इष्टतम निष्पादन नहीं होगा। दो तालिकाओं को जोड़ते समय, DBMS ऑप्टिमाइज़र दोनों तालिकाओं में रिकॉर्ड की संख्या के आधार पर एक तालिका में शामिल होने वाले एल्गोरिदम का चयन करता है। यदि कोई नेस्टेड क्वेरी है, तो नेस्टेड क्वेरी द्वारा लौटाए गए रिकॉर्ड की संख्या निर्धारित करना बेहद मुश्किल है। इसलिए, आपको नेस्टेड क्वेरीज़ के बजाय हमेशा अस्थायी तालिकाओं का उपयोग करना चाहिए। तो चलिए अनुरोध को फिर से लिखते हैं।

ग्राहकों का चयन करें। लिंक के रूप में लिंक करें, निर्देशिका से ग्राहकों को रखें। ग्राहकों को ग्राहकों के रूप में कहां रखें
क्लाइंट्स.लिंक बी (&क्लाइंट्स); ///////////////////////////////////////////// // //////////////////////////// चयन करें tClients.Link, UnallocatedPaymentsRemains.AmountRemaining, tClients से जैसे ही tClients Join RegisterAccumulations.UnallocatedPayments.Balances (, client IN (tClients से tClients.Link चुनें)) UnallocatedPaymentsBalances के रूप में tClients.Link = UnallocatedPaymentsBalances.Clients

इस मामले में, ऑप्टिमाइज़र यह निर्धारित करने में सक्षम होगा कि अस्थायी तालिका tClients कितने रिकॉर्ड का उपयोग करती है और तालिकाओं में शामिल होने के लिए इष्टतम एल्गोरिदम का चयन करने में सक्षम होगी।

वर्चुअल टेबल , आपको अधिकांश लागू कार्यों के लिए व्यावहारिक रूप से तैयार डेटा प्राप्त करने की अनुमति देता है। (पहले का टुकड़ा, अंतिम का टुकड़ा, अवशेष, टर्नओवर, अवशेष और टर्नओवर) यहां मुख्य शब्द आभासी है। ये तालिकाएँ भौतिक नहीं हैं, बल्कि सिस्टम द्वारा तुरंत संकलित की जाती हैं, अर्थात। वर्चुअल टेबल से डेटा प्राप्त करते समय, सिस्टम अंतिम रजिस्टर टेबल से डेटा एकत्र करता है, इकट्ठा करता है, समूह बनाता है और इसे उपयोगकर्ता को जारी करता है।

वे। वर्चुअल टेबल से कनेक्ट करते समय, सबक्वेरी से कनेक्शन बनाया जाता है। इस स्थिति में, DBMS ऑप्टिमाइज़र एक गैर-इष्टतम कनेक्शन योजना भी चुन सकता है। यदि क्वेरी जल्दी से उत्पन्न नहीं होती है और क्वेरी वर्चुअल टेबल में जॉइन का उपयोग करती है, तो वर्चुअल टेबल तक पहुंच को एक अस्थायी टेबल में स्थानांतरित करने की सिफारिश की जाती है, और फिर दो अस्थायी टेबल के बीच एक जॉइन बनाया जाता है। आइए पिछले अनुरोध को फिर से लिखें।

ग्राहकों का चयन करें। लिंक के रूप में लिंक करें, निर्देशिका से ग्राहकों को रखें। ग्राहकों को ग्राहकों के रूप में लिंक द्वारा अनुक्रमित करें जहां
क्लाइंट्स.लिंक बी (&क्लाइंट्स); ///////////////////////////////////////////// // //////////////////////////// चयन करें UnallocatedPayments.AmountBalance, UnallocatedPayments.Client AS क्लाइंट PLACE Balance FROM RegisterAccumulations.UnallocatedPayments.Balances(, क्लाइंट B ( tClients का चयन करें। tClients से लिंक)) UnallocatedPaymentsBalances के रूप में; ///////////////////////////////////////////// // //////////////////////////// चयन करें tClients.Link, toRemainders.AmountRemaining AS Amount शेष from tClients as tClients.Link द्वारा शेष के रूप में Remainders में शामिल हों = tRemainings.ग्राहक

9.अनुरोध के परिणाम की जाँच करना।

क्वेरी का परिणाम खाली हो सकता है; खाली मानों की जांच करने के लिए, निम्नलिखित निर्माण का उपयोग करें:

ResRequest = Request.Execute(); यदि resQuery.Empty() तो वापस लौटें; अगर अंत;

तरीका खाली()तरीकों से पहले इस्तेमाल किया जाना चाहिए चुनना()या उतारना(), क्योंकि संग्रह को पुनः प्राप्त करने में समय लगता है।

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

यह सिस्टम को लूप में अनुरोध की जाँच करने वाले सिंटैक्स से बचाएगा।

11. निर्माण "हो रहा है"।

एक डिज़ाइन जो अनुरोधों में काफी दुर्लभ है। आपको समग्र कार्यों (SUM, न्यूनतम, औसत, आदि) के मूल्यों पर शर्तें लगाने की अनुमति देता है। उदाहरण के लिए, आपको केवल उन ग्राहकों का चयन करना होगा जिनकी सितंबर में भुगतान राशि 13,000 रूबल से अधिक थी। यदि आप "कहां" शर्त का उपयोग करते हैं, तो आपको पहले एक अस्थायी तालिका या नेस्टेड क्वेरी बनानी होगी, भुगतान राशि के अनुसार वहां रिकॉर्ड समूहित करना होगा और फिर शर्त लागू करनी होगी। "HAVING" निर्माण से इससे बचने में मदद मिलेगी।

भुगतान का चयन करें। ग्राहक, राशि (भुगतान राशि) दस्तावेज़ से राशि के रूप में। भुगतान भुगतान के रूप में जहां माह (भुगतान तिथि) = 9 भुगतान द्वारा समूह। ग्राहक के पास राशि (भुगतान राशि) > 13000

कंस्ट्रक्टर में, ऐसा करने के लिए, बस "शर्तें" टैब पर जाएं, एक नई शर्त जोड़ें और "कस्टम" चेकबॉक्स को चेक करें। तो बस लिखो राशि (भुगतान राशि) > 13000

12. शून्य मान

मैं यहां डेटाबेस में तीन-मूल्यवान तर्क के सिद्धांतों का वर्णन नहीं करूंगा; इस विषय पर कई लेख हैं। कैसे के बारे में संक्षेप में व्यर्थक्वेरी के परिणाम को प्रभावित कर सकता है. मान NULL वास्तव में एक मान नहीं है, और यह तथ्य कि मान अपरिभाषित है अज्ञात है। इसलिए, NULL के साथ कोई भी ऑपरेशन NULL लौटाता है, चाहे वह जोड़, घटाव, विभाजन या तुलना हो। शून्य मान की तुलना शून्य मान से नहीं की जा सकती क्योंकि हम नहीं जानते कि तुलना किससे करें। वे। ये दोनों तुलनाएँ हैं: NULL = NULL, NULL<>NULL सत्य या असत्य नहीं है, यह अज्ञात है।

आइए एक उदाहरण देखें.

उन ग्राहकों के लिए जिनके पास भुगतान नहीं है, हमें "कोई भुगतान नहीं" मान के साथ "साइन" फ़ील्ड प्रदर्शित करना होगा। इसके अलावा, हम निश्चित रूप से जानते हैं कि हमारे पास ऐसे ग्राहक हैं। और जो मैंने ऊपर लिखा है उसका सार प्रतिबिंबित करने के लिए, आइए इसे इस प्रकार करें।

विशेषता के रूप में "कोई भुगतान नहीं" चुनें, भुगतान के स्थान पर दस्तावेज़ स्थान के रूप में शून्य चुनें; ///////////////////////////////////////////// // //////////////////////////////////////////////////////////////////////////////////////////// चयन करें। क्लाइंट के रूप में लिंक करें, भुगतान करें। लिंक करें कि भुगतान कैसे होता है, डायरेक्ट्री से tClientPayment डालें। क्लाइंट के रूप में क्लाइंट ने कनेक्शन दस्तावेज़ छोड़ा। भुगतान एएस भुगतान सॉफ्टवेयर क्लाइंट.लिंक = भुगतान.शेयरधारक; ///////////////////////////////////////////// // //////////////////////////// tClientPayment से tClientPayment.Client का चयन करें क्योंकि tClientPayment आंतरिक रूप से tPayment के रूप में tPayment में शामिल होता है tClientPayment.Payment = tPayment द्वारा दस्तावेज़।

दूसरी अस्थायी तालिका tClientPayment पर ध्यान दें। बाएं जुड़ाव से मैं सभी ग्राहकों और इन ग्राहकों के लिए सभी भुगतानों का चयन करता हूं। उन ग्राहकों के लिए जिनके पास भुगतान नहीं है, "भुगतान" फ़ील्ड शून्य होगी। तर्क का पालन करते हुए, पहली अस्थायी तालिका "tPayments" में मैंने 2 फ़ील्ड निर्दिष्ट किए, उनमें से एक NULL, दूसरी पंक्ति "भुगतान नहीं है"। तीसरी तालिका में, मैं "भुगतान" और "दस्तावेज़" फ़ील्ड का उपयोग करके आंतरिक जुड़ाव के साथ "tClientPayment" और "tPayment" तालिकाओं को जोड़ता हूं। हम जानते हैं कि पहली तालिका में "दस्तावेज़" फ़ील्ड शून्य है, और दूसरी तालिका में, जिनके पास "भुगतान" फ़ील्ड में भुगतान नहीं है वे भी शून्य हैं। ऐसा कनेक्शन हमारे पास क्या लौटाएगा? लेकिन यह कुछ भी वापस नहीं करेगा. क्योंकि तुलना NULL = NULL सत्य का मूल्यांकन नहीं करती है।

अपेक्षित परिणाम लौटाने के अनुरोध के लिए, आइए इसे फिर से लिखें:

विशेषता के रूप में "कोई भुगतान नहीं" चुनें, भुगतान के दस्तावेज़ स्थान के रूप में मान (Document.Payment.EmptyLink) चुनें; ///////////////////////////////////////////// // //////////////////////////////////////////////////////////////////////////चयन करें। क्लाइंट का चयन करें। क्लाइंट के रूप में लिंक करें, ISNULL(Payment.Link, VALUE(Document.Payment.EmptyLink )) कैसे भुगतान निर्देशिका से tClientPayment डालें। ग्राहकों द्वारा छोड़े गए कनेक्शन दस्तावेज़ के रूप में ग्राहक। ग्राहकों द्वारा भुगतान के रूप में भुगतान। लिंक = भुगतान। शेयरधारक; ///////////////////////////////////////////// // //////////////////////////// tClientPayment से tClientPayment.Client चुनें, tClientPayment के रूप में आंतरिक रूप से tPayment के रूप में जुड़ें, tClientPayment.Payment = tPayment द्वारा भुगतान करें। दस्तावेज़

अब, दूसरी अस्थायी तालिका में, हमने संकेत दिया है कि यदि "भुगतान" फ़ील्ड शून्य है, तो यह फ़ील्ड = भुगतान दस्तावेज़ का एक खाली लिंक है। पहली तालिका में हमने NULL को एक खाली संदर्भ से भी बदल दिया। अब कनेक्शन में गैर-शून्य फ़ील्ड शामिल हैं और अनुरोध अपेक्षित परिणाम लौटाएगा।

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

13. "चॉइस व्हेन...थेन...एंड" डिज़ाइन की एक अनिर्दिष्ट विशेषता।

ऐसे मामले में जब अनुरोध में "शर्तों" के निर्माण का वर्णन करना आवश्यक हो, हम मानक वाक्यविन्यास का उपयोग करते हैं:

चयन का चयन करें जब Users.Name = "वास्या पुपकिन" तब "हमारा पसंदीदा कर्मचारी" अन्यथा "हम यह नहीं जानते" निर्देशिका से फ़ील्ड 1 के रूप में समाप्त होता है। Users AS Users

लेकिन क्या होगा यदि, उदाहरण के लिए, हमें अनुरोध में महीने का नाम प्राप्त करने की आवश्यकता हो? किसी अनुरोध में एक विशाल निर्माण लिखना बदसूरत और समय लेने वाला है, इसलिए उपरोक्त लेखन का यह रूप हमारी मदद कर सकता है:

महीना चुनें (यूएस_गणना खपत_अनुसूची टर्नओवर गणना अवधि) जब 1 तब "जनवरी" जब 2 तब "फरवरी" जब 3 तब "मार्च" जब 4 तब "अप्रैल" जब 5 तब "मई" जब 6 तब "जून" जब 7 तब "जुलाई" के जब 8 तब "अगस्त" जब 9 तब "सितंबर" जब 10 तब "अक्टूबर" जब 11 तब "नवंबर" जब 12 तब "दिसंबर" एक महीने के रूप में समाप्त होता है

अब डिज़ाइन कम बोझिल लगता है और समझने में आसान है।

14. बैच क्वेरी निष्पादन।

अनुरोधों को गुणा न करने के लिए, आप एक बड़ा अनुरोध बना सकते हैं, इसे पैकेजों में विभाजित कर सकते हैं और इसके साथ काम कर सकते हैं।
उदाहरण के लिए, मुझे "उपयोगकर्ता" निर्देशिका से निम्नलिखित फ़ील्ड प्राप्त करने की आवश्यकता है: "जन्म तिथि" और प्रत्येक उपयोगकर्ता के लिए उपलब्ध भूमिकाएँ। इसे फॉर्म के विभिन्न सारणीबद्ध भागों में अपलोड करें। बेशक, आप इसे एक अनुरोध में कर सकते हैं, फिर आपको रिकॉर्ड्स के माध्यम से पुनरावृत्त करना होगा या उन्हें संक्षिप्त करना होगा, या आप यह कर सकते हैं:

उपयोगकर्ताओं का चयन करें। पूर्ण नाम के रूप में लिंक करें, उपयोगकर्ता। जन्मतिथि, उपयोगकर्ता। भूमिका निर्देशिका से vtUsers डालें। उपयोगकर्ताओं के रूप में उपयोगकर्ता; ///////////////////////////////////////////// // //////////////////////////// चुनें TueUsers.पूरा नाम, TueUsers.जन्मतिथि TueUsers से TueUsers के रूप में TueUsers समूह द्वारा TueUsers.पूरा नाम, TueUsers । जन्म की तारीख; ///////////////////////////////////////////// // //////////////////////////// चुनें wUsers.Full Name, wUsers.Role FROM WUsers AS WUsers GROUP BY wUsers.Full Name, wUsers. Date of जन्म

tPackage = Request.ExecutePackage();

TP_BirthDate = tPackage.Upload();
TP_Roles = tPackage.Unload();

जैसा कि हम देख सकते हैं, क्वेरी को एक बैच में निष्पादित किया जा सकता है और परिणाम को एक सरणी के रूप में संसाधित किया जा सकता है। कुछ मामलों में यह बहुत सुविधाजनक है.

15. बैच अनुरोध में शर्तें

उदाहरण के लिए, हमारे पास एक बैच अनुरोध है, जहां सबसे पहले हमें फ़ील्ड मिलती हैं: "उपयोगकर्ता" निर्देशिका से "नाम, जन्म तिथि, कोड" और हम "व्यक्ति" निर्देशिका से इन फ़ील्ड के लिए शर्तों के साथ रिकॉर्ड प्राप्त करना चाहते हैं।

उपयोगकर्ता.व्यक्तिगत.नाम को नाम के रूप में चुनें, उपयोगकर्ता.व्यक्तिगत.जन्मतिथि को जन्मतिथि के रूप में चुनें, उपयोगकर्ता.व्यक्तिगत.कोड को कोड के रूप में चुनें निर्देशिका से उपयोगकर्ता को स्थान दें।उपयोगकर्ता को उपयोगकर्ता के रूप में चुनें; ///////////////////////////////////////////// // ////////////////////////////////व्यक्तियों का चयन करें। निर्देशिका से व्यक्तिगत के रूप में लिंक करें। व्यक्तियों के रूप में व्यक्ति

आप इस तरह शर्तें लगा सकते हैं:

जहां व्यक्ति.कोड IN (vtUsers से चयन vtUsers.Code) और व्यक्तियों.नाम IN (vtUsers से vtUsers.Code चुनें) और व्यक्ति.जन्मतिथि IN (tvUsers से vtUsers.DateBirth चुनें)

और आप इसे इस तरह कर सकते हैं:

कहां (व्यक्ति.कोड, व्यक्ति.नाम, व्यक्ति.जन्मतिथि) में (मंगलवार.कोड, मंगलउपयोगकर्ता.नाम, मंगलउपयोगकर्ता.जन्मतिथि का चयन मंगलवार से करें)

इसके अलावा व्यवस्था बनाए रखना भी जरूरी है।

16. बैच अनुरोध में "स्थिति" के लिए क्वेरी बिल्डर को कॉल करना

जब कोई शर्त लगाना आवश्यक हो, जैसा कि ऊपर दिए गए उदाहरण में है, तो आप भूल सकते हैं कि वर्चुअल तालिका में इस या उस फ़ील्ड को कैसे कहा जाता है।
उदाहरण के लिए, आपको "जन्म तिथि" फ़ील्ड पर एक शर्त लगाने की आवश्यकता है, और आभासी तालिका में इस फ़ील्ड को "देनदार की जन्म तिथि" कहा जाता है, और यदि आप नाम भूल जाते हैं, तो आपको शर्त को संपादित किए बिना बाहर निकलना होगा सहेजें और फ़ील्ड का नाम देखें। इससे बचने के लिए आप निम्नलिखित तकनीक का उपयोग कर सकते हैं।

कंस्ट्रक्शन "बी" के बाद ब्रैकेट लगाना और ब्रैकेट के बीच खाली जगह (स्पेस) छोड़ना जरूरी है, इस स्पेस को सेलेक्ट करें और क्वेरी कंस्ट्रक्टर को कॉल करें। डिज़ाइनर के पास बैच क्वेरी की सभी तालिकाओं तक पहुंच होगी। तकनीक वर्चुअल रजिस्टर टेबल और "शर्तें" टैब दोनों पर काम करती है। बाद वाले मामले में, आपको "पी (मनमानी स्थिति)" बॉक्स को चेक करना होगा और संपादन मोड "एफ4" दर्ज करना होगा।

प्रश्न अक्सर अचानक ही तैयार कर लिए जाते थे और वे बस उन "तकनीकों" को स्पष्ट करने का काम करते हैं जिन पर मैं विचार कर रहा था।

मैं प्रश्नों में अनुक्रमणिका के उपयोग को देखना चाहता था, लेकिन यह एक बहुत व्यापक विषय है। मैं इसे एक अलग लेख में रखूंगा, या बाद में यहां जोड़ूंगा।

अद्यतन1. अंक 11,12
upd2. अंक 13,14,15,16

प्रयुक्त पुस्तकें:
क्वेरी भाषा "1सी:एंटरप्राइज़ 8" - ई.यू. ख्रुस्तलेवा
1सी:एंटरप्राइज़ 8 प्रणाली में व्यावसायिक विकास।"

वास्तविक समस्याओं में नमूनों को व्यवस्थित करते समय, अधिकांश मामलों में, डेटा चयन को कुछ मानदंडों के अनुसार व्यवस्थित किया जाता है।

ऐसे मामले में जब चयन वास्तविक तालिका से किया जाता है, तो कोई कठिनाई उत्पन्न नहीं होती है। डेटा को बिल्कुल तुच्छ तरीके से संसाधित किया जाता है:

ऐसे मामले में जब क्वेरी में स्रोत एक आभासी तालिका है, तो स्थिति कुछ अधिक जटिल हो जाती है।

क्वेरी भाषा आपको दो तरीकों से वर्चुअल टेबल से चयन पर एक शर्त लगाने की अनुमति देती है: WHERE क्लॉज में और वर्चुअल टेबल पैरामीटर का उपयोग करके। दोनों तरीकों से एक ही परिणाम मिलेगा (कुछ विशिष्ट मामलों के अपवाद के साथ), लेकिन, फिर भी, वे समकक्ष से बहुत दूर हैं।

हम पहले से ही जानते हैं कि वर्चुअल टेबल को वर्चुअल कहा जाता है क्योंकि वे वास्तव में डेटाबेस में नहीं होते हैं। वे तभी बनते हैं जब उनसे कोई अनुरोध किया जाता है। इसके बावजूद, वर्चुअल टेबल को वास्तविक मानना हमारे लिए (अर्थात, जो क्वेरी लिखते हैं) सुविधाजनक है। 1सी एंटरप्राइज 8 सिस्टम में क्या होगा जब हमारे द्वारा संकलित क्वेरी अभी भी वर्चुअल टेबल तक पहुंच जाएगी?

पहले चरण में, सिस्टम एक वर्चुअल टेबल बनाएगा। दूसरे चरण में, परिणामी तालिका से रिकॉर्ड्स का चयन किया जाएगा जो WHERE क्लॉज में निर्दिष्ट शर्त को पूरा करते हैं:
यह स्पष्ट रूप से देखा गया है कि अंतिम नमूने में वर्चुअल टेबल (और, इसलिए, डेटाबेस से) के सभी रिकॉर्ड शामिल नहीं होंगे, बल्कि केवल वे ही शामिल होंगे जो दी गई शर्त को पूरा करते हैं। और शेष रिकॉर्ड को परिणाम से बाहर कर दिया जाएगा।

इस प्रकार, सिस्टम सिर्फ बेकार काम नहीं करेगा, बल्कि दोगुना बेकार काम करेगा! सबसे पहले, संसाधनों को अनावश्यक डेटा के आधार पर एक वर्चुअल टेबल बनाने पर खर्च किया जाएगा (आकृति में उन्हें "डेटा क्षेत्र ए और बी" के रूप में चिह्नित किया गया है), और फिर इस डेटा को अंतिम परिणाम से फ़िल्टर करने के लिए काम किया जाएगा।

क्या वर्चुअल टेबल के निर्माण के चरण में, अनावश्यक डेटा का उपयोग तुरंत बंद करना संभव है? यह पता चला कि यह संभव है. वर्चुअल टेबल पैरामीटर बिल्कुल इसी के लिए डिज़ाइन किए गए हैं:

वर्चुअल टेबल को पैरामीटराइज़ करके, हम क्वेरी द्वारा संसाधित किए जाने वाले डेटा की मात्रा को तुरंत सीमित कर देते हैं।

वर्चुअल टेबल पैरामीटर "अतिरिक्त विधि" के मानों के बीच क्या अंतर है?
जब जोड़ विधि को "मूवमेंट" पर सेट किया जाता है, तो केवल वही अवधियाँ लौटाई जाएंगी जिनमें मूवमेंट थे। जब "आंदोलन और अवधि सीमाएं" सेट की जाती हैं, तो उपरोक्त आंदोलनों में 2 रिकॉर्ड जोड़े जाएंगे: वीटी मापदंडों में निर्दिष्ट अवधि की शुरुआत और अंत में आंदोलन। इन 2 रिकॉर्ड के लिए "रजिस्ट्रार" फ़ील्ड खाली होगी।

जानकारी साइट से ली गई है

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

यह स्पष्ट रूप से देखा गया है कि अंतिम नमूने में वर्चुअल टेबल (और, इसलिए, डेटाबेस से) के सभी रिकॉर्ड शामिल नहीं होंगे, बल्कि केवल वे ही शामिल होंगे जो दी गई शर्त को पूरा करते हैं। और शेष रिकॉर्ड को परिणाम से बाहर कर दिया जाएगा।

क्या वर्चुअल टेबल के निर्माण के चरण में, अनावश्यक डेटा का उपयोग तुरंत बंद करना संभव है? यह पता चला कि यह संभव है. वर्चुअल टेबल पैरामीटर बिल्कुल इसी के लिए डिज़ाइन किए गए हैं:

वर्चुअल टेबल को पैरामीटराइज़ करके, हम क्वेरी द्वारा संसाधित किए जाने वाले डेटा की मात्रा को तुरंत सीमित कर देते हैं।

आइए PriceSliceLast वर्चुअल टेबल के पैरामीटर दर्ज करने के लिए डायलॉग को कॉल करें और इंगित करें कि अवधि रिपोर्टडेट पैरामीटर में पारित हो जाएगी। ऐसा करने के लिए, तालिका सूची में इस तालिका का चयन करें और वर्चुअल टेबल विकल्प बटन पर क्लिक करें। फिर तालिकाओं से निम्नलिखित फ़ील्ड चुनें:

स्प्रनामपद्धति. अभिभावक,

नवीनतम कीमत का प्राइसस्लाइस।

बाईं तालिका में शामिल हों

- बुकमार्क पर सम्बन्ध: लिंक स्थिति फ़ील्ड में, सूचना रजिस्टर के नामकरण आयाम का मान नामकरण निर्देशिका तत्व के संदर्भ के बराबर होना चाहिए। और रजिस्टर तालिका के लिए सभी चेकबॉक्स को भी अनचेक करें और इसे लुकअप तालिका के लिए जांचें, जिससे कनेक्शन के प्रकार को लुकअप तालिका के लिए बाएं कनेक्शन के रूप में सेट किया जा सके:

चावल। 13.15. किसी क्वेरी में तालिकाओं के बीच संबंध

- बुकमार्क पर स्थितियाँआइए नामकरण निर्देशिका से तत्वों के चयन के लिए शर्त निर्धारित करें - चयनित तत्वों को नामकरण प्रकार अनुरोध पैरामीटर में पारित नामकरण के प्रकार के अनुरूप होना चाहिए:

चावल। 13.16. तत्वों के चयन की शर्तें

- बुकमार्क पर यूनियन/उपनाम:फ़ील्ड पैरेंट = सेवा समूह, और फ़ील्ड लिंक = सेवा का उपनाम निर्दिष्ट करें। - ओके पर क्लिक करें-

इसके बाद, आपको टैब पर ऐसा करने के लिए डेटा लेआउट योजना को संपादित करना होगा संसाधन, बटन पर क्लिक करें जोड़नाऔर एक संसाधन चुनें - कीमत

- बुकमार्क पर विकल्पनामकरण प्रकार पैरामीटर का मान निर्धारित करें - गणना.नामकरण प्रकार.सेवा। इसके अलावा, हम रिपोर्टडेट पैरामीटर के लिए उपलब्धता प्रतिबंध हटा देंगे। इस पैरामीटर फ़ील्ड के प्रकार में, दिनांक की संरचना सेट करें - दिनांक। इसके विपरीत, अवधि पैरामीटर के लिए, हम उपलब्धता प्रतिबंध निर्धारित करते हैं:

चावल। 13.17. लेआउट योजना विकल्प

समायोजन

- चलो बुकमार्क पर चलते हैं समायोजन:आइए ग्रुपिंग प्रकार पदानुक्रम को निर्दिष्ट करते हुए, सेवा समूह फ़ील्ड के आधार पर एक ग्रुपिंग बनाएं।

रिपोर्ट समूहीकरण के लिए निम्नलिखित पदानुक्रम प्रकार मौजूद हैं:पदानुक्रम के बिना - समूह में केवल गैर-पदानुक्रमित रिकॉर्ड प्रदर्शित किए जाते हैं। पदानुक्रम - समूहीकरण में गैर-पदानुक्रमित और श्रेणीबद्ध दोनों रिकॉर्ड प्रदर्शित किए जाते हैं। केवल पदानुक्रम - समूहीकरण में केवल पदानुक्रमित (मूल) रिकॉर्ड प्रदर्शित किए जाते हैं। इस समूह के अंदर हम समूह फ़ील्ड निर्दिष्ट किए बिना, एक और समूह बनाएंगे। उप-टैब पर चयनित फ़ील्ड:आउटपुट फ़ील्ड सेवा और मूल्य निर्दिष्ट करें:

चावल। 13.18. रिपोर्ट संरचना और फ़ील्ड

उप-टैब पर अन्यसेटिंग्स हम निम्नलिखित चरण निष्पादित करेंगे:

चावल। 13.19. "सेवा समूह" समूह के लिए सामान्य योग प्रदर्शित करने के लिए सेटिंग्स

चावल। 13.20. वैश्विक रिपोर्ट के लिए परिणाम सेट करना और प्रदर्शित करना

अंत में, आइए उपयोगकर्ता सेटिंग्स में रिपोर्ट दिनांक पैरामीटर शामिल करें और इसके संपादन मोड को त्वरित एक्सेस पर सेट करें। आइए डेटा संरचना योजना डिज़ाइनर को बंद करें और सेवाओं की सूची ऑब्जेक्ट को संपादित करने के लिए विंडो में, सबसिस्टम टैब पर जाएं। कॉन्फ़िगरेशन सबसिस्टम की सूची में, सेवा प्रावधान और लेखांकन सबसिस्टम पर ध्यान दें।

1सी में: एंटरप्राइज़ मोड

आइए 1C:एंटरप्राइज़ को डिबग मोड में लॉन्च करें और सबसे पहले आवधिक रजिस्टर कीमतें खोलें। फिर हम रिपोर्ट का परीक्षण करेंगे.

उदाहरण के रूप में इस रिपोर्ट का उपयोग करते हुए, हमने अध्ययन किया कि डेटा संरचना प्रणाली आवधिक सूचना रजिस्टर से नवीनतम मान कैसे प्राप्त करती है और निर्देशिका पदानुक्रम के अनुसार समूह कैसे प्रदर्शित होते हैं।

यदि मेरा प्रकाशन आपके लिए उपयोगी है, तो इसे प्लस देना न भूलें :-)

यहां संग्रह में सभी कार्यों के लिए एक रूब्रिकेटर है(प्रत्येक कार्य के लिए फ़ोरम थ्रेड के लिंक वाला एक पृष्ठ)
http://chistov.spb.ru/forum/16-969-1

खैर, अब मेरे विकास और नोट्स जो मैंने तैयारी प्रक्रिया के दौरान बनाए थे।
मैं उपर्युक्त दोनों को यथासंभव कम दोहराने का प्रयास करूँगा अंतिमप्रकाशन.

तो चलो शुरू हो जाओ:

यदि आप इसे दूर से लेते हैं, तो परीक्षा के अंत में आपके डेस्कटॉप पर दो ऑब्जेक्ट होने चाहिए:

1. सूचना आधार का अंतिम अपलोड (डीटी फ़ाइल)
2. व्याख्यात्मक नोट

और कुछ नहीं होना चाहिए, इंटरमीडिएट की कॉपियाँ आदि नहीं होनी चाहिए।

एक व्याख्यात्मक नोट अवश्य लिखें!
अस्पष्ट रूप से तैयार किए गए कार्य के मामले में, वहां यह लिखना सुनिश्चित करें कि आपने वास्तव में ऐसा और ऐसा समाधान विकल्प चुना है।
इसके अलावा, कोड में प्रमुख स्थानों पर कट्टरता के बिना संक्षिप्त टिप्पणियाँ छोड़ना बेहतर है, लेकिन जहां परीक्षक के पास प्रश्न हो सकते हैं, वहां लिखना बेहतर है।

लेकिन इसके बारे में आपको उन निर्देशों में बताया जाएगा जो आपको परीक्षा से पहले पढ़ने के लिए दिए जाएंगे।
पहले से जानना बेहतर है)

प्रश्नों में एम्परसेंड वर्ण का उपयोग करना।

कभी-कभी लेआउट को आगे-पीछे स्विच करने की तुलना में अतिरिक्त कीबोर्ड से टाइप करना अधिक तेज़ होता है, जिससे समय की बचत होती है
& = Alt+38

*************************************************************************************************
क्वेरीज़ में TimePoint() का उपयोग करना

संचय और लेखांकन रजिस्टरों के प्रश्नों में, दस्तावेज़ की तारीख को वर्चुअल टेबल (अवधि) पैरामीटर के रूप में उपयोग करना आवश्यक नहीं है, लेकिन मोमेंट पैरामीटर, जिसे कोड में निम्नानुसार परिभाषित किया गया है:

क्षण = ?(पासिंग मोड = दस्तावेज़ पोस्टिंग मोड। परिचालन, अपरिभाषित, समय का क्षण());

*************************************************************************************************
रजिस्टर द्वारा दस्तावेज़ आंदोलनों को उत्पन्न करते समय, पोस्टिंग प्रसंस्करण प्रक्रिया की शुरुआत में, वर्तमान दस्तावेज़ की गतिविधियों को रजिस्टर द्वारा साफ़ करना आवश्यक है।

कोड है:

आंदोलन.रजिस्टरनाम.लिखें = सत्य; मूवमेंट.रजिस्टरनाम.क्लियर();

यह संभव है कि प्रक्रिया के दौरान इस रजिस्टर से रिकॉर्ड का विश्लेषण करना आवश्यक होगा।
इसलिए, ताकि वर्तमान रिकॉर्ड (पुराने, दस्तावेज़ बदलने से पहले) का विश्लेषण करते समय वे निश्चित रूप से नमूने में शामिल न हों, आप उपरोक्त दो पंक्तियों में एक और पंक्ति जोड़ सकते हैं:

आंदोलन.रजिस्टरनाम.लिखें();

या, रिकॉर्ड का विश्लेषण करते समय, स्पष्ट रूप से एक सीमा इंगित करें जिसमें वर्तमान दस्तावेज़ का समय बिंदु शामिल नहीं है।

लेकिन हर जगह मैंने बस इन तीन पंक्तियों के निर्माण का संकेत दिया:

आंदोलन.रजिस्टरनाम.लिखें = सत्य; मूवमेंट.रजिस्टरनाम.क्लियर(); आंदोलन.रजिस्टरनाम.लिखें();

*************************************************************************************************
डेटा को ब्लॉक करने के दो तरीके हैं, उनके बीच का चुनाव इस्तेमाल की गई विधि पर निर्भर करता है - पुराना या नया:

1) नियमित नियंत्रित अवरोधन, दस्तावेज़ प्रसंस्करण की पुरानी पद्धति (डेटा अवरोधन ऑब्जेक्ट)

सेट करें कि क्या शेष राशि पहले जाँची जाती है और फिर बट्टे खाते में डाल दी जाती है।
उस स्थिति में जब हमें एक आंदोलन बनाने के लिए रजिस्टर से कुछ जानकारी की आवश्यकता होती है।

उदाहरण:

दस्तावेज़ में - मात्रा, रजिस्टर में - मात्रा और राशि (लागत)
इसलिए, हम दस्तावेज़ से माल की मात्रा जानते हैं - हम कितना बट्टे खाते में डालते हैं, लेकिन लागत - नहीं।
हम इसे केवल रजिस्टर से पता लगा सकते हैं, लेकिन यह सुनिश्चित करने के लिए कि कोई भी शेष राशि प्राप्त करने के क्षण और गतिविधियों को रिकॉर्ड करने के क्षण के बीच रजिस्टर को नहीं बदलता है, हमें शेष राशि पढ़ने से पहले ही रजिस्टर को लॉक करना होगा।
तो, इस मामले में, डेटा लॉकिंग ऑब्जेक्ट का उपयोग किया जाता है। और इसे बनाते समय, यह इंगित करना अधिक सही है कि हम किन आयामों से रजिस्टर को ब्लॉक कर रहे हैं (उदाहरण के लिए, हमारे मामले में - केवल दस्तावेज़ में निर्दिष्ट आइटम द्वारा) - ताकि कोई अनावश्यक लॉक न हो और कोई अन्य उपयोगकर्ता दूसरे को बेच सके वस्तु।

1. डेटा लॉक ऑब्जेक्ट का उपयोग करके लॉक सेट करें
2. बाकी पढ़ें
3. हम बट्टे खाते में डालने की संभावना की जाँच करते हैं
4. हम आंदोलन बनाते हैं, उदाहरण के लिए, माल को बट्टे खाते में डालना
5. दस्तावेज़ पोस्ट करने के बाद, ब्लॉकिंग स्वचालित रूप से हटा दी जाती है (ब्लॉकिंग पोस्टिंग लेनदेन के हिस्से के रूप में मान्य है और सिस्टम द्वारा स्वचालित रूप से हटा दी जाती है)। यानी ऑब्जेक्ट को विशेष रूप से अनलॉक करने की जरूरत नहीं है।

2) दस्तावेजों के प्रसंस्करण के लिए नई पद्धति (लॉकफॉरचेंज प्रॉपर्टी का उपयोग करके = सत्य)

इसका उपयोग तब किया जाता है जब हमें आंदोलनों को बनाने के लिए रजिस्टरों से जानकारी की आवश्यकता नहीं होती है, और हम जांच कर सकते हैं कि क्या हम राइट-ऑफ करते समय नकारात्मक में चले गए हैं, यदि रिकॉर्डिंग के बाद, हम रजिस्टर में शेष राशि को देखते हैं और देखते हैं कि नकारात्मक हैं . इस मामले में, हम समझेंगे कि हमने बहुत अधिक बट्टे खाते में डाल दिया है और बट्टे खाते में डालने की कार्रवाई रद्द कर देंगे।

उदाहरण:
आइए किसी उत्पाद को बेचने की प्रक्रिया पर विचार करें।
दस्तावेज़ में - मात्रा, रजिस्टर में - केवल मात्रा
इसलिए, हम दस्तावेज़ से माल की मात्रा जानते हैं।
हम दस्तावेज़ में निर्दिष्ट मात्रा के साथ आंदोलन बनाते हैं और उन्हें रिकॉर्ड करते हैं। इसके बाद, हम रजिस्टर पढ़ते हैं, शेष राशि को देखते हैं, और विश्लेषण करते हैं कि क्या कोई नकारात्मक है। यदि है, तो एक त्रुटि प्रदर्शित करें और इनकार = सत्य सेट करें।

अर्थात क्रम इस प्रकार है:
1. रजिस्टर के माध्यम से आगे बढ़ने के लिए, ब्लॉकफॉरचेंज प्रॉपर्टी = ट्रू सेट करें
2. हम आंदोलन बनाते हैं - माल को बट्टे खाते में डालते हैं
3. गतिविधियों को रिकॉर्ड करें
4. रजिस्टर पढ़ें और सुनिश्चित करें कि कोई नकारात्मक शेष नहीं है। यदि वहाँ है, तो उन्होंने अतिरिक्त लिख दिया, यदि नहीं, तो सब कुछ ठीक है।

इसलिए, इस मामले में, यह इंगित करने की आवश्यकता नहीं है कि हमें किन आयामों से रजिस्टर को ब्लॉक करने की आवश्यकता है।
हम अपनी गतिविधियों को रिकॉर्ड करने, गतिविधियों को बनाने और रिकॉर्ड करने से पहले बस ब्लॉकफॉरचेंज प्रॉपर्टी को ट्रू पर सेट करते हैं।
हमने जो रिकॉर्ड किया है उसका विश्लेषण करने के बाद, आवश्यक माप के अनुसार रिकॉर्डिंग के समय सिस्टम स्वयं रजिस्टर को ब्लॉक कर देगा।
एक बार पूरा हो जाने पर, अवरोध हटा दिया जाएगा.

यह विकल्प (दूसरा) सरल है, इसे "दस्तावेजों को संसाधित करने के लिए नई पद्धति" कहा जाता है और 1C यदि संभव हो तो इसका उपयोग करने की अनुशंसा करता है और यदि पहला विकल्प उपयोग किया जाता है तो अंक काट लेता है, लेकिन कुछ मामलों में इसे लागू नहीं किया जा सकता है और पहला विकल्प डेटा लॉकिंग ऑब्जेक्ट का उपयोग किया जाता है (ऊपर दिए गए उदाहरण देखें)।

मैं यह भी ध्यान देता हूं कि चुनी गई विधि की परवाह किए बिना, उनके साथ काम करने से पहले आंदोलनों को साफ किया जाना चाहिए (पिछली सलाह देखें)

*************************************************************************************************
डेटा ब्लॉकिंग (उपरोक्त विवरण से ब्लॉकिंग विधि नंबर 1)

जहां डेटा पढ़ा जाता है और इस डेटा के आधार पर गतिविधियां की जाती हैं, वहां नियंत्रित लॉकिंग की आवश्यकता होती है
प्रबंधित लॉकिंग कोड प्राप्त करने का सबसे तेज़ तरीका "डेटा लॉकिंग" दर्ज करना है, सिंटेक्स असिस्टेंट को कॉल करें और वहां से उदाहरण कोड कॉपी करें। फिर बस इसे अपने रजिस्टर और आयामों के नाम में बदलें।

यह कुछ इस तरह दिखता है:

लॉक = न्यूडाटालॉक; लॉकिंग एलिमेंट = लॉकिंग.ऐड('संचय रजिस्टर.गुड्सइनवेयरहाउस'); लॉकएलिमेंट.मोड = डेटालॉकमोड.एक्सक्लूसिव; ब्लॉकिंगएलिमेंट.डेटासोर्स = पीएम; लॉकिंग एलिमेंट.UseFromDataSource('नामकरण', 'नामकरण'); लॉक.लॉक();

*************************************************************************************************
दस्तावेज़ों के सारणीबद्ध भाग को केवल "टीसी" कहना बेहतर है

99% दस्तावेज़ों में केवल एक सारणीबद्ध भाग होता है। सारणीबद्ध भागों के लिए ऐसा एकीकृत नाम समय बचाने में बहुत मदद करेगा, क्योंकि:
1) बहुत संक्षिप्त - शीघ्रता से लिखें
2) सभी दस्तावेज़ों के लिए समान, आपको कोड लिखते समय यह याद रखने की ज़रूरत नहीं है कि इसे क्या कहा जाता है

*************************************************************************************************
तकनीकी विनिर्देश लाने या अपलोड करने से पहले क्वेरी परिणाम को शून्यता के लिए जांचा जाना चाहिए।

सामान्य तौर पर, मैंने सभी कार्यों में नमूनाकरण का उपयोग किया।

प्रदर्शन के मामले में सिस्टम के लिए नमूनाकरण अधिक इष्टतम है, क्योंकि यह केवल डेटा पढ़ने के लिए "तेज" होता है (टीके के विपरीत)।

लेकिन किसी भी स्थिति में, चयन() विधि से पहले, रिक्तता के लिए क्वेरी परिणाम की जांच करना बेहतर है, इससे सिस्टम पर लोड और कम हो जाएगा।

परिणाम = क्वेरी.रन(); यदि Result.Empty() नहीं है तो चुनें = Result.Select(TravelQueryResult.ByGrouping); ... अगर अंत;

और यदि हमें अनुरोध से केवल एक मान प्राप्त करने की आवश्यकता है
(उदाहरण के लिए, इस वर्ष के लिए स्थापित लेखांकन नीति के अनुसार केवल राइट-ऑफ़ विधि):

परिणाम = क्वेरी.रन(); यदि Result.Empty() नहीं है तो चुनें = Result.Select(); चयन.अगला(); लागत बट्टे खाते में डालने की विधि = नमूना। लागत बट्टे खाते में डालने की विधि; अगर अंत;

*************************************************************************************************
लेखांकन कार्य के लिए दस्तावेज़ "संचालन"।

लेखांकन कार्यों के लिए एक ऑपरेशन दस्तावेज़ बनाना आवश्यक है।

हम इसके लिए पोस्टिंग को पूरी तरह से अक्षम कर देते हैं (गुणों में "पोस्टिंग = अस्वीकार"), इंगित करते हैं कि यह लेखांकन रजिस्टर में गतिविधियां करता है, और गतिविधियों को फॉर्म पर खींच लेता है।

*************************************************************************************************
दस्तावेज़ों का शीघ्र प्रसंस्करण:

होना चाहिए शामिल:
परिचालन एवं लेखांकन में. दस्तावेज़ों के लिए लेखांकन सक्षम होना चाहिए ("ऑपरेशन" दस्तावेज़ को छोड़कर, नीचे देखें)।

होना चाहिए कामोत्तेजित:
गणना कार्यों में पेरोल दस्तावेज़ का कोई मतलब नहीं है।

दस्तावेज़ "ऑपरेशन" के लिए, पोस्टिंग पूरी तरह से अक्षम होनी चाहिए (दस्तावेज़ गुणों में "पोस्टिंग = निषेध"),
चूँकि वह लिखता है तो लिखते समय डेटा को सीधे रजिस्टर में लिखता है।

*************************************************************************************************
फॉर्म के अनुरोध में शर्त "या तो निर्दिष्ट नामकरण या कोई, यदि निर्दिष्ट नहीं है"

प्रश्नों में, निम्नलिखित कार्य का सामना करना पड़ता है: उदाहरण के लिए, आपको निर्दिष्ट नामकरण वाले दस्तावेज़ों का चयन करना होगा या यदि नामकरण निर्दिष्ट नहीं है तो सभी दस्तावेज़ों का चयन करना होगा।
इसे अनुरोध में निम्नलिखित शर्त द्वारा हल किया गया है:

नामकरण = औरनामपद्धति या औरनामपद्धति=मान(निर्देशिका.नामपद्धति.खालीलिंक)

लेकिन इस स्थिति को बदलना अधिक इष्टतम और सही होगा (युकोन को धन्यवाद):

अनुरोध.पाठ = अनुरोध.पाठ + "जहां नामकरण = और नामकरण";

अगर अंत;

8.3.5 में क्वेरी ऑब्जेक्ट मॉडल के आगमन के साथ, एक शर्त को अधिक सुरक्षित रूप से जोड़ना संभव होगा:

यदि वैल्यूफिल्ड (नामकरण) तो
क्वेरी1.चयन.जोड़ें('आइटम = &नामपद्धति');
Request.SetParameter("नामकरण", नामकरण);
अगर अंत;

*************************************************************************************************
प्रश्नों में तालिकाओं को जोड़ना:

कुल रिकॉर्ड की संख्या इस बात पर निर्भर नहीं करती है कि सम्मिलित तालिका का फ़ील्ड प्रदर्शित होता है या नहीं, यह केवल कॉन्फ़िगर किए गए संबंधों पर निर्भर करता है।
अर्थात्, संलग्न तालिका का फ़ील्ड प्रदर्शित नहीं किया जा सकता है।

यदि आप किसी तालिका को बिना किसी शर्त के संलग्न करना चाहते हैं, तो शर्तों वाले टैब पर बस शर्त "TRUE" लिखें।
इस स्थिति में, तालिका बिल्कुल जुड़ जाएगी।

*************************************************************************************************
विशेषताओं के प्रकार (पीवीसी) की योजना का उपयोग करना:

1. वस्तुओं की विशेषताओं का वर्णन करने के लिए एक तंत्र के रूप में उपयोग करें।

1.1. हम पीवीसी बनाते हैं। ये विशेषताओं के प्रकार होंगे (उदाहरण के लिए, रंग, आकार, अधिकतम गति, आदि)। सेटिंग्स में, सभी संभावित प्रकार के विशेषता मानों का चयन करें और, यदि आवश्यक हो, तो बिंदु 1.2 से ऑब्जेक्ट बनाएं और इसे सेटिंग्स में भी इंगित करें।

1.2. पीवीसी के अतिरिक्त मूल्यों के लिए, हम एक अधीनस्थ निर्देशिका अतिरिक्त विशेषताओं के मूल्य (या बस विशेषताओं के मूल्य) बनाते हैं।
यदि वे मौजूदा निर्देशिकाओं में नहीं हैं तो यह विशेषताओं को संग्रहीत करेगा। यदि हमें आवश्यक सभी विशेषताएँ मौजूदा निर्देशिकाओं में हैं, या इन मूल्यों को प्राथमिक डेटा प्रकारों द्वारा दर्शाया जा सकता है, तो हम इसे नहीं बना सकते हैं। पीवीसी सेटिंग्स में हम इंगित करते हैं कि इस निर्देशिका का उपयोग अतिरिक्त उद्देश्यों के लिए किया जाएगा। विशेषता मान.

1.3. हम एक सूचना रजिस्टर बनाते हैं, जो वास्तव में तीन वस्तुओं को जोड़ता है:
- वह वस्तु जिससे हम विशेषता तंत्र को जोड़ते हैं
- प्रकारविशेषताएं (पीवीसी प्रकार)
- विशेषता मान (प्रकार - विशेषता, यह एक नया प्रकार है जो पीवीसी के निर्माण के बाद सिस्टम में दिखाई दिया
और सभी संभावित डेटा प्रकारों का वर्णन करना जो एक विशेषता मान ले सकता है)।
सूचना रजिस्टर में, हम इंगित करते हैं कि विशेषता प्रकार, विशेषता मान (चयन पैरामीटर से लिंक) के लिए स्वामी है, साथ ही विशेषता प्रकार से, विशेषता मान के लिए प्रकार कनेक्शन भी है।

एक अन्य विशेषता यह है कि प्रत्येक निर्मित प्रकार की विशेषता के लिए, आप विशेषता मान के प्रकार को निर्दिष्ट कर सकते हैं, यदि आपको इस विशेषता के मूल्य का वर्णन करने के लिए सभी संभावित प्रकारों की आवश्यकता नहीं है।

2. लेखांकन रजिस्टर के लिए एक उप-कॉन्टो तंत्र बनाने के लिए पीवीसी का उपयोग करना .

2.1. हम पीवीसी टाइपसबकॉन्टो बनाते हैं।

2.2. हम एक अधीनस्थ निर्देशिका ValuesSubConto बनाते हैं (जैसा कि विशेषताओं के साथ होता है, इसमें सबकॉन्टो मान होंगे यदि अन्य निर्देशिकाओं में ऐसा कोई नहीं है)।

2.3. खातों के चार्ट का उपयोग करके संचार किया जाता है।

*************************************************************************************************
लेखांकन रजिस्टर संसाधन:

राशि - बैलेंस शीट,
मात्रा - ऑफ-बैलेंस शीट और लेखांकन विशेषता से संबंधित मात्रात्मक

*************************************************************************************************
वर्चुअल अकाउंटिंग रजिस्टर टेबल:

टर्नओवर: एकल खाते का टर्नओवर
टर्नओवरडीटीकेटी: किन्हीं दो खातों के बीच टर्नओवर, यानी अवधि के लिए सभी समान लेनदेन।

*************************************************************************************************
लेखांकन रजिस्टरों पर मुद्रा लेखांकन - कैसे लागू करें:

हम खातों के चार्ट में एक लेखांकन विशेषता "मुद्रा" बनाते हैं।
लेखांकन रजिस्टर में, हम अतिरिक्त रूप से बनाते हैं:
- मुद्रा आयाम (रिक्त मूल्यों का निषेध, ऑफ-बैलेंस शीट, लेखांकन विशेषता - मुद्रा)
- संसाधन करेंसीअमाउंट (ऑफ-बैलेंस शीट, लेखांकन विशेषता - मुद्रा, यह राशि को मुद्रा में संग्रहीत करेगा, यानी उदाहरण के लिए $100)
सभी।

इस प्रकार रजिस्टर संरचना है:

माप:
- मुद्रा
संसाधन
- मात्रा
- राशि (रूबल में राशि)
- मुद्राराशि (मुद्रा में राशि)

इस प्रकार, मुद्रा लेखांकन बेलारूस गणराज्य में पारंपरिक लेखांकन का केवल एक परिशोधन है; यह उदाहरण के लिए, संसाधन राशि का सार नहीं बदलता है
(वहां, हमेशा की तरह, राशि रूबल में है, भले ही खाता विदेशी मुद्रा में हो या नहीं)।
और यदि खाते के लिए मुद्रा लेखांकन सुविधा बंद कर दी गई है, तो यह बेलारूस गणराज्य की सामान्य संरचना है (संसाधन - केवल मात्रा और राशि)।

*************************************************************************************************
वर्चुअल टेबल का एक टुकड़ा प्राप्त करने के लिए उसके पैरामीटर सेट करते समय, हम आयामों पर शर्तें लगाते हैं, संसाधनों पर नहीं।

अन्यथा, हमें नवीनतम का एक टुकड़ा नहीं मिलेगा, बल्कि निर्दिष्ट संसाधन मूल्य के साथ अंतिम रिकॉर्ड मिलेगा - यह आयामों के सेट में अंतिम नहीं हो सकता है

*************************************************************************************************
गणना रजिस्टर में संसाधन का अर्थ और विवरण

गणना रजिस्टरों में, एक संसाधन बनाने से इस रजिस्टर का उपयोग करके आधार की गणना करते समय इसे प्राप्त करना संभव हो जाता है।
और दी गई अवधि के अनुपात में भी, संसाधन मूल्य की पुनर्गणना की जाएगी (यदि आधार अवधि रजिस्टर की आवधिकता के साथ मेल नहीं खाती है)।

और विशेषता का मान केवल गणना रजिस्टर की वास्तविक तालिका में उपलब्ध है; यह आभासी तालिकाओं में उपलब्ध नहीं है।

*************************************************************************************************
गणना रजिस्टर आयाम के गुणों में चेकबॉक्स "बेसिक"।
इसका मतलब है कि भविष्य में इस आयाम से एक आधार प्राप्त किया जाएगा और इस क्षेत्र के लिए मूल्यों के अतिरिक्त अनुक्रमण के लिए कार्य किया जाएगा।

*************************************************************************************************
रजिस्टर प्रविष्टियों के सेट रिकॉर्ड करते समय छुट्टी की वैधता अवधि का महीने के हिसाब से टूटना,
यदि दस्तावेज़ में एक पंक्ति में एक साथ कई महीनों के लिए अवकाश निर्दिष्ट किया गया है:

वर्तमान माह की प्रारंभ तिथि = माह की शुरुआत (TexLineMainAccruals.ActionPeriodStart); currentMonthEndDate = EndMonth(TexLineMainAccruals.ActionPeriodStart); वर्तमान माह = दिनांक; जबकिDateStartCurrentMonth<= НачалоМесяца(ТекСтрокаОсновныеНачисления.ПериодДействияКонец) Цикл Движение = Движения.ОсновныеНачисления.Добавить(); Движение.Сторно = Ложь; Движение.ВидРасчета = ТекСтрокаОсновныеНачисления.ВидРасчета; Движение.ПериодДействияНачало = Макс(ДатаНачалаТекМесяца, ТекСтрокаОсновныеНачисления.ПериодДействияНачало); Движение.ПериодДействияКонец = КонецДня(Мин(ДатаОкончанияТекМесяца, ТекСтрокаОсновныеНачисления.ПериодДействияКонец)); Движение.ПериодРегистрации = Дата; Движение.Сотрудник = ТекСтрокаОсновныеНачисления.Сотрудник; Движение.Подразделение = ТекСтрокаОсновныеНачисления.Подразделение; Движение.Сумма = 0; Движение.КоличествоДней = 0; Движение.График = ТекСтрокаОсновныеНачисления.График; Движение.Параметр = ТекСтрокаОсновныеНачисления.Параметр; Движение.БазовыйПериодНачало = НачалоМесяца(ДобавитьМесяц(Дата, -3)); Движение.БазовыйПериодКонец = КонецДня(КонецМесяца(ДобавитьМесяц(Дата, -1))); ДатаНачалаТекМесяца = НачалоМесяца(ДобавитьМесяц(ДатаНачалаТекМесяца, 1)); ДатаОкончанияТекМесяца = КонецМесяца(ДатаНачалаТекМесяца); КонецЦикла; КонецЕсли;

*************************************************************************************************
गैंट चार्ट बनाना:

हम फॉर्म पर "गैंट चार्ट" प्रकार का एक तत्व रखते हैं, इसे डीजी कहते हैं, फिर "जेनरेट" कमांड बनाते हैं और फॉर्म मॉड्यूल में निम्नलिखित लिखते हैं:

&ऑनक्लाइंट प्रक्रिया जनरेट(कमांड) जेनरेटऑनसर्वर(); प्रक्रिया का अंत और सर्वर पर प्रक्रिया जनरेटऑन सर्वर() DG.Clear(); डीजी.अपडेट = गलत; अनुरोध = नया अनुरोध("SELECT | BasicAccrualsActualActionPeriod.Employee, |BasicAccrualsActualActionPeriod.CalculationType, |BasicAccrualsActualActionPeriod.ActionPeriodStart AS ActionPeriodStart, | BasicAccrualsActualActionPeriod.Period ActionsEnd AS periodActionsEnd |FROM |Calculation Register.Ba sicAccruals.ActualPeriodActions AS BasicAccrualsActualPeriodActions |WHERE |BasicAccrualsActualPeriodActions.PeriodActions के बीच और प्रारंभ दिनांक और &अंततिथि "); Query.SetParameter("StartDate", period.StartDate); Request.SetParameter('EndDate', period.EndDate); चुनें = Query.Run().Select(); जबकि चयन.अगला() लूप प्वाइंट = डीजी.सेटपॉइंट(चयन.कर्मचारी); सीरीज = डीजी.सेटसीरीज(चयन.गणना प्रकार); मान = DG.GetValue(बिंदु, श्रृंखला); अंतराल = मान.जोड़ें(); अंतराल.प्रारंभ = नमूना.पीरियडएक्शनस्टार्ट; अंतराल.अंत = नमूना.क्रियाअवधिअंत; अंतचक्र; डीजी.अद्यतन = सत्य; प्रक्रिया का अंत

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

*************************************************************************************************
गणना कार्यों में "उलट" प्रविष्टियों को संसाधित करना:

लेन-देन प्रसंस्करण प्रक्रिया (ऑब्जेक्ट मॉड्यूल) में, हम सभी गतिविधियां बनाते हैं, और फिर यदि अन्य अवधियों में रिकॉर्ड होते हैं, तो हम उन्हें इस तरह प्राप्त करते हैं
(सिस्टम उन्हें स्वचालित रूप से उत्पन्न करता है - हमारी मदद करता है):

अतिरिक्त रिकॉर्ड = मूवमेंट्स.मेनएक्रुअल्स.गेटएडिशन(); // अतिरिक्त प्राप्त करने के लिए गतिविधियों को रिकॉर्ड करने की आवश्यकता नहीं है

रिकॉर्ड परिवर्धन चक्र से प्रत्येक टेक लाइन के लिए
रिकॉर्ड = मूवमेंट्स.मेनएक्रुअल्स.एड();
fillPropertyValues(रिकॉर्ड, टेकस्ट्रिंग);
रिकॉर्ड.पंजीकरणअवधि = टेकस्ट्रिंग.पंजीकरणअवधिप्रवर्तन;
रिकॉर्ड.एक्शनपीरियडस्टार्ट = टेकस्ट्रिंग.एक्शनपीरियडस्टार्टरिवर्स;
रिकॉर्ड.एक्शनपीरियडएंड = टेकस्ट्रिंग.एक्शनपीरियडएंडरिवर्सल;
चक्र का अंत

और रिकॉर्ड की गणना करते समय, चेक डालें:

यदि TechMotion.Reversal तो
करंटमूवमेंट.सम = - करंटमूवमेंट.राशि;
अगर अंत;

*************************************************************************************************
यह कैसे निर्धारित करें कि गणना कार्यों में मुख्य उपार्जन में क्या शामिल है और अतिरिक्त उपार्जन में क्या शामिल है।

लेकिन यह हमेशा 100% स्पष्ट नहीं होता है; अधिक जटिल मामले भी होते हैं, हालाँकि उनमें से बहुत सारे हैं
(उदाहरण के लिए, एक बोनस जो एक महीने में कार्य दिवसों की संख्या पर निर्भर करता है - वह HE है)।

मूल शुल्क:
यदि गणना का प्रकार अनुसूची (अर्थात् कैलेंडर तिथियों के साथ सूचना का रजिस्टर) पर निर्भर है, तो यह मुख्य शुल्कों को संदर्भित करता है।

उदाहरण ओह:
- वेतन
- कुछ ऐसा जिसकी गणना कार्य दिवसों की संख्या से की जाती है (और इसके लिए आपको एक शेड्यूल का उपयोग करने की आवश्यकता है): या तो वैधता अवधि में (जैसे वेतन) या आधार अवधि में

अतिरिक्त जिम्मेदारी:
क्या माना जाता है या तो अर्जित राशि से, या काम किए गए समय से (और मानक नहीं!), या बिल्कुल भी निर्भर नहीं करता है - यह अतिरिक्त है। उपार्जन.

वह यह है: संचय जिनकी गणना के लिए समय मानक का उपयोग किया जाता है (शायद एक तथ्य भी) ओएच है, और जिसके लिए वास्तविक डेटा या कुछ भी आवश्यक नहीं है वह डीएन है।

या दूसरे शब्दों में:

यदि वीआर समय मानक का उपयोग करता है, तो वीआर के लिए वैधता अवधि शामिल की जानी चाहिए।

*************************************************************************************************
"नामकरण" निर्देशिका के सूची प्रपत्र में अंतर्निहित सहायता अनुभाग "संदर्भ पुस्तकों के साथ कार्य करना" खोलने की क्षमता जोड़ें।

प्रपत्र पर आदेश चलाएँ:

&ऑनक्लाइंट
प्रक्रिया सहायता(कमांड)
ओपनहेल्प('v8help://1cv8/EnterprWorkingWithCatalogs');
प्रक्रिया का अंत

हम सेक्शन लाइन को इस प्रकार परिभाषित करते हैं:
कॉन्फ़िगरेशन ऑब्जेक्ट (कॉन्फिगरेटर में) की सहायता जानकारी पर जाएं, एक शब्द लिखें, उसका चयन करें, एलिमेंट्स/लिंक मेनू पर जाएं और 1सी सहायता के वांछित अनुभाग का चयन करें, जिसके बाद लिंक स्वचालित रूप से डाला जाता है। यह जटिल दिखता है, लेकिन व्यवहार में यह आसान है।

*************************************************************************************************
प्रपत्रों के बीच अंतःक्रिया का कार्यान्वयन, उदाहरण के लिए, चयन:

1. वर्तमान फॉर्म से, "ओपनफॉर्म ()" विधि का उपयोग करके वांछित फॉर्म खोलें, पैरामीटर के साथ संरचना को दूसरे पैरामीटर के रूप में पास करें (यदि आवश्यक हो)। तीसरा पैरामीटर इस फॉर्म का लिंक पास कर सकता है - ThisForm।

2. खुले हुए फॉर्म में, "When CreatedOnServer()" हैंडलर में, हम "पैरामीटर्स.[पैरामीटरनाम]" के माध्यम से चरण 1 में पारित पैरामीटर्स को पकड़ सकते हैं। इस फॉर्म को खोलने की शुरुआत करने वाला फॉर्म "स्वामी" पहचानकर्ता के माध्यम से पहुंच योग्य होगा (यदि यह, निश्चित रूप से, चरण 1 में निर्दिष्ट था)।

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

*************************************************************************************************
फॉर्म पैरामीटर्स का जीवनचक्र

इसके खुलने के समय फॉर्म में स्थानांतरित किए गए सभी पैरामीटर केवल "व्हेन क्रिएटऑनसर्वर" प्रक्रिया में दिखाई देते हैं।
एक बार बन जाने के बाद, सभी पैरामीटर नष्ट हो जाते हैं और फ़ॉर्म पर उपलब्ध नहीं रहते।
अपवाद उन पैरामीटरों के लिए है जो प्रपत्र संपादक में "कुंजी पैरामीटर" विशेषता के साथ घोषित किए गए हैं।
वे रूप की विशिष्टता निर्धारित करते हैं।
यह पैरामीटर तब तक मौजूद रहेगा जब तक फॉर्म मौजूद है।

*************************************************************************************************
टैक्सी इंटरफ़ेस का उपयोग करना

विकास के दौरान, आप कॉन्फ़िगरेशन गुणों में सामान्य प्रबंधित इंटरफ़ेस 8.2 सेट कर सकते हैं - यह सब कुछ अधिक कॉम्पैक्ट और परिचित बनाता है।
यह विशेष रूप से सच है यदि आप दूर से किराए पर लेते हैं - स्क्रीन रिज़ॉल्यूशन बहुत छोटा है, और "टैक्सी" इंटरफ़ेस के साथ कुछ भी करना असंभव है।
जब आपका काम पूरा हो जाए तो फिर से "टैक्सी" लगाना न भूलें!अन्यथा, परीक्षक अंक काट लेगा!

*************************************************************************************************

पीएस: ई अलग-अलग मानक उप-कार्य हैं जिनका उपयोग सभी कार्यों में किया जाता है, और इन्हें ही आपको हल करने में सक्षम होना चाहिए (उदाहरण के लिए, बैचों द्वारा लिखना, पीवीसी का उपयोग करना (ठीक है, यह वास्तव में दुर्लभ है) और अन्य)। और सभी कार्यों में उन्हें बस दोहराया जाता है (कहीं कुछ उपकार्य होते हैं, कहीं और, बस अलग-अलग संयोजनों में)। इसके अलावा, उन्होंने लंबे समय से एक नया संग्रह जारी करने का वादा किया है (यदि उन्होंने पहले से नहीं किया है), जिसमें बहुत अधिक समस्याएं होनी चाहिए, यानी, व्यक्तिगत समस्याओं के समाधान को याद रखने का कोई मतलब नहीं है, यह सीखना समझ में आता है कि कैसे व्यक्तिगत मानक उपकार्यों को हल करें, फिर आप किसी भी समस्या का समाधान करेंगे।

पीएसएस: सहकर्मियों, अगर किसी के पास परीक्षा की तैयारी और उसे पास करने के बारे में कोई अन्य उपयोगी जानकारी है, तो कृपया टिप्पणियों में लिखें और हम लेख में जोड़ देंगे।