टेबल्स

नोट

Microsoft Power Fx कैनवास ऐप्स फॉर्मूला भाषा का नया नाम है। इन आलेखों का काम प्रगति पर है क्योंकि हम कैनवास ऐप से भाषा निकालते हैं, इसे अन्य Microsoft Power Platform उत्पाद के साथ एकीकृत करते हैं, और इसे खुले स्रोत के रूप में उपलब्ध कराते हैं। भाषा के परिचय के लिएMicrosoft Power Fx अवलोकन से शुरू करें।

Microsoft Power Fx में, आप एक सूत्र लिख सकते हैं जो Microsoft Excel, SharePoint, SQL सर्वर, और कई अन्य स्रोत जो रिकॉर्ड और तालिकाओं में डेटा संग्रहीत करते हैं, जानकारी को एक्सेस करता है. इस प्रकार के डेटा के साथ सबसे प्रभावी ढंग से कार्य करने के लिए, इन संरचनाओं में निहित अवधारणाओं की समीक्षा करें.

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

आप विभिन्न प्रकार के सूत्र बना सकते हैं, जो तालिका का नाम एक तर्क के रूप में लेते हैं, ठीक उसी तरह, जैसे Excel में सूत्र एक या अधिक कक्ष संदर्भों को तर्कों के रूप में लेता है. Power Fx में कुछ सूत्र एक तालिका देते हैं, जो आपके द्वारा निर्दिष्ट अन्य तर्कों को प्रतिबिंबित करता है. उदाहरण के लिए, आप एक सूत्र बना सकते थे:

• तालिका को Patch फ़ंक्शन के लिए एकाधिक तर्कों में किसी एक के रूप में निर्दिष्ट कर तालिका में एक रिकॉर्ड अद्यतन करने के लिए
• तालिका को AddColumns, DropColumns, या RenameColumns फ़ंक्शन के लिए एक तर्क के रूप में निर्दिष्ट करते हुए तालिका में स्तंभ जोड़ने, निकालने और नाम बदलने के लिए. उनमें को कोई भी फ़ंक्शन मूल तालिका को संशोधित नहीं करता. इसके बजाय, फ़ंक्शन आपके द्वारा निर्दिष्ट अन्य तर्कों के आधार पर एक अन्य तालिका देता है.

तालिका के तत्व

रिकॉर्ड

प्रत्येक रिकॉर्ड में किसी व्यक्ति, स्थान या चीज़ के बारे में जानकारियों की कम से कम एक श्रेणी होती है. उपरोक्त उदाहरण प्रत्येक उत्पाद (Chocolate, Bread, और Water) के लिए एक रिकॉर्ड और जानकारी की प्रत्येक श्रेणी (Price, Quantity on Hand, और Quantity on Order) के लिए एक स्तंभ दर्शाता है.

एक सूत्र में, आप रिकॉर्ड को स्वयं उसके द्वारा, तालिका के संदर्भ के बाहर, घुमावदार धनुकोष्ठक द्वारा संदर्भित कर सकते हैं. उदाहरण के लिए, यह रिकॉर्ड { Name: "Strawberries", Price: 7.99 } किसी तालिका से संबद्ध नहीं है. उस उदाहरण में फ़ील्ड नाम, जैसे Name और Price पर ध्यान दें, वे दोहरे उद्धरण चिह्नों में संलग्न नहीं हैं.

फ़ील्ड्‍स

फ़ील्ड, किसी रिकॉर्ड में जानकारी का एक व्यक्तिगत भाग है. आप किसी विशेष रिकॉर्ड के लिए स्तंभ में मान के रूप में इस प्रकार के फ़ील्ड की कल्पना कर सकते हैं.

नियंत्रण के समान ही, आप रिकॉर्ड पर .ऑपरेटर का उपयोग करके रिकॉर्ड के एक क्षेत्र को संदर्भित करते हैं. उदाहरण के लिए, First(Products).NameProducts तालिका में प्रथम रिकॉर्ड के लिए Name फ़ील्ड देता है.

फ़ील्ड में एक अन्य रिकॉर्ड या तालिका हो सकती है, जैसा कि GroupBy फ़ंक्शन के लिए उदाहरण दर्शाता है. आप रिकॉर्ड और तालिकाओं के मनचाहे स्तर नेस्ट कर सकते हैं.

स्तंभ

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

• नाम
• मूल्य
• Quantity on Hand
• Quantity on Order

स्तंभ का नाम उस स्तंभ के फ़ील्ड को प्रतिबिंबित करता है.

एक स्तंभ के भीतर सभी मान समान डेटा प्रकार के होते हैं. उपरोक्त उदाहरण में, "Quantity on Hand" स्तंभ में हमेशा एक संख्या होती है और स्ट्रिंग नहीं हो सकती है, जैसे एक रिकॉर्ड के लिए "12 इकाइयाँ". किसी फ़ील्ड का मान रिक्त भी हो सकता है.

आपने संभवतः अन्य उपकरणों में स्तंभ को "फ़ील्ड" के रूप में संदर्भित किया होगा.

तालिका

एक तालिका में एक या अधिक रिकॉर्ड होते हैं, प्रत्येक में एकाधिक फ़ील्ड होते हैं, जिसके पास सभी रिकॉर्ड पर नाम सतत रूप में होते हैं.

कोई भी तालिका, जो डेटा स्रोत या संग्रह में संग्रहीत होती है, का एक नाम होता है, जिसका उपयोग आप उस तालिका को संदर्भित करने और उस फ़ंक्शन पर पास करने के लिए करते हैं, जो तालिका को तर्कों के रूप में लेता है. तालिकाएँ किसी फ़ंक्शन या सूत्र का परिणाम भी हो सकती हैं.

जैसा कि निम्नलिखित उदाहरण में है, आप तालिका को रिकॉर्ड के एक सेट के साथ Table फ़ंक्शन के उपयोग द्वारा सूत्र में व्यक्त कर सकते हैं, जिसे आप घुमावदार धनुकोष्ठक में व्यक्त करते हैं:

Table( { Value: "Strawberry" }, { Value: "Vanilla" } )

आप वर्ग कोष्ठक द्वारा एकल-स्तंभ तालिका को भी परिभाषित कर सकते हैं. उपरोक्त लिखने का एक समतुल्य तरीका निम्न है:

[ "Strawberry", "Vanilla" ]

तालिका सूत्र

Excel और Power Fx के लिए, आप संख्याओं और पाठ के स्ट्रिंग में समान तरीकों से बदलाव करने के लिए सूत्रों का उपयोग करते हैं:

• Excel में, कक्ष A1 में एक मान, जैसे 42 टाइप करें, और फिर किसी अन्य कक्ष में एक सूत्र, जैसे A1+2 टाइप करें ताकि कक्ष का मान 44 दिखाया जा सकें.
• Power Apps में, Slider1 का डिफ़ॉल्ट गुण 42 पर सेट करें, और एक लेबल का पाठ गुण Slider1.Value + 2 पर सेट करें, ताकि मान 44 दिखाया जा सके.

यदि आप तर्कों के मान (उदाहरण के लिए, कक्ष A1 में संख्या या Slider1 का मान) बदलते हैं, तो दोनों स्थितियों में गणना मूल्य स्वचालित रूप से बदल जाता है.

इसी तरह, आप तालिकाओं और रिकॉर्ड में डेटा तक पहुँचने और बदलाव करने के लिए सूत्रों का उपयोग कर सकते हैं. आप कुछ सूत्रों में तर्कों के रूप में तालिकाओं के नामों का उपयोग कर सकते हैं, जैसे Catalog तालिका के Price स्तंभ में न्यूनतम मान दर्शाने के लिए Min(Catalog, Price). अन्य सूत्र वापसी मानों के रूप में पूरी तालिका प्रदान करते हैं, जैसे RenameColumns(Catalog, "Price", "Cost"), जो Catalog तालिका से सभी रिकॉर्ड देता है, परंतु Price स्तंभ का नाम परिवर्तित कर Cost करता है.

जैसा कि संख्याओं के साथ होता है, जिन सूत्रों में तालिकाएँ और रिकॉर्ड शामिल होते हैं, उनमें अंतर्निहित तालिका या रिकॉर्ड परिवर्तित होने के साथ स्वचालित रूप से पुनर्गणना की जाती है. यदि Catalog तालिका में उत्पाद की लागत पिछले न्यूनतम से कम की जाती है, तो Min सूत्र का वापसी मान इसके साथ मिलान करने के लिए स्वचालित रूप से परिवर्तित होगा.

तालिका फ़ंक्शन और नियंत्रण गुण

Lower फ़ंक्शन पर विचार करें. यदि चर स्वागत में पाठ स्ट्रिंग "Hello, World" शामिल है, तो सूत्र Lower( welcome )"hello, world" देता है. यह फ़ंक्शन किसी भी तरह से उस चर में मान नहीं बदलता. Lower एक शुद्ध फ़ंक्शन है, जिसमें यह केवल इनपुट को संसाधित करता है और आउटपुट का उत्पादन करता है. बस इतना ही; इसका कोई दुष्प्रभाव नहीं है. Excel में सभी फ़ंक्शन और Power Fx में अधिकांश फ़ंक्शन शुद्ध फ़ंक्शन हैं, जो कार्यपुस्तिका या ऐप को स्वचालित रूप से पुनर्गणना करने की अनुमति देते हैं.

Power Fx फ़ंक्शन का एक सेट प्रदान करता है, जो समान तरीके से तालिकाओं पर कार्य करता है. ये फ़ंक्शन तालिका को इनपुट के रूप में लेते हैं और डेटा की संपूर्ण तालिकाओं को फ़िल्टर, सॉर्ट, रूपांतरित, घटाते, और सारांशित करते हैं. वास्तव में, Lower और कई अन्य फ़ंक्शन, जो सामान्यतः एकल मान लेते हैं, वे इनपुट के रूप में एकल-स्तंभ तालिका भी ले सकते हैं.

कई फ़ंक्शन एकल-स्तंभ तालिका को उनके इनपुट के रूप में लेते हैं. यदि किसी संपूर्ण तालिका में केवल एक कॉलम है, तो आप उसे नाम से निर्दिष्ट कर सकते हैं. यदि किसी तालिका में एकाधिक स्तंभ हैं, तो आप उन स्तंभों से एक को Table.Column सिंटैक्स के उपयोग द्वारा निर्दिष्ट कर सकते हैं. उदाहरण के लिए, Products.NameProducts तालिका की केवल Name मान वाली एकल-स्तंभ तालिका देता है.

आप AddColumns, RenameColumns, ShowColumns या DropColumns फ़ंक्शन का उपयोग करके अपनी इच्छानुसार तालिका को नया आकार दे सकते हैं. पुनः, ये फ़ंक्शन केवल उनके आउटपुट को बदलते हैं, उनके स्रोत को नहीं.

व्यावहारिक सूत्र

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

रिकॉर्ड कार्यक्षेत्र

कुछ फ़ंक्शन तालिका के व्यक्तिगत रूप से सभी रिकॉर्ड पर सूत्र का मूल्यांकन करते हुए संचालित होते हैं. सूत्र के परिणाम का उपयोग विभिन्न तरीकों से किया जाता है:

• AddColumns - सूत्र जोड़े गए फ़ील्ड का मान प्रदान करता है.
• Average, Max, Min, Sum, StdevP, VarP - सूत्र सामूहिक का मान प्रदान करता है.
• Filter, Lookup - सूत्र निर्धारित करता है कि रिकॉर्ड को आउटपुट में शामिल होना चाहिए अथवा नहीं.
• Concat - सूत्र निर्धारित करता है कि स्ट्रिंग परस्पर श्रृंखलाबद्ध हो जाएँ.
• Distinct - सूत्र ऐसा मान देता है, जिसका उपयोग डुप्लिकेट रिकॉर्ड की पहचान करने के लिए किया जाता है.
• ForAll - सूत्र कोई भी मान, संभावित दुष्प्रभावों के साथ दे सकता है.
• Sort - सूत्र वह मान प्रदान करता है, जिस पर रिकॉर्ड सॉर्ट होते हैं.
• With - सूत्र कोई भी मान, संभावित दुष्प्रभावों के साथ दे सकता है.

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

उदाहरण के लिए, वैश्विक चर में रखे गए उत्पाद की तालिका को लें:

Set( Products,
    Table(
        { Product: "Widget",    'Quantity Requested': 6,  'Quantity Available': 3 },
        { Product: "Gadget",    'Quantity Requested': 10, 'Quantity Available': 20 },
        { Product: "Gizmo",     'Quantity Requested': 4,  'Quantity Available': 11 },
        { Product: "Apparatus", 'Quantity Requested': 7,  'Quantity Available': 6 }
    )
)

यह निर्धारित करने के लिए, कि इनमें से किसी भी उत्पाद का उसकी उपलब्धता से अधिक अनुरोध किया गया था अथवा नहीं:

Filter( Products, 'Quantity Requested' > 'Quantity Available' )

Filter का प्रथम तर्क वह तालिका है, जिसके रिकॉर्ड पर ऑपरेट किया जाना है, और द्वितीय तर्क एक सूत्र है. Filter इस सूत्र के मूल्यांकन के लिए एक रिकॉर्ड कार्यक्षेत्र बनाता है, जिसमें प्रत्येक रिकॉर्ड के फ़ील्ड उपलब्ध हैं, जो इस मामले में Product, Quantity Requested, और Quantity Available हैं. तुलना का परिणाम निर्धारित करता है कि फ़ंक्शन के परिणाम में प्रत्येक रिकॉर्ड को शामिल किया जाना चाहिए अथवा नहीं:

इस उदाहरण में जोड़कर, हम गणना कर सकते हैं कि प्रत्येक उत्पाद को कितना ऑर्डर करना है:

AddColumns( 
    Filter( Products, 'Quantity Requested' > 'Quantity Available' ), 
    "Quantity To Order", 'Quantity Requested' - 'Quantity Available'
)

यहाँ हम परिणाम पर एक परिकलित स्तंभ जोड़ रहे हैं. AddColumns का स्वयं का रिकॉर्ड कार्यक्षेत्र होता है, जिसका उपयोग अनुरोधित और उपलब्ध के बीच अंतर की गणना करने के लिए किया जाता है.

अंततः हम परिणाम तालिका को केवल उन स्तंभों तक घटा सकते हैं जो हम चाहते हैं:

ShowColumns(
    AddColumns(
        Filter( Products, 'Quantity Requested' > 'Quantity Available' ),
        "Quantity To Order", 'Quantity Requested' - 'Quantity Available'
    ),
    "Product",
    "Quantity To Order"
)

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

स्पष्टीकरण

रिकॉर्ड दायरे के साथ जोड़े गए फ़ील्ड नाम अनुप्रयोग में समान नामों को कहीं और से ओवरराइड करते हैं. जब ऐसा होता है, तो आप अभी भी रिकॉर्ड कार्यक्षेत्र से बाहर के मानों पर @ स्पष्टीकरण ऑपरेटर से पहुँच प्राप्त कर सकते हैं:

• नेस्टेड रिकॉर्ड दायरे से मूल्यों तक पहुंचने के लिए, इस पैटर्न का उपयोग करने पर संचालित किए जा रहे टेबल के नाम के साथ @ ऑपरेटर का उपयोग करें:
  तालिका[@FieldName]
• वैश्विक मान, जैसे डेटा स्रोत, संग्रह और संदर्भ चर तक पहुंचने के लिए, पैटर्न [@ObjectName] (बिना तालिका निर्दिष्ट किए) का उपयोग करें.

यदि तालिका को व्यंजक पर संचालित किया जाता है, जैसे फ़ि‍ल्टर(तालिका, ... ) तो स्पष्टीकरण ऑपरेटर का उपयोग नहीं किया जा सकता. केवल सबसे अंदरूनी रिकॉर्ड कार्यक्षेत्र इस तालिका व्यंजक के फ़ील्ड पर पहुँच सकता है, परंतु स्पष्टीकरण ऑपरेटर के उपयोग द्वारा नहीं पहुँच सकता.

उदाहरण के लिए, कल्पना करें कि एक संग्रह X है:

आप ClearCollect( X, [1, 2] ) के साथ इस संग्रह को बना सकते हैं.

और एक और संग्रह Y:

आप ClearCollect( Y, ["A", "B"] ) के साथ इस संग्रह को बना सकते हैं.

इसके अतिरिक्त, Value नामक चर को परिभाषित इस सूत्र द्वारा करें: UpdateContext( {Value: "!"} )

आइए, इसे एक साथ रखें. इस संदर्भ में, निम्न सूत्र:

Ungroup(
    ForAll( X,
        ForAll( Y,
            Y[@Value] & Text( X[@Value] ) & [@Value]
        )
    ),
    "Value"
)

इस तालिका का निर्माण करता है:

यहाँ क्या हो रहा है? सबसे बाहरी ForAll फ़ंक्शन X के लिए एक रिकॉर्ड कार्यक्षेत्र परिभाषित करता है, जैसे ही इसका संसाधन होता है, यह प्रत्येक रिकॉर्ड के मान फ़ील्ड पर पहुँच की अनुमति देता है. इस पर बस मान शब्द के उपयोग द्वारा, या X[@Value] के उपयोग द्वारा पहुँचा जा सकता है.

सबसे अंदरूनी ForAll फ़ंक्शन Y के लिए एक अन्य रिकॉर्ड कार्यक्षेत्र परिभाषित करता है. चूँकि इस तालिका में भी एक Value फ़ील्ड परिभाषित है, अतः यहाँ Value का उपयोग करने पर Y के रिकॉर्ड को संदर्भित किया जाता है, और अब X के रिकॉर्ड को संदर्भित नहीं किया जाता. यहाँ, X के Value फ़ील्ड पर पहुँचने के लिए, हमें स्पष्टीकरण ऑपरेटर के साथ लंबे संस्करण का उपयोग करना चाहिए.

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

Ungroup(
    ForAll( X,
        ForAll( Y,
            Value & Text( X[@Value] ) & [@Value]
        )
    ),
    "Value"
)

सभी ForAll रिकॉर्ड कार्यक्षेत्र, ग्लोबल कार्यक्षेत्र को ओवरराइड करते हैं. हमने जिस Value संदर्भ चर को परिभाषित किया है, बिना स्पष्टीकरण ऑपरेटर के नाम द्वारा उपलब्ध नहीं है. इस मान तक पहुँचने के लिए [@Value] का उपयोग करें.

Ungroup परिणाम को एक साथ रखता है, क्योंकि नेस्टेड ForAll फ़ंक्शन के परिणामस्वरूप एक नेस्टेड परिणाम तालिका मिलती है.

एकल-स्तंभ तालिकाएँ

तालिका से एकल स्तंभ पर संचालन करने के लिए, ShowColumns का उपयोग करें, जैसा इस उदाहरण में है:

ShowColumns( Products, "Product" )

यह सूत्र इस एकल-स्तंभ तालिका का निर्माण करता है:

एक छोटे विकल्प के लिए, Table.Column निर्दिष्ट करें, जो Table से केवल Column की तालिका निकालता है. उदाहरण के लिए, यह सूत्र वही परिणाम उत्पन्न करता है, जैसा ShowColumns के उपयोग से उत्पन्न होता है.

Products.Product

इनलाइन रिकॉर्ड

आप घुमावदार धनुकोष्ठक के उपयोग द्वारा रिकॉर्ड व्यक्त करते हैं, जिसमें नामयुक्त फ़ील्ड मान होते हैं. उदाहरण के लिए, आप इस विषय के प्रारंभ में तालिका में प्रथम रिकॉर्ड को इस सूत्र के उपयोग द्वारा व्यक्त कर सकते हैं:

{ Name: "Chocolate", Price: 3.95, 'Quantity on Hand': 12, 'Quantity on Order': 10 }

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

{ Name: First(Products).Name, Price: First(Products).Price * 1.095 }

आप नेस्टिंग घुमावदार धनुकोष्ठकों द्वारा रिकॉर्ड नेस्ट कर सकते हैं, जैसा कि इस उदाहरण में दर्शाया गया है:

{ 'Quantity': { 'OnHand': ThisItem.QuantOnHand, 'OnOrder': ThisItem.QuantOnOrder } }

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

ध्यान दें कि Price स्तंभ में मान में मुद्रा चिह्न, जैसे डॉलर चिह्न शामिल नहीं है. वह स्वरूपण मान प्रदर्शित होने पर लागू होगा.

इनलाइन तालिकाएँ

आप Table फ़ंक्शन और रिकॉर्ड के एक सेट के उपयोग द्वारा एक तालिका बना सकते हैं. आप इस विषय के प्रारंभ में तालिका को इस सूत्र के उपयोग द्वारा व्यक्त कर सकते हैं:

Table( 
	{ Name: "Chocolate", Price: 3.95, 'Quantity on Hand': 12, 'Quantity on Order': 10 },
	{ Name: "Bread", Price: 4.95, 'Quantity on Hand': 34, 'Quantity on Order': 0 },
	{ Name: "Water", Price: 4.95, 'Quantity on Hand': 10, 'Quantity on Order': 0 } 
)

आप तालिकाएँ नेस्ट भी कर सकते हैं:

Table( 
	{ Name: "Chocolate", 
	  'Quantity History': Table( { Quarter: "Q1", OnHand: 10, OnOrder: 10 },
	                             { Quarter: "Q2", OnHand: 18, OnOrder: 0 } ) 
	}
)

इनलाइन मान तालिकाएँ

आप वर्ग कोष्ठक में मान निर्दिष्ट करके एकल-स्तंभ तालिकाएँ बना सकते हैं. परिणामी तालिका में एकल स्तंभ है, जिसका नाम है Value है.

उदाहरण के लिए, [ 1, 2, 3, 4 ] और Table( { Value: 1 }, { Value: 2 }, { Value: 3 }, { Value: 4 } ) समतुल्य हैं, और यह तालिका देता है: