Geekly articles weekly

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



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

मैं तुरंत एक आरक्षण करूंगा, यह एक विचार, एक प्रोटोटाइप या यहां तक ​​कि एमवीपी के बारे में नहीं है, लेकिन सभी आवश्यक बुनियादी ढांचे की भाषा के साथ पूर्ण विकसित उत्पादन-तैयार भाषा के बारे में - विकास के माहौल से (डिबगर के साथ) भाषा के कई संस्करणों के स्वत: समर्थन के लिए (स्वचालित मर्ज के साथ उपसर्ग) , रिलीज-नोट, आदि)। इसके अलावा, इस भाषा का उपयोग करते हुए, ERP स्तर की जटिलता की कई दर्जन परियोजनाएं पहले ही कार्यान्वित की जा चुकी हैं, जिसमें सैकड़ों युगपत उपयोगकर्ता, टेराबाइट डेटाबेस, "कल की समय सीमा", सीमित बजट और आईटी में बिना अनुभव के डेवलपर्स शामिल हैं। और यह सब एक ही समय में। ठीक है, निश्चित रूप से, यह ध्यान दिया जाना चाहिए कि अब वर्ष 2000 नहीं है, और इन सभी परियोजनाओं को मौजूदा प्रणालियों (जो वहां नहीं था) के शीर्ष पर लागू किया गया था, जिसका अर्थ है कि सबसे पहले यह आवश्यक था "धीरे-धीरे" के रूप में, व्यवसाय को रोकने के बिना, और फिर। भी धीरे-धीरे, जैसा होना चाहिए वैसा ही करें। सामान्य तौर पर, यह पहला इलेक्ट्रिक कार है जो कैलिफ़ोर्निया के धनी हिपस्टर्स को नहीं, बल्कि ओम्स्क में कहीं कम लागत वाली टैक्सी सेवाओं को बेचने के लिए है।

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

सिद्धांत की बिट


आइए इस और अन्य आधुनिक भाषाओं में उपयोग किए जाने वाले मूलभूत दृष्टिकोणों में अंतर को उजागर करने के लिए सिद्धांत से शुरू करें।

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

प्रोग्रामिंग द्वारा हल किए गए पहले और मुख्य कार्यों में से एक कार्यों के मूल्यों की गणना की समस्या है। कम्प्यूटेशनल सिद्धांत के दृष्टिकोण से, इस समस्या को हल करने के लिए मौलिक रूप से दो अलग-अलग दृष्टिकोण हैं।

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

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

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

एक दृष्टिकोण के रूप में सीआरएफ के तीन मुख्य लाभ हैं:

  • यह बहुत बेहतर अनुकूलित है। यह मूल्य की गणना करने की प्रक्रिया के अनुकूलन और इस तरह की गणना की समानता की संभावना पर सीधे लागू होता है। पहले दृष्टिकोण में, बाद में, इसके विपरीत, इन प्रक्रियाओं में एक बहुत बड़ी जटिलता का परिचय देता है।
  • यह बेहतर रूप से बढ़ा हुआ है, अर्थात, एक निर्मित कार्य के लिए, यह निर्धारित करने के लिए बहुत अधिक कुशल हो सकता है कि जब इसके निर्मित फ़ंक्शन उपयोग करता है, तो इसके मूल्यों में परिवर्तन कैसे होगा। कड़ाई से बोलते हुए, यह लाभ पहले का एक विशेष मामला है, लेकिन यह ठीक है कि यह बहुत बड़ी संभावनाएं देता है, जो मूल रूप से पहले दृष्टिकोण में नहीं हो सकता है, इसलिए इसे एक अलग आइटम के रूप में हाइलाइट किया गया है।
  • इसे समझना बहुत आसान है। यही है, मोटे तौर पर बोल, दो अन्य संकेतकों के संदर्भ में एक संकेतक के योग की गणना के कार्य का वर्णन समझने में बहुत आसान है, यदि पहले दृष्टिकोण के संदर्भ में उसी का वर्णन किया गया हो। हालाँकि, एल्गोरिदमिक रूप से जटिल समस्याओं में स्थिति विषम रूप से विपरीत होती है, लेकिन यह ध्यान देने योग्य है कि क्षेत्रों के विशाल बहुमत में एल्गोरिदमिक रूप से जटिल समस्याएं 5% हैं। सामान्य तौर पर, संक्षेप में, सीआरएफ गणित है, और ट्यूरिंग मशीनें कंप्यूटर विज्ञान हैं। तदनुसार, गणित का अध्ययन लगभग किंडरगार्टन में किया जाता है, और कंप्यूटर विज्ञान वैकल्पिक और हाई स्कूल से होता है। तुलनात्मक रूप से तो, लेकिन फिर भी इस मामले में किसी न किसी प्रकार की मीट्रिक देता है।

ट्यूरिंग मशीनों के कम से कम दो फायदे हैं:

  • एल्गोरिदमिक रूप से जटिल समस्याओं में पहले से ही सर्वोत्तम प्रयोज्यता का उल्लेख किया गया है
  • सभी आधुनिक कंप्यूटर इस दृष्टिकोण पर बनाए गए हैं।

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

इस जगह पर पढ़ने के बाद, कोई भी चौकस पाठक एक उचित सवाल पूछेगा: "अगर सीआरएफ दृष्टिकोण इतना अच्छा है, तो इसका उपयोग किसी भी सामान्य आधुनिक भाषा में क्यों नहीं किया जाता है?" तो, वास्तव में, ऐसा नहीं है, इसका उपयोग, इसके अलावा, उस भाषा में किया जाता है जिसका उपयोग मौजूदा सूचना प्रणालियों के विशाल बहुमत में किया जाता है। जैसा कि आप अनुमान लगा सकते हैं, यह भाषा एसक्यूएल है। यहाँ, ज़ाहिर है, एक ही चौकस पाठक यथोचित रूप से आपत्ति करेगा कि एसक्यूएल संबंधपरक बीजगणित की भाषा है (अर्थात, तालिकाओं के साथ काम करना, कार्य नहीं करना), और यह सही होगा। औपचारिक रूप से। वास्तव में, हम याद कर सकते हैं कि डीबीएमएस में टेबल आमतौर पर तीसरे सामान्य रूप में होते हैं, अर्थात्, उनके पास प्रमुख कॉलम होते हैं, जिसका अर्थ है कि इस तालिका के किसी भी शेष स्तंभ को इसके प्रमुख स्तंभों के कार्य के रूप में माना जा सकता है। स्पष्ट नहीं, स्पष्ट रूप से। और SQL एक रिलेशनल बीजगणित भाषा से पूर्ण प्रोग्रामिंग भाषा में क्यों नहीं बढ़ा है (जो कि कार्यों के साथ काम कर रहा है) एक बड़ा सवाल है। मेरी राय में, इसके कई कारण हैं, जिनमें से सबसे महत्वपूर्ण है "एक रूसी (वास्तव में कोई भी) व्यक्ति खाली पेट काम नहीं कर सकता है, लेकिन एक अच्छी तरह से खिलाया हुआ काम नहीं करना चाहता है," इस अर्थ में, जैसा कि अभ्यास से पता चलता है, इसके लिए आवश्यक कार्य यह वास्तव में टाइटैनिक है और छोटी कंपनियों के लिए बहुत अधिक जोखिम रखता है, और बड़ी कंपनियों के लिए, सबसे पहले, सब कुछ ठीक है, और दूसरी बात, इस काम को पैसे के साथ मजबूर करना असंभव है - गुणवत्ता यहां महत्वपूर्ण है, मात्रा नहीं। वास्तव में, जब गुणवत्ता के बजाय लोग मात्रा द्वारा किसी समस्या को हल करने का प्रयास करते हैं, तो सबसे ज्वलंत उदाहरण ओरेकल है, जो यहां तक ​​कि वृद्धिशीलता के सबसे बुनियादी आवेदन को भी लागू करने में कामयाब रहा - अपडेट किए गए भौतिक निरूपण ताकि इस तंत्र में कई पृष्ठों (न्याय) के कई प्रतिबंध हैं इसके लिए, Microsoft अभी भी बदतर है )। हालाँकि, यह एक अलग कहानी है, शायद इसके बारे में एक अलग लेख होगा।

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

लेकिन पर्याप्त सिद्धांत, यह सीधे भाषा में जाने का समय है।

तो, हम मिलते हैं :


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

आलेखीय रूप से, lsFusion में डोमेन लॉजिक की सभी अवधारणाओं को निम्न चित्र द्वारा दर्शाया जा सकता है:


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

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

गुण


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

संपत्तियों को परिचालकों के पूर्वनिर्धारित सेट का उपयोग करके पुन: सेट किया जाता है। इनमें से बहुत सारे ऑपरेटर हैं, इसलिए, हम केवल मुख्य को मानते हैं (ये ऑपरेटर किसी भी औसत-स्थैतिक परियोजना के 95% को कवर करते हैं)।

प्राथमिक संपत्ति (डेटा)


प्राथमिक संपत्ति एक संपत्ति है जिसका मूल्य डेटाबेस में संग्रहीत किया जाता है और इसे संबंधित कार्रवाई के परिणामस्वरूप बदला जा सकता है (इसके बारे में थोड़ी देर बाद)। डिफ़ॉल्ट रूप से, मापदंडों के किसी भी सेट के लिए ऐसी प्रत्येक संपत्ति का मूल्य एक विशेष NULL मान के बराबर है।
quantity = DATA INTEGER (Item);
isDayOff = DATA BOOLEAN (Country, DATE);
, ( ), .

. :

class X { 	
    Y y; 	
    Map<Y, Z> f; 	
    Map<Y, Map<M, Z>> m; 	
    List<Y> n;
    LinkedHashSet<Y> l; //   
    static Set<Y> s;
}

:
y = DATA Y (X);
f = DATA Z (X, Y);
m = DATA Z (X, Y, M);
n = DATA Y (X,INTEGER);
l = DATA INTEGER (X,Y);
s = DATA BOOLEAN (Y);

(JOIN), , (+,-,/,*), (AND, OR), (+, CONCAT), (>,<,=), (CASE, IF), (IS)

f(a) = IF g(h(a)) > 5 AND a IS X THEN ‘AB’ + ‘CD’ ELSE x(5);
- , . , , , :

  • , . , ( NULL). , lsFusion – , , , – TRUE ( FALSE NULL), 3-state’.
  • NULL: (+), (-), CONCAT . :
    • : NULL 0, – , 0 NULL ( 5 (+) NULL = 5, 5 (-) 5 = NULL, 5 + NULL = NULL 5 — 5 = 0).
    • : NULL ( CONCAT ‘ ‘, ‘John’,’Smith’ = ‘John Smith’, CONCAT ‘ ‘, ‘John’, NULL = ‘John’, ‘John’ + ‘ ‘ + NULL = NULL).
  • (IF) ( ) : f(a) IF g(a), f(a) g(a) NULL, NULL – .

(GROUP)


– . (, ) .

:

  • :
    sum(Invoice i) = GROUP SUM sum(InvoiceDetail id) IF invoice(id) = i;
    currentBalance(Sku sk) = GROUP SUM currentBalance(sk, Stock st);
    , ( i sk). , , - :
    x() = (GROUP SUM f(a)) + 5;
  • SQL-:
    sum = GROUP SUM sum(InvoiceDetail id) BY invoice(id);
    currentBalance = GROUP SUM currentBalance(Sku sk, Stock st) BY sk;
    ( , , )

, ( ), – ( ). , , , ( , , SQL – ). , ( BY), - :
// BY     ,   s
sum(DATE from, Stock s, DATE to) = GROUP sum(Invoice i) IF date(i) >= from AND date(i) <=to BY stock(i); 
, , , , , .

:

  • /,

  • .

/ (PARTITION … ORDER)


( , ) , . , ( , ). / .
place(Team t) = PARTITION SUM 1 ORDER DESC points(t) BY conference(t);
, , , , , , .

SQL ( , ) (OVER PARTITION BY… ORDER BY).

(RECURSION)


– , . , , .

. , ( ):

  • (result) ( ) :
    • result(0, o1, o2, ..., oN) = initial(o1, ..., oN), initial –
    • result(i+1, o1, o2, ..., oN) = step(o1, ..., oN, $o1, $o2, ..., $oN) IF result(i, $o1, $o2, ..., $oN), step – .
  • , ( o1, o2, …, oN). , .

, , , , :
//   integer  from  to (       System)
iterate(i, from, to) = RECURSION i=from STEP i=$i+1 AND i<=to CYCLES IMPOSSIBLE;
 
//      a  b   ( ,  ,  )
edge = DATA BOOLEAN (Node, Node);
pathes '- ' (a, b) = RECURSION 1 IF b=a STEP 1 IF edge(b, $b);
 
// ,     child  parent,  null,     (         child')
parent  = DATA Group (Group);
level '' (Group child, Group parent) = RECURSION 1 AND child IS Group AND parent = child STEP 1 IF parent = parent($parent);
 
//  ,        to, (   NULL)
fib(i, to) = RECURSION 1 IF (i=0 OR i=1) STEP 1 IF (i=$i+1 OR i=$i+2) AND i<to CYCLES IMPOSSIBLE;
, / , , , .

, , , , , lsFusion – .

SQL CTE, , , . , Postgres GROUP BY , , , , , , . , , WHILE’ .

. , , .


– , , , , ( , , ). , , “”, , -, , , -, , “”.

, – lsFusion. , – . , – ( , , , ). , – . .

, . / , , , , , . 3 97, lsFusion – 60 40.

, , . , -, ( , ), .

, :

(FOR), (WHILE)


, lsFusion , , NULL ( ).
FOR selected(Team team) DO
    MESSAGE 'Team ' + name(team) + ' was selected';
, :
showAllDetails(Invoice i) {
    FOR invoice(InvoiceDetail id) = i ORDER index(id) DO
        MESSAGE 'Sku : ' + nameSku(id) + ', ' + quantity(id);
}
, , (IF).

(WHILE) , :

  • , NULL ( )


(EXEC), ({…}), (CASE, IF), (BREAK), (RETURN)

f(a) {
    FOR t=x(b,a) DO {
        do(b);
        IF t>5 THEN
            BREAK;
    }
    MESSAGE 'Succeeded';
}
- . , , .

(CHANGE)


. , , , , NULL. :
//       
setDiscount(Customer c)  {
    discount(c, Item i) <- 15 WHERE selected(i);
}
, :
setDiscount(Customer c)  {
    FOR selected(Item i) DO
        discount(c, i) <- 15;
}
, , , ( , , , , selected discount – ), . , , .

(NEW)


( , , , , ). , , .

:
newSku ()  {
    LOCAL addedSkus = Sku (INTEGER);
    NEW Sku WHERE iterate(i, 1, 3) TO addedSkus(i);
    FOR Sku s = addedSkus(i) DO {
        id(s) <- 425;
        name(s) <- 'New Sku : ' + i;
    }
}
, , — NEW (FOR), ( ):
FOR iterate(i, 1, 3) NEW s=Sku DO  {
    id(s) <- i;
    name(s) <- 'New Sku : ' + i;
}
, FOR :
NEW s=Sku DO {
    id(s) <- 425;
    name(s) <- 'New Sku';
}
– , , , .

(DELETE)


– :
DELETE Sku s WHERE name(s) = 'MySku';
, «» .

, , .


, , . , , . .

, . , — / .

, , . , ( ), .

, , . , :
LOCAL f = INTEGER (INTEGER, INTEGER);

f(1,3) <- 6;
f(2,2) <- 4;
f(f(1,3),4) <- 5;
f(a,a) <- NULL; //      1-  2-  (  2,2)

MESSAGE GROUP CONCAT a + ',' + b + '->' + f(a, b),' ; '; //  1,3->6 ; 6,4->5
: (APPLY) (CANCEL). , , , . , , , . – , , , , . — .

(NEWSESSION, NESTEDSESSION)


(, , http- ..). , , . , , , «», «» ( , ). NEWSESSION, ( ). :
run() {
    f(1) <- 2;
    APPLY;
    f(1) <- 1;
    NEWSESSION {
        MESSAGE f(1); //  2,       
        f(2) <- 5;
        APPLY;          
    }
    MESSAGE f(1); //  1,     1  ,   
}
, , , . , :
run(Store s) {
    NEWSESSION
        MESSAGE 'I see that param, its name is: ' + name(s);
}
, , ( ). NESTED, , , , . , ( , NESTED). :
g = DATA LOCAL NESTED INTEGER ();
run() {
    f(1) <- 1; g() <- 5;
    NEWSESSION NESTED (f) {
        MESSAGE f(1) + ' ' + g(); //  1 5
        f(1) <- 5; g() <- 7;
    }
    MESSAGE f(1) + ' ' + g(); //  5 7
}
. :

  • , , , < —
  • , , : < —
  • , : < — .

, (, ), , . , , - , , , , , :


  • ,

(APPLY), (CANCEL)


– , . , . , :

  • . , , , NESTED ( ).
  • , . , - , , , . , (update conflict), , , . , :

// -------------------------- Object locks ---------------------------- //
 
locked = DATA User (Object);
lockResult = DATA LOCAL NESTED BOOLEAN ();
 
lock(Object object)  {
    NEWSESSION { 
        lockResult() < - NULL;
        APPLY SERIALIZABLE {
            IF locked(object) THEN {
                CANCEL;
            } ELSE {
                locked(object) <- currentUser();
                lockResult() <- TRUE;
            }
        }
    }
}
 
unlock(Object object)  {
    NEWSESSION
        APPLY locked(object) <- NULL;
}
PS: Authentication, , , ( ) ( ). , , lsFusion , (, ).

– , , , , ( ).

(PREV, CHANGED, SET, DROPPED)


: (PREV), (CHANGED), NULL NULL (SET) .. ( ), , , :
f = DATA INTEGER (INTEGER);
run() {
    f(1) <- 2;
    APPLY;
 
    f(1) <- 5;
    f(2) <- 3;
    MESSAGE GROUP SUM 1 IF CHANGED(f(a)); // ,    f     ,  2
    MESSAGE '. : ' + f(1) + ', . : ' + PREV(f(1)); //  . : 5, . : 2
}
. , , , , .


“ ?”, “ ?”. , , .

, , . , . .

:

  • – .
  • – , / .

, , :

  • – .
  • – .

, , , .

:

  • , , , .
  • , .

:

  • , « ». , , , ( , , 5-10 , ).
  • , ( ), , , , .

:

  • , , .

:

  • , , ( ), , .

( , ), .
ON { //   ,       APPLY
    MESSAGE 'Something changed';
}
, , , , ‘Something changed’ (!) ( , ). , , - , (CHANGED, SET, DROPPED ..). , - , -, -. – :
//  email,          
WHEN SET(balance(Sku s, Stock st) < 0) DO
      EMAIL SUBJECT '     ' + name(s) + '   ' + name(st);

WHEN LOCAL CHANGED(customer(Order o)) AND name(customer(o)) == 'Best customer' DO
    discount(OrderDetail d) <- 50 WHERE order(d) = o;

, – , . , :
ON {
    FOR SET(balance(Sku s, Stock st) < 0) DO
        EMAIL SUBJECT '     ' + name(s) + '   ' + name(st);
}
, , / , , .

SQL ( ) . , , , ( ) , .

, :

  • – , ( )
  • – , . , , «» .


, , . , , NULL:
//    0
CONSTRAINT balance(Sku s, Stock st) < 0 
    MESSAGE '    ';

// ""  
CONSTRAINT DROPCHANGED(barcode(Sku s)) AND name(currentUser()) != 'admin' 
    MESSAGE ' -       ';

//      ,   
CONSTRAINT sku(OrderDetail d) AND NOT in(sku(d), customer(order(d)))
    MESSAGE '        ';
, – , NULL (SET) , – NULL . – , , , / , .

, – ( ), , , ( ), , .


. , , , – . , :
f = DATA A (INTEGER);
, f NULL , A. :
f = Object (INTEGER);
CONSTRAINT f(i) AND NOT f(i) IS A MESSAGE ' '; // f(i) => f(i) IS A
, , – . ( , , «»), , , , : - , .

, lsFusion . , lsFusion . , . lsFusion , , - :
CLASS A {
    f = DATA LONG (INTEGER); //  f = DATA LONG (A, INTEGER)
}
lsFusion , :
CLASS Animal;
CLASS Transport;
CLASS Car : Transport;
CLASS Horse : Transport, Animal;
, – .


lsFusion – . , , :
speed = ABSTRACT LONG (Transport);
/ , :
CLASS Breed;
speed = DATA LONG (Breed)
breed = DATA Breed (Animal);

speed(Horse h) += speed(breed(h)); //       
( ):
CLASS Thing;
CLASS Ship : Thing;
CLASS Asteroid : Thing;

collide ABSTRACT (Thing, Thing);
collide(Ship s1, Ship s2) +{
    MESSAGE 'Ship : ' + name(s1) + ', Ship : ' + name(s2);
}
collide(Ship s1, Asteroid a2) +{
    MESSAGE 'Ship : ' + name(s1) + ', Asteroid : ' + name(a2);
}
collide(Asteroid a1, Ship s2) +{
    MESSAGE 'Asteroid : ' + name(a1) + ', Ship : ' + name(s2);
}
collide(Asteroid a1, Asteroid a2) +{
    MESSAGE 'Asteroid : ' + name(a1) + ', Asteroid : ' + name(a2);
}
, , ( ), . ABSTRACT :
speed(Transport t) = CASE 
    WHEN t IS Horse THEN speed(breed(t))
    //  
END
, .

, , :
speed(Horse h) = speed(breed(h));
, , ( ). , , .


, , . () : , , . , , , , , . NULL , , :
f = DATA LONG (LONG);
g = DATA LONG (A);
h(a) = OVERRIDE f(a), g(a); //   


( ) – , . , , , :
CLASS Direction '' {
    left '',
    right '',
    forward ''
}

result(dir) = CASE
    WHEN dir = Direction.left THEN ' '
    WHEN dir = Direction.right THEN ' '
    WHEN dir = Direction.forward THEN ' '
END
, .

enum’, , .


( lsFusion, ) :

  • ( ).
  • ( ).
  • .

.

() , NULL . , , , , , .

:
//   A    B
b(A a) = AGGR B WHERE a IS A; 
//     a     B    A,   b(a(b)) = b

createC = DATA BOOLEAN (A, B)
//    A  B    createC    C
//     ,       ,      
c = AGGR C WHERE createC(A a, B b); 
//     a  b     C      B 
, , ( ):
CLASS Shipment '';
date = ABSTRACT DATE (Shipment);
CLASS Invoice '';
createShipment ' ' = DATA BOOLEAN (Invoice);
date ' ' = DATA DATE (Invoice);
CLASS ShipmentInvoice '  ' : Shipment;
//    ,       
shipment(Invoice invoice) = AGGR ShipmentInvoce WHERE createShipment(invoice);
date(ShipmentInvoice si) += sum(date(invoice(si)),1); //   =   + 1
, (, ), ( ) , . , ERP 1100 . , , , . , ( 50 ), , 1100 300 .

, , , , . , , – , – , , , « - », , , .


, lsFusion . , , , , , , , , , ( , , ). , lsFusion ( ACID), , SQL-, . , DSL lsFusion , , – – . , SQL , , lsFusion . , , – , github ( , ), (IDE, , VCS, ), slack telegram- , (linux maven, - ), , , , , lsFusion , SQL, ABAP 1 – .

, , lsFusion, , ( ), : ERP-, SQL- , ORM-, RAD-, . , , .

, :

  • SQL- – - – , , .
  • ERP- – - – , , ..
  • ORM- – - (, ), .
  • RAD – - , , , IT-.
  • – , RAD, , - , , Excel (, , , – ).

, lsFusion ERP, RAD SQL , lsFusion ( ). , SQL, , , , , , Fortran C ( , ). ORM- , – . , , - .

SME ( , ), ( ). , 1 , .

, , , , , ( 12 ), .

UPD: .

Source: https://habr.com/ru/post/hi458376/

More articles:


All Articles