Waarden

Een waarde is gegevens die worden geproduceerd door een expressie te evalueren. In deze sectie worden de soorten waarden in de M-taal beschreven. Elk type waarde wordt gekoppeld aan een letterlijke syntaxis, een set waarden die van dat type zijn, een set operators die zijn gedefinieerd voor die set waarden en een intrinsiek type dat is toegewezen aan nieuw samengestelde waarden.

Soort	Literal
Null	null
Logische	true    false
Nummer	0    1    -1    1.5    2.3e-5
Tijd	#time(09,15,00)
Datum	#date(2013,02,26)
Datetime	#datetime(2013,02,26, 09,15,00)
DateTimeZone	#datetimezone(2013,02,26, 09,15,00, 09,00)
Duur	#duration(0,1,30,0)
Text	"hello"
Binaire	#binary("AQID")
Lijst	{1, 2, 3}
Record	[ A = 1, B = 2 ]
Tabel	#table({"X","Y"},{{0,1},{1,0}})
Functie	(x) => x + 1
Type	type { number }    type table [ A = any, B = text ]

In de volgende secties wordt elk waardetype gedetailleerd beschreven. Typen en type-ascriptie worden formeel gedefinieerd in Typen. Functiewaarden worden gedefinieerd in Functions. De volgende secties bevatten de operators die zijn gedefinieerd voor elk waardetype en geven voorbeelden. De volledige definitie van operatorsemantiek volgt in Operators.

Nul

Een null-waarde wordt gebruikt om de afwezigheid van een waarde of een waarde met onbepaalde of onbekende status aan te geven. Een null-waarde wordt geschreven met behulp van de letterlijke waarde null. De volgende operators zijn gedefinieerd voor null-waarden:

Operator	Result
x > y	Groter dan
x >= y	Groter dan of gelijk aan
x < y	Kleiner dan
x <= y	Kleiner dan of gelijk aan
x = y	Equal
x <> y	Not equal
x ?? y	Coalesce

Het systeemeigen type van de null waarde is het intrinsieke type null.

Logisch

Een logische waarde wordt gebruikt voor Booleaanse bewerkingen met de waarde waar of onwaar. Een logische waarde wordt geschreven met behulp van de letterlijke waarden true en false. De volgende operators zijn gedefinieerd voor logische waarden:

Operator	Result
x > y	Groter dan
x >= y	Groter dan of gelijk aan
x < y	Kleiner dan
x <= y	Kleiner dan of gelijk aan
x = y	Equal
x <> y	Not equal
x or y	Voorwaardelijk logisch OF
x ?? y	Coalesce
x and y	Voorwaardelijke logische AND
not x	Logische NOT

Het systeemeigen type van zowel logische waarden (true als false) is het intrinsieke type logical.

Aantal

Een getalwaarde wordt gebruikt voor numerieke en rekenkundige bewerkingen. Hier volgen enkele voorbeelden van letterlijke getallen:

3.14  // Fractional number 
-1.5  // Fractional number 
1.0e3 // Fractional number with exponent
123   // Whole number 
1e3   // Whole number with exponent 
0xff  // Whole number in hex (255)

Een getal wordt weergegeven met ten minste de precisie van een double (maar kan meer precisie behouden). De dubbele weergave is congruent met de IEEE 64-bits dubbele precisiestandaard voor binaire drijvende kommaberekeningen die zijn gedefinieerd in [IEEE 754-2008]. (De Dubbele weergave heeft een dynamisch bereik van 5,0 x 10³²⁴ tot 1,7 x 10³⁰⁸ met een precisie van 15-16 cijfers.)

De volgende speciale waarden worden ook beschouwd als getalwaarden :

• Positieve nul en negatieve nul. In de meeste gevallen gedragen positieve nul en negatief nul zich identiek als de eenvoudige waarde nul, maar bepaalde bewerkingen maken onderscheid tussen de twee.

• Positieve oneindigheid (#infinity) en negatieve oneindigheid (-#infinity). Infinities worden geproduceerd door bewerkingen zoals het delen van een niet-nulgetal door nul. Levert bijvoorbeeld 1.0 / 0.0 positieve oneindigheid op en -1.0 / 0.0 geeft negatieve oneindigheid als resultaat.

• De waarde Not-a-Number (#nan), vaak afgekort NaN. NaN's worden geproduceerd door ongeldige drijvendekommabewerkingen, zoals nul delen door nul.

Binaire wiskundige bewerkingen worden uitgevoerd met behulp van een precisie. De precisie bepaalt het domein waarop de operanden worden afgerond en het domein waarin de bewerking wordt uitgevoerd. Als er geen expliciet opgegeven precisie is, worden dergelijke bewerkingen uitgevoerd met dubbele precisie.

• Als het resultaat van een wiskundige bewerking te klein is voor de doelindeling, wordt het resultaat van de bewerking positief nul of negatief nul.

• Als het resultaat van een wiskundige bewerking te groot is voor de doelindeling, wordt het resultaat van de bewerking positief oneindig of negatief oneindig.

• Als een wiskundige bewerking ongeldig is, wordt het resultaat van de bewerking NaN.

• Als een of beide operanden van een drijvendekommabewerking NaN zijn, wordt het resultaat van de bewerking NaN.

De volgende operators zijn gedefinieerd voor getalwaarden:

Operator	Result
x > y	Groter dan
x >= y	Groter dan of gelijk aan
x < y	Kleiner dan
x <= y	Kleiner dan of gelijk aan
x = y	Equal
x <> y	Not equal
x + y	Sum
x - y	Verschil
x * y	Product
x / y	Quotiënt
x ?? y	Coalesce
+x	Unary plus
-x	Ontkenning

Het systeemeigen type getalwaarden is het intrinsieke type number.

Tijd

Een tijdwaarde slaat een ondoorzichtige weergave van het tijdstip van de dag op. Een tijd wordt gecodeerd als het aantal tikken sinds middernacht, waarmee het aantal tikken van 100 nanoseconden wordt geteld die zijn verstreken op een 24-uursklok. Het maximum aantal tikken sinds middernacht komt overeen met 23:59:59.999999999 uur.

Hoewel er geen letterlijke syntaxis is voor tijden, worden er verschillende standaardbibliotheekfuncties geboden om ze samen te stellen. Tijden kunnen ook worden samengesteld met behulp van de intrinsieke functie #time:

#time(hour, minute, second)

Het volgende moet worden opgeslagen of er wordt een fout met redencode Expression.Error gegenereerd:

0 ≤ uur ≤ 24
0 ≤ minuut ≤ 59
0 ≤ tweede ≤ 59

Bovendien, als uur = 24, moet minuut en seconde nul zijn.

De volgende operators zijn gedefinieerd voor tijdwaarden:

Operator	Result
x = y	Equal
x <> y	Not equal
x >= y	Groter dan of gelijk aan
x > y	Groter dan
x < y	Kleiner dan
x <= y	Kleiner dan of gelijk aan
x ?? y	Coalesce

Met de volgende operators kunnen een of beide operanden een datum zijn:

Operator	Linkeroperand	Rechteroperand	Betekenis
x + y	time	duration	Datumverschil per duur
x + y	duration	time	Datumverschil per duur
x - y	time	duration	Datumverschil per ontkende duur
x - y	time	time	Duur tussen datums
x & y	date	time	Samengevoegde datum/tijd

Het systeemeigen type tijdwaarden is het intrinsieke type time.

Datum

Een datumwaarde slaat een ondoorzichtige weergave van een specifieke dag op. Een datum wordt gecodeerd als een aantal dagen sinds het tijdvak, beginnend vanaf 1 januari 0001 gemeenschappelijk tijdperk op de Gregoriaanse kalender. Het maximum aantal dagen sinds de periode is 3652058, dat overeenkomt met 31 december 9999.

Hoewel er geen letterlijke syntaxis voor datums is, worden er verschillende standaardbibliotheekfuncties geboden om ze samen te stellen. Datums kunnen ook worden samengesteld met behulp van de intrinsieke functie #date:

#date(year, month, day)

Het volgende moet worden opgeslagen of er wordt een fout met redencode Expression.Error gegenereerd:

1 ≤ jaar ≤ 9999
1 ≤ maand ≤ 12
1 ≤ dag ≤ 31

Bovendien moet de dag geldig zijn voor de gekozen maand en het jaar.

De volgende operators zijn gedefinieerd voor datumwaarden:

Operator	Result
x = y	Equal
x <> y	Not equal
x >= y	Groter dan of gelijk aan
x > y	Groter dan
x < y	Kleiner dan
x <= y	Kleiner dan of gelijk aan
x ?? y	Coalesce

Met de volgende operators kunnen een of beide operanden een datum zijn:

Operator	Linkeroperand	Rechteroperand	Betekenis
x + y	date	duration	Datumverschil per duur
x + y	duration	date	Datumverschil per duur
x - y	date	duration	Datumverschil per ontkende duur
x - y	date	date	Duur tussen datums
x & y	date	time	Samengevoegde datum/tijd

Het systeemeigen type datumwaarden is het intrinsieke type date.

Datum/tijd

Een datum/tijd-waarde bevat zowel een datum als een tijd.

Hoewel er geen letterlijke syntaxis is voor datum/tijd, worden er verschillende standaardbibliotheekfuncties geboden om ze samen te stellen. Datum/tijd kan ook worden samengesteld met behulp van de intrinsieke functie #datetime:

#datetime(year, month, day, hour, minute, second)

Het volgende moet een fout met de redencode Expression.Error bevatten: 1 ≤ jaar ≤ 9999
1 ≤ maand ≤ 12
1 ≤ dag ≤ 31
0 ≤ uur ≤ 23
0 ≤ minuut ≤ 59
0 ≤ tweede ≤ 59

Bovendien moet de dag geldig zijn voor de gekozen maand en het jaar.

De volgende operators zijn gedefinieerd voor datum/tijd-waarden:

Operator	Result
x = y	Equal
x <> y	Not equal
x >= y	Groter dan of gelijk aan
x > y	Groter dan
x < y	Kleiner dan
x <= y	Kleiner dan of gelijk aan
x ?? y	Coalesce

Met de volgende operators kunnen een of beide operanden een datum/tijd zijn:

Operator	Linkeroperand	Rechteroperand	Betekenis
x + y	datetime	duration	Datum/tijd-verschuiving op duur
x + y	duration	datetime	Datum/tijd-verschuiving op duur
x - y	datetime	duration	Datum/tijd-verschuiving op negatieve duur
x - y	datetime	datetime	Duur tussen datum/tijd

Het systeemeigen type datum/tijd-waarden is het intrinsieke type datetime.

DateTimeZone

Een datum/tijdzone-waarde bevat een datum/tijd en een tijdzone. Een tijdzone wordt gecodeerd als een aantal minuten offset van UTC, waarmee het aantal minuten wordt geteld dat het tijdgedeelte van de datum/tijd moet worden verschoven van Universal Coordinated Time (UTC). Het minimumaantal minuten dat wordt verschoven van UTC is -840, die een UTC-offset van -14:00 of veertien uur eerder dan UTC vertegenwoordigt. Het maximum aantal minuten dat wordt verschoven van UTC is 840, wat overeenkomt met een UTC-offset van 14:00 uur.

Hoewel er geen letterlijke syntaxis is voor datum/tijdzones, worden er verschillende standaardbibliotheekfuncties geboden om ze samen te stellen. Datetimezones kunnen ook worden samengesteld met behulp van de intrinsieke functie #datetimezone:

#datetimezone(
       year, month, day,
       hour, minute, second,
       offset-hours, offset-minutes)

Het volgende moet worden opgeslagen of er wordt een fout met redencode Expression.Error gegenereerd:

1 ≤ jaar ≤ 9999
1 ≤ maand ≤ 12
1 ≤ dag ≤ 31
0 ≤ uur ≤ 23
0 ≤ minuut ≤ 59
0 ≤ tweede ≤ 59
-14 ≤ offseturen ≤ 14
-59 ≤ offsetminuten ≤ 59

Bovendien moet de dag geldig zijn voor de gekozen maand en het jaar en, als offseturen = 14, dan offsetminuten <= 0 en, als offseturen = -14, dan offsetminuten >= 0.

De volgende operators zijn gedefinieerd voor datum/tijdzone-waarden:

Operator	Result
x = y	Equal
x <> y	Not equal
x >= y	Groter dan of gelijk aan
x > y	Groter dan
x < y	Kleiner dan
x <= y	Kleiner dan of gelijk aan
x ?? y	Coalesce

Met de volgende operators kunnen een of beide operanden een datum/tijdzone zijn:

Operator	Linkeroperand	Rechteroperand	Betekenis
x + y	datetimezone	duration	Offset van datum/tijdzone op duur
x + y	duration	datetimezone	Offset van datum/tijdzone op duur
x - y	datetimezone	duration	Datum/tijdzone-offset op negated duration
x - y	datetimezone	datetimezone	Duur tussen datum/tijdzones

Het systeemeigen type datum/tijdzone-waarden is het intrinsieke type datetimezone.

Duur

Een duurwaarde slaat een ondoorzichtige weergave op van de afstand tussen twee punten op een tijdlijn met 100 nanoseconden. De grootte van een duur kan positief of negatief zijn, met positieve waarden die de voortgang in tijd aandukken en negatieve waarden die de voortgang achterwaarts in de tijd aandukken. De minimumwaarde die in een duur kan worden opgeslagen, is -9.223.372.036.854.775.808 tikken of 10.675.199 dagen 2 uur 48 minuten 05,4775808 seconden achteruit in de tijd. De maximumwaarde die in een duur kan worden opgeslagen, is 9.223.372.036.854.775.807 tikken of 10.675.199 dagen 2 uur 48 minuten 05,4775807 seconden vooruit in de tijd.

Hoewel er geen letterlijke syntaxis is voor duur, worden er verschillende standaardbibliotheekfuncties geboden om ze samen te stellen. Duur kan ook worden samengesteld met behulp van de intrinsieke functie #duration:

#duration(0, 0, 0, 5.5)          // 5.5 seconds 
#duration(0, 0, 0, -5.5)         // -5.5 seconds 
#duration(0, 0, 5, 30)           // 5.5 minutes 
#duration(0, 0, 5, -30)          // 4.5 minutes 
#duration(0, 24, 0, 0)           // 1 day 
#duration(1, 0, 0, 0)            // 1 day

De volgende operators zijn gedefinieerd voor duurwaarden:

Operator	Result
x = y	Equal
x <> y	Not equal
x >= y	Groter dan of gelijk aan
x > y	Groter dan
x < y	Kleiner dan
x <= y	Kleiner dan of gelijk aan
x ?? y	Coalesce

Bovendien staan de volgende operators toe dat een of beide operanden een duurwaarde zijn:

Operator	Linkeroperand	Rechteroperand	Betekenis
x + y	datetime	duration	Datum/tijd-verschuiving op duur
x + y	duration	datetime	Datum/tijd-verschuiving op duur
x + y	duration	duration	Som van duur
x - y	datetime	duration	Datum/tijd-verschuiving op negatieve duur
x - y	datetime	datetime	Duur tussen datum/tijd
x - y	duration	duration	Verschil in duur
x * y	duration	number	N keer een duur
x * y	number	duration	N keer een duur
x / y	duration	number	Fractie van een duur

Het systeemeigen type duurwaarden is het intrinsieke type duration.

Sms verzenden

Een tekstwaarde vertegenwoordigt een reeks Unicode-tekens. Tekstwaarden hebben een letterlijke vorm die voldoet aan de volgende grammatica:

_text letterlijk:
      "opt voor tekst-letterlijke tekens"
letterlijke tekst:
      tekst-letterlijk-teken-letterlijk-tekens_kiezen
tekst-letterlijk-teken:
      één tekstteken
      teken-escape-reeks
      double-quote-escape-sequence
enkel tekstteken:
      Elk teken behalve " (U+0022) of # (U+0023) gevolgd door ( (U+0028)
double-quote-escape-sequence:
      "" (U+0022, U+0022)

Hier volgt een voorbeeld van een tekstwaarde :

"ABC" // the text value ABC

De volgende operators zijn gedefinieerd voor tekstwaarden :

Operator	Result
x = y	Equal
x <> y	Not equal
x >= y	Groter dan of gelijk aan
x > y	Groter dan
x < y	Kleiner dan
x <= y	Kleiner dan of gelijk aan
x & y	Samenvoegen
x ?? y	Coalesce

Het systeemeigen type tekstwaarden is het intrinsieke type text.

Binary

Een binaire waarde vertegenwoordigt een reeks bytes.

Hoewel er geen letterlijke syntaxis voor binaire waarden is, worden er verschillende standaardbibliotheekfuncties geboden om ze samen te stellen. Binaire waarden kunnen ook worden samengesteld met behulp van de intrinsieke functie #binary.

In het volgende voorbeeld wordt een binaire waarde samengesteld uit een lijst met bytes:

#binary( {0x00, 0x01, 0x02, 0x03} )

De volgende operators zijn gedefinieerd voor binaire waarden:

Operator	Result
x = y	Equal
x <> y	Not equal
x >= y	Groter dan of gelijk aan
x > y	Groter dan
x < y	Kleiner dan
x <= y	Kleiner dan of gelijk aan
x ?? y	Coalesce

Het systeemeigen type binaire waarden is het intrinsieke type binair.

List

Een lijstwaarde is een waarde die een reeks waarden produceert wanneer deze wordt opgesomd. Een waarde die door een lijst wordt geproduceerd, kan elk soort waarde bevatten, inclusief een lijst. Lijsten kunnen als volgt worden samengesteld met behulp van de initialisatiesyntaxis:

list-expression:
      { itemlijst_opt }
itemlijst:
      Item
      itemitemlijst,
item:
      Expressie
      expressie expressie..

Hier volgt een voorbeeld van een lijstexpressie waarmee een lijst met drie tekstwaarden wordt gedefinieerd: "A", "B"en "C".

{"A", "B", "C"}

De waarde "A" is het eerste item in de lijst en de waarde "C" is het laatste item in de lijst.

• De items van een lijst worden pas geëvalueerd wanneer ze worden geopend.
• Terwijl lijstwaarden die zijn samengesteld met behulp van de syntaxis van de lijst, items produceren in de volgorde waarin ze worden weergegeven in de itemlijst, kunnen lijsten die worden geretourneerd uit bibliotheekfuncties een andere set of een ander aantal waarden produceren telkens wanneer ze worden geïnventariseerd.

Als u een reeks gehele getallen in een lijst wilt opnemen, kan het a..b formulier worden gebruikt:

{ 1, 5..9, 11 }     // { 1, 5, 6, 7, 8, 9, 11 }

Het aantal items in een lijst, ook wel het aantal lijsten genoemd, kan worden bepaald met behulp van de List.Count functie.

List.Count({true, false})  // 2 
List.Count({})             // 0

Een lijst kan in feite een oneindig aantal items bevatten; List.Count voor dergelijke lijsten is niet gedefinieerd en kan een fout veroorzaken of niet worden beëindigd.

Als een lijst geen items bevat, wordt deze een lege lijst genoemd. Een lege lijst wordt geschreven als:

{}  // empty list

De volgende operators zijn gedefinieerd voor lijsten:

Operator	Result
x = y	Equal
x <> y	Not equal
x & y	Concatenate
x ?? y	Coalesce

Bijvoorbeeld:

{1, 2} & {3, 4, 5}   // {1, 2, 3, 4, 5} 
{1, 2} = {1, 2}      // true 
{2, 1} <> {1, 2}     // true

Het systeemeigen type lijstwaarden is het intrinsieke type list, waarmee een itemtype wordt anyopgegeven.

Opnemen

Een recordwaarde is een geordende reeks velden. Een veld bestaat uit een veldnaam, een tekstwaarde die het veld in de record uniek identificeert en een veldwaarde. De veldwaarde kan elk type waarde zijn, inclusief record. Records kunnen als volgt worden samengesteld met behulp van initialisatiesyntaxis:

record-expression:
      [opt voor_{lijst met velden}]
lijst met velden:
      veld
      veldveldlijst,
Veld:
      veldnaamexpressie=
veldnaam:
      gegeneraliseerde id
      id tussen aan/ uit

In het volgende voorbeeld wordt een record samengesteld met een veld met de naam x waarde 1en een veld met de naam y waarde 2.

[ x = 1, y = 2 ]

In het volgende voorbeeld wordt een record gemaakt met een veld met a de naam a met een geneste recordwaarde. De geneste record heeft een veld met de naam b waarde 2.

[ a = [ b = 2 ] ]

Het volgende geldt voor het evalueren van een recordexpressie:

• De expressie die aan elke veldnaam is toegewezen, wordt gebruikt om de waarde van het gekoppelde veld te bepalen.

• Als de expressie die is toegewezen aan een veldnaam een waarde produceert wanneer deze wordt geëvalueerd, wordt dat de waarde van het veld van de resulterende record.

• Als de expressie die is toegewezen aan een veldnaam een fout genereert wanneer deze wordt geëvalueerd, wordt het feit dat er een fout is gegenereerd, vastgelegd met het veld, samen met de foutwaarde die is gegenereerd. Bij volgende toegang tot dat veld wordt een fout opnieuw gegenereerd met de vastgelegde foutwaarde.

• De expressie wordt geëvalueerd in een omgeving zoals de bovenliggende omgeving, alleen met variabelen die overeenkomen met de waarde van elk veld van de record, behalve de omgeving die wordt geïnitialiseerd.

• Een waarde in een record wordt pas geëvalueerd als het bijbehorende veld wordt geopend.

• Een waarde in een record wordt maximaal één keer geëvalueerd.

• Het resultaat van de expressie is een recordwaarde met een lege metagegevensrecord.

• De volgorde van de velden in de record wordt gedefinieerd door de volgorde die ze weergeven in de record-initializer-expression.

• Elke veldnaam die is opgegeven, moet uniek zijn binnen de record of is een fout. Namen worden vergeleken met behulp van een rangtelvergelijking.

    [ x = 1, x = 2 ] // error: field names must be unique 
    [ X = 1, x = 2 ] // OK

Een record zonder velden wordt een lege record genoemd en wordt als volgt geschreven:

[] // empty record

Hoewel de volgorde van de velden van een record niet significant is bij het openen van een veld of het vergelijken van twee records, is het belangrijk in andere contexten, zoals wanneer de velden van een record worden geïnventariseerd.

Dezelfde twee records produceren verschillende resultaten wanneer de velden worden verkregen:

Record.FieldNames([ x = 1, y = 2 ]) // [ "x", "y" ] 
Record.FieldNames([ y = 1, x = 2 ]) // [ "y", "x" ]

Het aantal velden in een record kan worden bepaald met behulp van de Record.FieldCount functie. Bijvoorbeeld:

Record.FieldCount([ x = 1, y = 2 })  // 2 
Record.FieldCount([])                // 0

Naast het gebruik van de syntaxis [ ]van de record initialisatie kunnen records worden samengesteld uit een lijst met waarden en een lijst met veldnamen of een recordtype. Bijvoorbeeld:

Record.FromList({1, 2}, {"a", "b"})

Het bovenstaande is gelijk aan:

[ a = 1, b = 2 ]

De volgende operators zijn gedefinieerd voor recordwaarden:

Operator	Result
x = y	Equal
x <> y	Not equal
x & y	Samenvoeging
x ?? y	Coalesce

In de volgende voorbeelden ziet u de bovenstaande operators. Bij recordsamenvoeging worden de velden van de rechteroperand gebruikt om velden uit de linkeroperand te overschrijven, mocht er sprake zijn van een overlapping in veldnamen.

[ a = 1, b = 2 ] & [ c = 3 ]    // [ a = 1, b = 2, c = 3 ] 
[ a = 1, b = 2 ] & [ a = 3 ]    // [ a = 3, b = 2 ] 
[ a = 1, b = 2 ] = [ b = 2, a = 1 ]         // true 
[ a = 1, b = 2, c = 3 ] <> [ a = 1, b = 2 ] // true

Het systeemeigen type recordwaarden is het intrinsieke type record, waarmee een geopende lege lijst met velden wordt opgegeven.

Tabel

Een tabelwaarde is een geordende reeks rijen. Een rij is een geordende reeks kolomwaarden. Het type tabel bepaalt de lengte van alle rijen in de tabel, de namen van de kolommen van de tabel, de typen kolommen van de tabel en de structuur van de sleutels van de tabel (indien van toepassing).

Hoewel er geen letterlijke syntaxis voor tabellen is, worden er verschillende standaardbibliotheekfuncties geboden om ze samen te stellen. Tabellen kunnen ook worden samengesteld met behulp van de intrinsieke functie #table.

In het volgende voorbeeld wordt een tabel samengesteld uit een lijst met kolomnamen en een lijst met rijen. De resulterende tabel bevat twee kolommen van type any en drie rijen.

#table({"x", "x^2"}, {{1,1}, {2,4}, {3,9}})

#table kan ook worden gebruikt om een volledig tabeltype op te geven:

#table(
    type table [Digit = number, Name = text],  
    {{1,"one"}, {2,"two"}, {3,"three"}} 
    )

Hier heeft de nieuwe tabelwaarde een tabeltype waarmee kolomnamen en kolomtypen worden opgegeven.

De volgende operators zijn gedefinieerd voor tabelwaarden:

Operator	Result
x = y	Equal
x <> y	Not equal
x & y	Samenvoegen
x ?? y	Coalesce

Tabelsamenvoeging lijnt like-named kolommen uit en vult null in voor kolommen die slechts in één van de operandtabellen worden weergegeven. In het volgende voorbeeld ziet u tabelsamenvoeging:

  #table({"A","B"}, {{1,2}}) 
& #table({"B","C"}, {{3,4}})

V	B	C
1	2	null
null	3	4

Het systeemeigen type tabelwaarden is een aangepast tabeltype (afgeleid van het intrinsieke type table) waarin de kolomnamen worden vermeld, waarmee alle kolomtypen worden opgegeven die moeten worden opgegeven en geen sleutels hebben. (Ga naar Tabeltypen voor meer informatie over tabeltypen.)

Function

Een functiewaarde is een waarde waarmee een set argumenten wordt toegewezen aan één waarde. De details van functiewaarden worden beschreven in Functions.

Type

Een typewaarde is een waarde die andere waarden classificeert. De details van typewaarden worden beschreven in Typen.