🔴 🛀🏾 🚸 दूसरी प्रोग्रामिंग लैंग्वेज नहीं। भाग 3: भौतिकी 🧒 👵🏾 📯

LsFusion भाषा पर लेखों की एक श्रृंखला का तीसरा और अंतिम भाग ( पहले और दूसरे भाग के लिंक)

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

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

इस लेख में, हम एक चित्र के बिना करते हैं (इस तरह का कोई स्टैक नहीं है), लेकिन हम पिछले लेख में अनुरोध किए अनुसार सामग्री की तालिका करेंगे।

सामग्री की तालिका

आइटम पहचान

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

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

नामस्थान

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

प्लेटफ़ॉर्म का प्रत्येक तत्व कुछ नामस्थानों में बनाया गया है
यदि एक तत्व बनाने की प्रक्रिया में, अन्य तत्वों को संदर्भित किया जाता है, तो समान नामस्थान में बनाए गए तत्व पूर्वता लेते हैं

MODULE PurchaseInvoice;
NAMESPACE Purchase;
CLASS Invoice ' ()' ;

MODULE SaleInvoice;
NAMESPACE Sale;
CLASS Invoice ' ()' ;

MODULE PurchaseShipment;
REQUIRE PurchaseInvoice, SaleInvoice;
NAMESPACE Purchase;
// Invoice Purchase.Invoice, Sale.invoice
// namespace Purchase namespace Purchase
shipment(Invoice invoice) = AGGR ShipmentInvoce WHERE createShipment(invoice);

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

स्पष्ट टाइपिंग

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

sum = DATA NUMERIC [ 10 , 2 ] (OrderDetail);
sum = GROUP SUM sum(OrderDetail od) BY order(od);
// , Order
// OrderDetail
CONSTRAINT sum(Order o) < 0 MESSAGE ' ' ;

यहां, निश्चित रूप से, सवाल उठ सकता है: अगर वांछित संपत्ति का नाम स्थान प्राथमिकता नहीं है, तो क्या होगा, लेकिन यह कक्षाओं के लिए बेहतर है? वास्तव में, सामान्य खोज एल्गोरिथ्म काफी जटिल है (इसका पूर्ण विवरण यहां है ) और ऐसे "अस्पष्ट" मामलों की संख्या बहुत अधिक है, इसलिए अनिश्चितता के मामले में वांछित संपत्ति के नाम स्थान / वर्गों को स्पष्ट रूप से निर्दिष्ट करने की सिफारिश की जाती है, या आईडीई में डबल-चेक (घोषणा पर जाएं) CTRL + B) जो संपत्ति मिली है वही वास्तव में थी।

इसके अलावा, यह ध्यान देने योग्य है कि lsFusion में स्पष्ट टाइपिंग आमतौर पर आवश्यक नहीं है। पैरामीटर कक्षाओं को छोड़ दिया जा सकता है, और यदि मंच के पास वांछित संपत्ति खोजने के लिए पर्याप्त जानकारी है, तो वह ऐसा करेगा। दूसरी ओर, वास्तव में जटिल परियोजनाओं में, यह अभी भी स्पष्ट रूप से पैरामीटर वर्गों को निर्धारित करने के लिए अनुशंसित है, न केवल कोड की संक्षिप्तता के दृष्टिकोण से, बल्कि विभिन्न अतिरिक्त सुविधाओं के दृष्टिकोण से भी, जैसे: प्रारंभिक त्रुटि निदान, आईडीई से स्मार्ट ऑटो-पूरा और इतने पर। हमारे पास अंतर्निहित टाइपिंग (पहले 5 साल) और स्पष्ट (शेष समय) दोनों के साथ काम करने का व्यापक अनुभव था, और मुझे कहना होगा कि निहित टाइपिंग के समय को अब एक कंपकंपी के साथ याद किया जाता है (हालांकि यह केवल "हमें यह नहीं पता है कि इसे कैसे पकाना है")।

प्रतिरूपकता

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

LsFusion निम्नलिखित दो तंत्रों के साथ मॉड्यूलरता प्रदान करता है:

एक्सटेंशन - सिस्टम के तत्वों को बनाने (बदलने) का विस्तार करने की क्षमता के बाद उन्हें बनाया जाता है।
मॉड्यूल - इसके आगे के पुन: उपयोग के लिए कुछ कार्यक्षमता को एक साथ समूहित करने की क्षमता।

विस्तार

lsFusion पहले लेख में वर्णित बहुरूपता तंत्र के माध्यम से कक्षाओं और रूपों, साथ ही गुणों और कार्यों का विस्तार करने की क्षमता का समर्थन करता है।

sum = DATA NUMERIC [ 10 , 2 ] (OrderDetail);
sum = GROUP SUM sum(OrderDetail od) BY order(od);
// , Order
// OrderDetail
CONSTRAINT sum(Order o) < 0 MESSAGE ' ' ;
CLASS ABSTRACT Shape;
CLASS Box : Shape;

CLASS Quadrilateral;
EXTEND CLASS Box : Quadrilateral; //

CLASS ShapeType {
point '' ,
segment ''
}

EXTEND CLASS ShapeType { //
circle ''
}

CLASS ItemGroup;
name = DATA ISTRING [ 100 ] (ItemGroup);

itemGroup = DATA ItemGroup (Item);

EXTEND FORM items
PROPERTIES (i) NEWSESSION DELETE //

OBJECTS g = ItemGroup BEFORE i //
PROPERTIES (g) READONLY name
FILTERS itemGroup(i) == g // , ,
;

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

मॉड्यूल

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

आमतौर पर, मॉड्यूल अपने स्वयं के / मौजूदा तत्वों का विस्तार करने की घोषणा करने के लिए अन्य मॉड्यूल के तत्वों का उपयोग करते हैं। तदनुसार, यदि मॉड्यूल बी मॉड्यूल ए से तत्वों का उपयोग करता है, तो मॉड्यूल बी में इंगित करना आवश्यक है कि यह ए पर निर्भर करता है।

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

मॉड्यूल के बीच निर्भरता सकर्मक हैं। यही है, यदि मॉड्यूल सी मॉड्यूल बी पर निर्भर करता है, और मॉड्यूल बी मॉड्यूल ए पर निर्भर करता है, तो यह माना जाता है कि मॉड्यूल सी भी मॉड्यूल ए पर निर्भर करता है।

कोई भी मॉड्यूल हमेशा सिस्टम मॉड्यूल सिस्टम पर निर्भर करता है, भले ही यह स्पष्ट रूप से इंगित किया गया हो या नहीं।

MODULE EmployeeExample; //

REQUIRE Authentication, Utils; // , Employee
NAMESPACE Employee; //

CLASS Employee '' ; //
CLASS Position '' ; //

employeePosition(employee) = DATA Position (Employee); //

metaprogramming

मेटाप्रोग्रामिंग एक प्रकार का प्रोग्रामिंग है जो लेखन प्रोग्राम कोड से जुड़ा है, जिसके परिणामस्वरूप एक और प्रोग्राम कोड उत्पन्न होता है। LsFusion रूपक के लिए तथाकथित मेटाकोड का उपयोग करता है।

मेटाकोड में निम्न शामिल हैं:

मेटाकोड नाम
मेटाकोड पैरामीटर
एक मेटाकोड का निकाय - एक कोड ब्लॉक जिसमें घोषणा और / या सिस्टम तत्वों (गुण, कार्य, घटनाएं, अन्य मेटाकोड, आदि) के एक्सटेंशन शामिल हैं।

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

घोषणा:

META addActions(formName)
EXTEND FORM formName
PROPERTIES () showMessage, closeForm
;
END

का उपयोग करें:

@addActions (documentForm);
@addActions (orderForm);

परिणाम कोड:

EXTEND FORM documentForm
PROPERTIES () showMessage, closeForm
;
EXTEND FORM orderForm
PROPERTIES () showMessage, closeForm
;

केवल मेटाकोड मापदंडों को प्रतिस्थापित करने के अलावा, मंच आपको इन मापदंडों को मौजूदा पहचानकर्ताओं / स्ट्रिंग शाब्दिक (या एक दूसरे के साथ) के साथ संयोजन करने की अनुमति देता है, उदाहरण के लिए:

घोषणा:

META objectProperties(object, caption)
object ## Name ' ' ## caption = DATA BPSTRING [ 100 ](object);
object ## Type ' ' ## caption = DATA Type (object);
object ## Value ' ' ## caption = DATA INTEGER (object);
END

का उपयोग करें:

@objectProperties (document, '' );

परिणाम कोड:

DocumentName ' ' = DATA BPSTRING [ 100 ](Document);
DocumentType ' ' = DATA Type (Document);
DocumentValue ' ' = DATA INTEGER (Document);

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

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

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

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

एकीकरण

एकीकरण में अन्य प्रणालियों के साथ lsFusion प्रणाली की बातचीत से संबंधित सब कुछ शामिल है। इस अंतःक्रिया की दिशा के दृष्टिकोण से, एकीकरण को विभाजित किया जा सकता है:

किसी अन्य सिस्टम से lsFusion सिस्टम तक पहुँचना।
LsFusion सिस्टम से दूसरे सिस्टम तक पहुँच।

भौतिक मॉडल के दृष्टिकोण से, एकीकरण को इसमें विभाजित किया जा सकता है:

LsFusion सर्वर के जावा वर्चुअल मशीन (JVM) और / या lsFusion सिस्टम के रूप में समान SQL सर्वर का उपयोग करके "समान वातावरण" में चल रहे सिस्टम के साथ सहभागिता।
नेटवर्क प्रोटोकॉल के माध्यम से रिमोट सिस्टम के साथ सहभागिता।

तदनुसार, पहले सिस्टम को आंतरिक कहा जाएगा, दूसरा - बाहरी।

इस प्रकार, प्लेटफ़ॉर्म में चार अलग-अलग एकीकरण हैं:

एक बाहरी प्रणाली के लिए अपील
बाहरी व्यवस्था से अपील
आंतरिक प्रणाली के लिए अपील
आंतरिक प्रणाली से अपील

एक बाहरी प्रणाली के लिए अपील

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

वर्तमान में, प्लेटफ़ॉर्म निम्न प्रकार के इंटरैक्शन / बाहरी सिस्टम का समर्थन करता है:

HTTP - वेब सर्वर से http अनुरोध करता है।

इस प्रकार के इंटरैक्शन के लिए, आपको एक क्वेरी स्ट्रिंग (URL) निर्दिष्ट करना होगा, जो एक साथ सर्वर पते और अनुरोध दोनों को निर्धारित करता है जिसे निष्पादित करने की आवश्यकता है। पैरामीटर दोनों को क्वेरी लाइन (पैरामीटर तक पहुंचने के लिए, विशेष वर्ण $ और इस पैरामीटर की संख्या, 1 से शुरू) का उपयोग किया जा सकता है, साथ ही साथ इसके शरीर (बॉडी) में भी स्थानांतरित किया जा सकता है। यह माना जाता है कि क्वेरी स्ट्रिंग में उपयोग नहीं किए जाने वाले सभी पैरामीटर BODY को दिए जाते हैं। यदि BODY में एक से अधिक पैरामीटर हैं, तो ट्रांसमिशन के दौरान BODY सामग्री प्रकार मल्टीपार्ट / मिश्रित करने के लिए सेट है, और पैरामीटर को इस BODY के घटकों के रूप में स्थानांतरित किया जाता है।

BODY में फ़ाइल कक्षाओं (FILE, PDFFILE, आदि) के पैरामीटर को संसाधित करते समय फ़ाइल एक्सटेंशन (निम्न तालिका के अनुसार) के आधार पर पैरामीटर का प्रकार निर्धारित किया जाता है। यदि फ़ाइल एक्सटेंशन इस तालिका में नहीं है, तो सामग्री प्रकार एप्लिकेशन / <फ़ाइल एक्सटेंशन> पर सेट है।

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

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

EXTERNAL HTTP GET 'https://www.cs.cmu.edu/~chuck/lennapg/len_std.jpg' TO exportFile;
open(exportFile());

LOCAL headers = STRING ( STRING );
headers( 'Authentication : Bearer' ) <- 'd43ks43ds343dd233' ';
EXTERNAL HTTP 'http://tryonline.lsfusion.org/exec?action=getExamples'
HEADERS headers
HEADERSTO headers
PARAMS JSONFILE ( '\{"mode"=1\}' )
TO exportFile;

IMPORT FROM exportFile() FIELDS () STRING caption, STRING code DO
MESSAGE 'Example : ' + caption + ', code : ' + code;
FOR v = headers( STRING s) DO
MESSAGE 'Result Header is : Key - ' + s + ', Value - ' + v;

SQL - SQL सर्वर कमांड को निष्पादित करता है।

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

फ़ाइल वर्गों (FILE, PDFFILE, आदि) के पैरामीटर का उपयोग केवल SQL कमांड में किया जा सकता है। इसके अलावा, यदि निष्पादन के दौरान कोई भी पैरामीटर एक टेबल फाइल (टेबल एक्सटेंशन के साथ टेबल या फाइल) है, तो यह पैरामीटर इस मामले में भी एक टेबल माना जाता है:

SQL कमांड को निष्पादित करने से पहले, इस तरह के प्रत्येक पैरामीटर का मान अस्थायी तालिका में सर्वर पर लोड किया जाता है
मापदंडों का प्रतिस्थापन करते समय, यह पैरामीटर मान ही नहीं होता है जिसे प्रतिस्थापित किया जाता है, बल्कि निर्मित अस्थायी तालिका का नाम है

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

externalSQL () {
EXPORT TABLE FROM bc=barcode(Article a) WHERE name(a) LIKE '%%' ; // -
EXTERNAL SQL 'jdbc:mysql://$1/test?user=root&password='
EXEC 'select price AS pc, articles.barcode AS brc from $2 x JOIN articles ON x.bc=articles.barcode'
PARAMS 'localhost' ,exportFile()
TO exportFile; // -

// -
LOCAL price = INTEGER ( INTEGER );
LOCAL barcode = STRING [ 30 ] ( INTEGER );
IMPORT FROM exportFile() TO price=pc,barcode=brc;
FOR barcode(Article a) = barcode( INTEGER i) DO
price(a) <- price(i);
}

एलएसएफ - एक और lsFusion सर्वर की एक कार्रवाई कॉल।

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

इस प्रकार की इंटरैक्शन में कार्रवाई सेट करने की विधि पूरी तरह से बाहरी सिस्टम से एक्सेस करते समय (अगले अनुभाग में इस प्रकार की पहुंच के बारे में) कार्रवाई की विधि के अनुरूप है।

externalLSF() {
EXTERNAL LSF 'http://localhost:7651' EXEC 'System.testAction[]' ;
}

डिफ़ॉल्ट रूप से, इस प्रकार का इंटरैक्शन बाहरी प्रोटोकॉल से / से एक्सेस करने के लिए उचित इंटरफेस का उपयोग करके HTTP प्रोटोकॉल का उपयोग करके लागू किया जाता है।

इस घटना में कि आपको उपरोक्त से भिन्न प्रोटोकॉल का उपयोग करके सिस्टम तक पहुंचने की आवश्यकता है, आप हमेशा जावा में एक कार्रवाई करके और इस कॉल को वहां लागू कर सकते हैं (लेकिन बाद में "आंतरिक सिस्टम तक पहुंच")

बाहरी व्यवस्था से अपील

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

तथाकथित कार्रवाई को तीन तरीकों में से एक में सेट किया जा सकता है:

/ एक्शन? एक्शन = <एक्शन नाम> - तथाकथित एक्शन का नाम सेट करता है।
/ eval? script = <code> - lsFusion में कोड सेट करता है। यह माना जाता है कि इस कोड में नाम चलाने के साथ एक कार्रवाई की घोषणा है, यह यह कार्रवाई है जिसे कहा जाएगा। यदि स्क्रिप्ट पैरामीटर निर्दिष्ट नहीं है, तो यह माना जाता है कि कोड को पहले बॉडी पैरामीटर के रूप में पास किया गया है।
/ eval / action? script = <action code> - एक्शन कोड को lsFusion में सेट करता है। मापदंडों तक पहुंचने के लिए, आप विशेष वर्ण $ और पैरामीटर संख्या (1 से शुरू) का उपयोग कर सकते हैं।

दूसरे और तीसरे मामलों में, यदि स्क्रिप्ट पैरामीटर निर्दिष्ट नहीं है, तो यह माना जाता है कि कोड पहले बॉडी पैरामीटर द्वारा पारित किया गया है।

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

उदाहरण के लिए, यदि हमारे पास कोई कार्रवाई है:

importOrder( INTEGER no, DATE date, FILE detail) {
NEW o = FOrder {
no(o) <- no;
date(o) <- date;
LOCAL detailId = INTEGER ( INTEGER );
LOCAL detailQuantity = INTEGER ( INTEGER );
IMPORT FROM detail TO detailId, detailQuantity;
FOR imported( INTEGER i) DO {
NEW od = FOrderDetail {
id(od) <- detailId(i);
quantity(od) <- detailQuantity(i);
price(od) <- 5 ;
order(od) <- o;
}
}
APPLY ;
EXPORT JSON FROM price = price(FOrderDetail od), id = id(od) WHERE order(od) = o;
EXPORT FROM orderPrice(o), exportFile();
}
}

तब आप POST अनुरोध का उपयोग करके इसे एक्सेस कर सकते हैं:

URL - http: // server_address / execute? क्रिया = importOrder और p = 123 & p = 2019-01-01
बॉडी - क्वेरी स्ट्रिंग्स के साथ json फ़ाइल

पायथन कॉल उदाहरण

 import json import requests from requests_toolbelt.multipart import decoder lsfCode = ("run(INTEGER no, DATE date, FILE detail) {\n" " NEW o = FOrder {\n" " no(o) <- no;\n" " date(o) <- date;\n" " LOCAL detailId = INTEGER (INTEGER);\n" " LOCAL detailQuantity = INTEGER (INTEGER);\n" " IMPORT JSON FROM detail TO detailId, detailQuantity;\n" " FOR imported(INTEGER i) DO {\n" " NEW od = FOrderDetail {\n" " id(od) <- detailId(i);\n" " quantity(od) <- detailQuantity(i);\n" " price(od) <- 5;\n" " order(od) <- o;\n" " }\n" " }\n" " APPLY;\n" " EXPORT JSON FROM price = price(FOrderDetail od), id = id(od) WHERE order(od) == o;\n" " EXPORT FROM orderPrice(o), exportFile();\n" " }\n" "}") order_no = 354 order_date = '10.10.2017' order_details = [dict(id=1, quantity=10), dict(id=2, quantity=15), dict(id=5, quantity=4), dict(id=10, quantity=18), dict(id=11, quantity=1), dict(id=12, quantity=3)] order_json = json.dumps(order_details) url = 'http://localhost:7651/eval' payload = {'script': lsfCode, 'no': str(order_no), 'date': order_date, 'detail': ('order.json', order_json, 'text/json')} response = requests.post(url, files=payload) multipart_data = decoder.MultipartDecoder.from_response(response) sum_part, json_part = multipart_data.parts sum = int(sum_part.text) data = json.loads(json_part.text) ############################################################## print(sum) for item in data: print('{0:3}: price {1}'.format(int(item['id']), int(item['price']))) ############################################################## # 205 # 4: price 5 # 18: price 5 # 3: price 5 # 1: price 5 # 10: price 5 # 15: price 5

आंतरिक प्रणाली के लिए अपील

आंतरिक बातचीत दो प्रकार की होती है:

जावा इंटरऑपरेबिलिटी

इस प्रकार का इंटरैक्शन आपको JVM lsFusion सर्वर के अंदर जावा कोड को कॉल करने की अनुमति देता है। ऐसा करने के लिए, आपको चाहिए:

यह सुनिश्चित करें कि संकलित जावा वर्ग अनुप्रयोग सर्वर के वर्गपथ में सुलभ है। यह भी आवश्यक है कि यह वर्ग lsfusion.server.physics.dev.integration.internal.to.InternalAction को इनहेरिट करता है।

जावा वर्ग उदाहरण

 import lsfusion.server.data.sql.exception.SQLHandledException; import lsfusion.server.language.ScriptingErrorLog; import lsfusion.server.language.ScriptingLogicsModule; import lsfusion.server.logics.action.controller.context.ExecutionContext; import lsfusion.server.logics.classes.ValueClass; import lsfusion.server.logics.property.classes.ClassPropertyInterface; import lsfusion.server.physics.dev.integration.internal.to.InternalAction; import java.math.BigInteger; import java.sql.SQLException; public class CalculateGCD extends InternalAction { public CalculateGCD(ScriptingLogicsModule LM, ValueClass... classes) { super(LM, classes); } @Override protected void executeInternal(ExecutionContext<ClassPropertyInterface> context) throws SQLException, SQLHandledException { BigInteger b1 = BigInteger.valueOf((Integer)getParam(0, context)); BigInteger b2 = BigInteger.valueOf((Integer)getParam(1, context)); BigInteger gcd = b1.gcd(b2); try { findProperty("gcd[]").change(gcd.intValue(), context); } catch (ScriptingErrorLog.SemanticErrorException ignored) { } } }

विशेष आंतरिक कॉल ऑपरेटर (इंटरनल) का उपयोग करके कार्रवाई दर्ज करें
calculateGCD ' ' INTERNAL 'CalculateGCD' ( INTEGER , INTEGER );
किसी भी अन्य की तरह एक पंजीकृत कार्रवाई, कॉल ऑपरेटर का उपयोग करके कॉल की जा सकती है। इस मामले में, निर्दिष्ट जावा वर्ग के निष्पादन योग्य (lsfusion.server.logics.action.controller.context.ExecutionContext संदर्भ) विधि निष्पादित की जाएगी।
// FORM gcd '' OBJECTS (a = INTEGER , b = INTEGER ) PANEL PROPERTIES 'A' = VALUE (a), 'B' = VALUE (b) PROPERTIES gcd(), calculateGCD(a, b) ; // run() { calculateGCD( 100 , 200 ); }

एसक्यूएल बातचीत

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

round(number, digits) = FORMULA 'round(CAST(($1) as numeric),$2)' ; // :
jumpWorkdays = FORMULA NULL DATE PG 'jumpWorkdays($1, $2, $3)' , MS 'dbo.jumpWorkdays($1, $2, $3)' ; // SQL

इस ऑपरेटर को केवल उन मामलों में उपयोग करने की अनुशंसा की जाती है जहां अन्य ऑपरेटरों की मदद से कार्य को हल नहीं किया जा सकता है, साथ ही अगर यह गारंटी दी जाती है कि कौन से विशिष्ट SQL सर्वर का उपयोग किया जा सकता है, या उपयोग किए गए सिंटैक्स निर्माण नवीनतम SQL मानकों में से एक का अनुपालन करते हैं।

आंतरिक प्रणाली से अपील

आंतरिक प्रणाली की अपील के लिए सब कुछ सममित है। बातचीत के दो प्रकार हैं:

जावा इंटरऑपरेबिलिटी

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

सीधे एक lsFusion प्रणाली के जावा तत्वों का उपयोग करने के लिए, आपको सबसे पहले किसी ऐसी वस्तु का लिंक प्राप्त करना होगा जिसमें इन जावा तत्वों को खोजने के लिए इंटरफेस होगा। यह आमतौर पर दो तरीकों में से एक में किया जाता है:

यदि प्रारंभ में कॉल lsFusion सिस्टम (ऊपर वर्णित तंत्र के माध्यम से) से आता है, तो "खोज ऑब्जेक्ट" के रूप में आप "ऑब्जेक्ट" का उपयोग कर सकते हैं, जिसके माध्यम से यह कॉल जाती है (इस क्रिया का वर्ग lsfusion.server.physics.dev.integration से इनहेरिट करना चाहिए। internal.to.InternalAction, जो, बदले में, सभी आवश्यक इंटरफेस हैं)।
यदि जिस विधि से lsFusion प्रणाली का उपयोग करना आवश्यक है, वह एक स्प्रिंग बीन है, तो निर्भरता इंजेक्शन (क्रमशः बीन को बिजनेस लॉजिक कहा जाता है) का उपयोग करके व्यावसायिक तर्क ऑब्जेक्ट का लिंक प्राप्त किया जा सकता है।

जावा वर्ग उदाहरण

 import lsfusion.server.data.sql.exception.SQLHandledException; import lsfusion.server.data.value.DataObject; import lsfusion.server.language.ScriptingErrorLog; import lsfusion.server.language.ScriptingLogicsModule; import lsfusion.server.logics.action.controller.context.ExecutionContext; import lsfusion.server.logics.classes.ValueClass; import lsfusion.server.logics.property.classes.ClassPropertyInterface; import lsfusion.server.physics.dev.integration.internal.to.InternalAction; import java.math.BigInteger; import java.sql.SQLException; public class CalculateGCDObject extends InternalAction { public CalculateGCDObject(ScriptingLogicsModule LM, ValueClass... classes) { super(LM, classes); } @Override protected void executeInternal(ExecutionContext<ClassPropertyInterface> context) throws SQLException, SQLHandledException { try { DataObject calculation = (DataObject)getParamValue(0, context); BigInteger a = BigInteger.valueOf((Integer)findProperty("a").read(context, calculation)); BigInteger b = BigInteger.valueOf((Integer)findProperty("b").read(context, calculation)); BigInteger gcd = a.gcd(b); findProperty("gcd[Calculation]").change(gcd.intValue(), context, calculation); } catch (ScriptingErrorLog.SemanticErrorException ignored) { } } }

SQL इंटरैक्शन

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

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

प्रवास

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

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

 V< > { 1 ... N }

बदले में, निम्न प्रकार हैं:

DATA PROPERTY oldNS.oldName[class1,...,classN] -> newNS.newName[class1,...,classN]
CLASS oldNS.oldName -> newNS.newName
OBJECT oldNS.oldClassName.oldName -> newNS.newClassName.newName

TABLE oldNS.oldName -> newNS.newName
PROPERTY oldNS.oldName[class1,...,classN] -> newNS.newName[class1,...,classN]
FORM PROPERTY oldNS.oldFormName.oldName(object1,...,objectN) -> newNS.newFormName.newName(object1,...,objectN)
NAVIGATOR oldNS.oldName -> newNS.newName

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

मेटाडेटा माइग्रेशन (सुरक्षा नीतियां, तालिका सेटिंग, आदि) के लिए
उपयोगकर्ता डेटा के माइग्रेशन को अनुकूलित करने के लिए (ताकि एकत्रीकरण की पुनर्गणना न हो और एक बार फिर तालिकाओं के बीच डेटा स्थानांतरित न हो)।

तदनुसार, यदि मेटाडेटा माइग्रेशन की आवश्यकता नहीं है या बहुत अधिक डेटा नहीं है, तो माइग्रेशन स्क्रिप्ट में ऐसे परिवर्तन छोड़ दिए जा सकते हैं।

प्रवासन का उदाहरण

V0. 3.1 {
DATA PROPERTY Item.gender[Item.Article] -> Item.dataGender[Item.Article] // DATA
PROPERTY System.SIDProperty[Reflection.Property] -> Reflection.dbNameProperty[Reflection.Property] //
FORM PROPERTY Item.itemForm.name(i) -> Item.itemForm.itemName(i)
}

V0. 4 {
FORM PROPERTY Document.documentForm.name(i) -> Document.itemForm.itemName(i)
FORM PROPERTY Item.itemForm.itemName(i) -> Item.itemForm.iname // : iname = itemName(i)
CLASS Date.DateInterval -> Date.Interval
OBJECT Geo.Direction.North -> Geo.Direction.north
TABLE User.oldTable -> User.newTable
}

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

अंतर्राष्ट्रीयकरण

व्यवहार में, कभी-कभी ऐसी स्थिति उत्पन्न होती है जब विभिन्न भाषाओं में एक अनुप्रयोग का उपयोग करने में सक्षम होना आवश्यक होता है। यह कार्य आमतौर पर उपयोगकर्ता द्वारा देखे जाने वाले सभी स्ट्रिंग डेटा को स्थानीयकृत करने के लिए नीचे आता है, जैसे: पाठ संदेश, संपत्ति शीर्षलेख, कार्य, फ़ॉर्म, आदि। यह सब डेटा lsFusion में स्ट्रिंग शाब्दिक (एकल उद्धरण में तार, उदाहरण के लिए 'abc') का उपयोग करके सेट किया गया है, क्रमशः, उनका स्थानीयकरण निम्नानुसार किया जाता है:

पाठ को स्थानीयकृत करने के बजाय, स्ट्रिंग डेटा की पहचान करता है, जो ब्रेसिज़ में संलग्न है (उदाहरण के लिए, '{button.cancel}')।
जब यह स्ट्रिंग क्लाइंट को सर्वर पर भेजी जाती है, तो यह स्ट्रिंग में पाए गए सभी पहचानकर्ताओं को खोजती है, फिर वांछित लोकेल (अर्थात क्लाइंट लोकेल) में सभी रिसोर्सबंडल प्रोजेक्ट फाइलों में उनमें से प्रत्येक को खोजती है , और जब सही विकल्प मिलता है, तो ब्रैकेट्स में पहचानकर्ता को संबंधित पाठ से बदल दिया जाता है।

script '{scheduler.script.scheduled.task.detail}' = DATA TEXT (ScheduledTaskDetail);
CONSTRAINT script(ScheduledTaskDetail d) AND action(d) MESSAGE '{scheduler.constraint.script.and.action}' ;
FORM scheduledTask '{scheduler.form.scheduled.task}' ;

ServerResourceBundle.properties:

 scheduler.script.scheduled.task.detail=Script scheduler.constraint.script.and.action=In the scheduler task property and script cannot be selected at the same time scheduler.form.scheduled.task=Tasks

ServerResourceBundle_ru.properties

 scheduler.script.scheduled.task.detail= scheduler.constraint.script.and.action=           scheduler.form.scheduled.task=

बड़ी डेटा परियोजनाओं के प्रदर्शन का अनुकूलन करें

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

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

. ( , ), , , .
. , , .
. / , . «» .

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

एक संपत्ति का भौतिककरण किया जा सकता है यदि और केवल तभी इसके लिए वस्तुओं की एक निश्चित संख्या है जिसके लिए इस संपत्ति का मूल्य NULL नहीं है।

आम तौर पर, हाल ही के लेख में सामग्रीकरण के विषय की पर्याप्त रूप से जांच की गई थी डेटाबेस में लिखने और पढ़ने के संतुलन के बारे में, इसलिए इस पर विस्तार से यहाँ, मेरी राय में, बहुत मतलब नहीं है।

सूचकांक

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

केवल भौतिक गुणों को अनुक्रमित किया जा सकता है (ऊपर के अनुभाग से)।

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

INDEX customer(Order o);

date = DATA DATE (Order);
INDEX date(Order o), o;

INDEX name(Sku s), price(s, DATE d), d;

टेबल

LsFusion संपत्ति मूल्यों को संग्रहीत और गणना करने के लिए एक संबंधपरक डेटाबेस का उपयोग करता है। सभी प्राथमिक गुण, साथ ही सभी एकत्रित गुण जो भौतिक रूप में चिह्नित हैं, डेटाबेस तालिकाओं के क्षेत्र में संग्रहीत हैं। प्रत्येक तालिका के लिए, Key0, key1, ..., keyN, नाम के साथ प्रमुख फ़ील्ड्स का एक सेट होता है, जिसमें वस्तुओं के मूल्यों को संग्रहीत किया जाता है (उदाहरण के लिए, कस्टम कक्षाओं के लिए, इन वस्तुओं के पहचानकर्ता)। अन्य सभी फ़ील्ड संपत्ति मानों को इस तरह से संग्रहीत करते हैं कि प्रत्येक पंक्ति के संबंधित फ़ील्ड में कुंजी फ़ील्ड से ऑब्जेक्ट के लिए गुण मान है।

तालिका बनाते समय, आपको उन वस्तुओं की कक्षाओं की एक सूची निर्दिष्ट करनी होगी जो इस तालिका में कुंजियाँ होंगी।

TABLE book (Book);

in = DATA BOOLEAN (Sku, Stock);
TABLE skuStock (Sku, Stock); // in

price = DATA NUMERIC [ 10 , 2 ] (Sku, DATE );
TABLE skuDate (Sku, DATE ); // Sku

TABLE sku (Sku);

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

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

नीति	टेबल का नाम	क्षेत्र का नाम
हस्ताक्षर (डिफ़ॉल्ट) के साथ पूर्ण	अंतरिक्ष Name_NameTables	__1 _2..._N
	_	_

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

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

निष्कर्ष

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

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

इसलिए बहुत जल्द ही इस लेख की शैली में कई और लेख होंगे: "क्यों नहीं ...?", और मुझे यकीन है कि वे इन बहुत उबाऊ ट्यूटोरियल से अधिक दिलचस्प होंगे।

दूसरी प्रोग्रामिंग लैंग्वेज नहीं। भाग 3: भौतिकी