Lue englanniksi

Jaa


Operaattorin toiminta

Tässä osiossa määritetään eri M-operaattoreiden toiminta.

Operaattoreiden käsittelyjärjestys

Kun lauseke sisältää useita operaattoreita, operaattoreiden käsittelyjärjestys ohjaa järjestystä, jossa yksittäiset operaattorit arvioidaan. Esimerkiksi lauseketta x + y * z arvioidaan seuraavasti x + (y * z) : - * operaattorilla on suurempi tärkeysjärjestys kuin binaarioperaattorilla + . Operaattorin tärkeysjärjestys määräytyy siihen liittyvän kielioppituotannon määrittelyn mukaan. Esimerkiksi additive-expression koostuu multiplicative-expression-lausekkeista eroteltuna -tai -operaattoreilla+, jolloin ja - -+operaattorit ovat alhaisemmalla etusijalla kuin - ja*./

parenthesized-expression-tuotantoa voidaan käyttää oletusjärjestyksen muuttamiseen.

parenthesized-expression:
       ( lauseke)

Esimerkkejä:

1 + 2 * 3       // 7 
(1 + 2) * 3     // 9

Seuraavassa taulukossa on yhteenveto M-operaattoreista, ja siinä luetellaan operaattoriluokat tärkeysjärjestyksessä suurimmasta pienimpään. Saman luokan operaattoreilla on sama tärkeysjärjestys.

Luokka Expression Kuvaus
Ensisijainen minä
@ minä
Tunnistelauseke
(x) Sulkeiden suluissa ollut lauseke
x[i] Haku
x{y} Kohteen käyttö
x(...) Funktiokutsu
{x, y, ...} Luettelon valmistelu
[ i = x, ... ] Tietueen valmistelu
... Ei toteutettu
Unaarinen + x Käyttäjätiedot
- x Negaatio
not x Looginen negaatio
Metatiedot xmetay Liitä metatiedot
Multiplikatiivinen x * y Kertolasku
x / y Jakolasku
Additiivinen x + y Yhteenlasku
x - y Vähennys
Relaatio x< y Pienempi kuin
x > y Suurempi kuin
x<= y Pienempi tai yhtä suuri kuin
x >= y Suurempi tai yhtä suuri kuin
Samanarvoisuus x = y Sama kuin
x<> y Not equal
Tyypin vahvistus xasy On yhteensopiva nullable-primitive-tyyppi tai virhe
Tyypin vastaavuus xisy Testaa, onko yhteensopiva nullable-primitive-tyypin kanssa
Looginen JA xandy Oikosulukonjunktio
Looginen TAI xory Oikosulun erottaminen
Coalesce x??y Tyhjäarvoinen hiilitysoperaattori

Operaattorit ja metatiedot

Jokaisella arvolla on siihen liittyvä tietuearvo, joka voi sisältää lisätietoja arvosta. Tätä tietuetta kutsutaan arvon metatietotietueeksi . Metatietotietue voidaan liittää mihin tahansa arvoon, myös null. Tällaisen liitoksen tulos on uusi arvo, jolla on annetut metatiedot.

Metatietotietue on vain tavallinen tietue, ja se voi sisältää kenttiä ja arvoja, joita tavallinen tietue voi sisältää, ja sillä on itsellään metatietotietue. Metatietotietueen liittäminen arvoon ei keskeytä muuta toimintaa. Se ei muuta arvon toimintaa arvioinneissa lukuun ottamatta niitä, jotka nimenomaan tarkastelevat metatietotietueita.

Jokaisella arvolla on oletusarvoinen metatietotietue, vaikka sellaista ei olisikaan määritetty. Oletusarvoinen metatietotietue on tyhjä. Seuraavissa esimerkeissä näytetään tekstiarvon metatietotietueen käyttäminen vakiokirjastofunktiolla Value.Metadata :

Value.Metadata( "Mozart" )   // []

Metatietotietueita ei yleensä säilytetä , kun arvoa käytetään operaattorilla tai funktiolla, joka luo uuden arvon. Jos esimerkiksi kaksi tekstiarvoa yhdistetään -operaattorin & avulla, tuloksena saatavan tekstiarvon metatietona on tyhjä tietue []. Seuraavat lausekkeet vastaavat toisiaan:

"Amadeus " & ("Mozart" meta [ Rating = 5 ])  
"Amadeus " & "Mozart"

Vakiokirjastofunktioita Value.RemoveMetadata ja Value.ReplaceMetadata voidaan käyttää kaikkien metatietojen poistamiseen arvosta ja arvon metatietojen korvaamiseen (metatietojen yhdistämisen sijaan mahdollisesti olemassa oleviin metatietoihin).

Ainoa operaattori, joka palauttaa metatietoja sisältävät tulokset, on meta-operaattori.

Rakenteellisesti rekursiiviset operaattorit

Arvot voivat olla syklisia. Esimerkkejä:

let l = {0, @l} in l
// {0, {0, {0, ... }}}
[A={B}, B={A}]
// [A = {{ ... }}, B = {{ ... }}]

M käsittelee sykliset arvot pitämällä kirjaa, luetteloimalla ja taulukoiden laiskoina. Yritys luoda syklinen arvo, joka ei hyödy jälkirakenne arvoista, tuottaa virheen:

[A=B, B=A] 
// [A = Error.Record("Expression.Error", 
//         "A cyclic reference was encountered during evaluation"), 
//  B = Error.Record("Expression.Error", 
//         "A cyclic reference was encountered during evaluation"), 
// ]

Jotkin M-operaattorit on määritetty rakenteen rekursion avulla. Esimerkiksi tietueiden ja luetteloiden yhdenvertaisuus on määritetty vastaavissa tietuekentissä ja kohdeluetteloissa.

Ei-sykliset arvot, jotka soveltavat rakenteellista rekursiota, tuottavat rajallisen laajennuksen arvosta: jaettuja sisäkkäisiä arvoja käytetään toistuvasti, mutta rekursion prosessi päättyy aina.

Syklisen arvon ääretön laajennus käytettäessä rakenteellista rekursiota. M-semantiikka ei tee mitään erityistä mukautusta tällaisille loputtomia laajennuksia varten – yritys vertailla esimerkiksi syklisiä arvoja on yleensä jäänyt ilman resursseja ja lopettanut ne poikkeuksellisesti.

Valinta- ja projektio-operaattorit

Valinta- ja projektio-operaattorit sallivat tietojen poimimisen luettelo- ja tietuearvoista.

Kohteen käyttö

Arvo voidaan valita luettelosta tai taulukosta sen nollaan perustuvan sijainnin perusteella, joka on kyseisessä luettelossa tai taulukossa käyttäen item-access-expression-lauseketta.

item-access-expression:
      item-selection
      optional-item-selection
item-selection:
      primary-expression
{item-selector}
optional-item-selection:
      primary-expression
{item-selector} ?
item-selector:
      lauseke

item-access-expressionx{y} palauttaa:

  • Luetteloa x ja lukua yvarten luettelokohde x sijainnissa y. Luettelon ensimmäisen kohteen koordinaattorin koordinaattoriarvo on nolla. Jos pyydettyä sijaintia ei ole luettelossa, esiin tulee virhe.

  • Taulukolle x ja luvulle ytaulukon x rivi sijainnissa y. Taulukon ensimmäisen rivin koordinaattoriindeksi on nolla. Jos pyydettyä sijaintia ei ole taulukossa, esiin tulee virhe.

  • Taulukolle x ja tietueelle ytaulukon x rivi, joka vastaa tietueen y kenttien arvoja kentillä, joiden nimet vastaavat kyseisiä taulukon sarakenimiä. Jos taulukossa ei ole yksilöivää vastaavaa riviä, esiin tulee virhe.

Esimerkkejä:

{"a","b","c"}{0}                        // "a" 
{1, [A=2], 3}{1}                        // [A=2] 
{true, false}{2}                        // error 
#table({"A","B"},{{0,1},{2,1}}){0}      // [A=0,B=1] 
#table({"A","B"},{{0,1},{2,1}}){[A=2]}  // [A=2,B=1]  
#table({"A","B"},{{0,1},{2,1}}){[B=3]}  // error 
#table({"A","B"},{{0,1},{2,1}}){[B=1]}  // error

item-access-expressionx Jos kohdassa yon useita vastaavuuksia, esiin tulee yhä virhe.

Esimerkkejä:

{"a","b","c"}{0}?                       // "a" 
{1, [A=2], 3}{1}?                       // [A=2] 
{true, false}{2}?                       // null 
#table({"A","B"},{{0,1},{2,1}}){0}?     // [A=0,B=1] 
#table({"A","B"},{{0,1},{2,1}}){[A=2]}? // [A=2,B=1]  
#table({"A","B"},{{0,1},{2,1}}){[B=3]}? // null 
#table({"A","B"},{{0,1},{2,1}}){[B=1]}? // error

Kohteen käyttö ei pakota muiden luettelo- tai taulukkokohteiden arviointia kuin se, jota käytetään. Esimerkkejä:

{ error "a", 1, error "c"}{1}  // 1 
{ error "a", error "b"}{1}     // error "b"

Seuraava pätee, kun kohteen käyttöoperaattoria x{y} arvioidaan:

  • Tai -lausekkeen arvioinnin aikana esiin tuodut xy virheet välitetään.

  • Lauseke x tuottaa luettelon tai taulukon arvon.

  • Lauseke y tuottaa lukuarvon tai jos x tuottaa taulukkoarvon, se tuottaa tietuearvon.

  • Jos y tuottaa lukuarvon ja -arvo y on negatiivinen, annetaan syykoodin "Expression.Error" sisältävä virhe.

  • Jos y tuottaa lukuarvon ja -arvo y on suurempi tai yhtä suuri kuin - xmäärä, virhe ja syykoodi "Expression.Error" annetaan, ellei valinnaista operaattorilomaketta x{y}? käytetä, jolloin palautetaan arvo null .

  • Jos x tuottaa taulukkoarvon ja y tuottaa tietuearvon eikä kohdassa ysisällä vastaavuuksiax, annetaan virhe ja syykoodi"Expression.Error", ellei valinnaista operaattorilomaketta x{y}? käytetä, jolloin palautetaan arvonull.

  • Jos x tuottaa taulukkoarvon ja y tuottaa tietuearvon ja kohdassa ysisältää useita vastaavuuksiax, annetaan virhe ja syykoodi"Expression.Error".

Mitään kohteessa olevia muita kuin sijainnissa x olevia kohteita y ei arvioida kohteen valinnan prosessin aikana. (Luetteloiden tai taulukoiden kohdalla ohitetaan edeltävät kohteet tai rivit y , mikä voi aiheuttaa niiden arvioinnin luettelon tai taulukon lähteestä riippuen.)

Kentän käyttö

field-access-expression-lauseketta käytetään valitsemaan arvo tietueesta tai projisoimaantietue tai taulukko siihen, jossa on vähemmän kenttiä tai sarakkeita.

field-access-expression:
      field-selection
      implicit-target-field-selection
      projektio
      implicit-target-projection
field-selection:
      primary-expression field-selector
field-selector:
      required-field-selector
      optional-field-selector
required-field-selector:

       [ field-name]
optional-field-selector:
       [ field-name] ?
field-name:
      generalized-identifier
      quoted-identifier
implicit-target-field-selection:
      field-selector
projektio:
      primary-expression required-projection
      primary-expression optional-projection
required-projection:

       [ required-selector-list]
optional-projection:
       [ required-selector-list] ?
required-selector-list:
      required-field-selector
      required-selector-list
,required-field-selector
implicit-target-projection:
      required-projection
      optional-projection

Kentän käytön yksinkertaisin muoto on pakollinen kentän valinta. Se käyttää operaattoria x[y] etsimään kenttää tietueesta kentän nimen mukaan. Jos kenttää y ei ole kohteessa x, esiin tulee virhe. Lomakkeen x[y]? avulla suoritetaan valinnainen kentän valinta ja palautetaan null , jos pyydettyä kenttää ei ole tietueessa.

Esimerkkejä:

[A=1,B=2][B]       // 2 
[A=1,B=2][C]       // error 
[A=1,B=2][C]?      // null

Operaattorit tukevat useiden kenttien kollektiivista käyttöä pakolliselle tietueen projektiota ja valinnaista tietueen projektiota varten. Operaattori x[[y1],[y2],...] projisoi tietueen uuteen tietueeseen, jossa on vähemmän kenttiä (valitsija , y1y2, ...). Jos valittua kenttää ei ole, esiin tulee virhe. Operaattori x[[y1],[y2],...]? projisoi tietueen uuteen tietueeseen käyttäen , ja valitsemia y1y2...kenttiä. Jos kenttä puuttuu, null käytetään sen sijaan . Esimerkkejä:

[A=1,B=2][[B]]           // [B=2] 
[A=1,B=2][[C]]           // error 
[A=1,B=2][[B],[C]]?      // [B=2,C=null]

Lomakkeita [y] ja [y]? tuetaan lyhenneviittauksenatunnisteessa _ (alaviiva). Seuraavat kaksi lauseketta vastaavat toisiaan:

[A]                 
_[A]

Seuraavassa esimerkissä havainnollistetaan kentän käyttöoikeuksien lyhennemuoto:

let _ = [A=1,B=2] in [A] //1

Lomaketta [[y1],[y2],...] ja [[y1],[y2],...]? tuetaan myös lyhenteinä, ja seuraavat kaksi lauseketta ovat myös toisiaan vastaavia:

[[A],[B]]                 
_[[A],[B]]

Lyhennelomake on erityisen hyödyllinen yhdessä pikakirjoituksen each kanssa, joka on tapa ottaa käyttöön yksittäinen parametri nimeltä _ (lisätietoja on kohdassa Yksinkertaistetut määrittelyt). Yhdessä kaksi pikakirjoitusta yksinkertaistavat yleisiä korkeamman tason toiminnallisia lausekkeita:

List.Select( {[a=1, b=1], [a=2, b=4]}, each [a] = [b]) 
// {[a=1, b=1]}

Yllä oleva lauseke vastaa seuraavia salaperäisempiä pitkäikäisimpiä arvoja:

List.Select( {[a=1, b=1], [a=2, b=4]}, (_) => _[a] = _[b]) 
// {[a=1, b=1]}

Kentän käyttö ei pakota muiden kuin käytettävien kenttien arviointia. Esimerkkejä:

[A=error "a", B=1, C=error "c"][B]  // 1 
[A=error "a", B=error "b"][B]       // error "b"

Seuraava pätee, kun kentän käyttöoperaattoria x[y], x[y]?, x[[y]]tai x[[y]]? arvioidaan:

  • Lausekkeen x arvioinnin aikana esiin tuodut virheet välitetään.

  • Kentän y arvioinnissa esiin tuodut virheet liittyvät pysyvästi kenttään y, jonka jälkeen ne välitetään. Kentän tuleva käyttö y tuo esiin samanlaisen virheen.

  • Lauseke x tuottaa tietueen tai taulukon arvon, tai syntyy virhe.

  • Jos tunniste y nimeää kentän, jota ei ole kohteessa x, syykoodin "Expression.Error" sisältävä virhe annetaan, ellei valinnaista operaattorilomaketta ...? käytetä, jolloin palautetaan arvo null .

Kentän käyttöprosessin aikana ei arvioida mitään muuta kuin nimeämää x kenttääy.

Metatieto-operaattori

Arvon metatietotietuetta muutetaan meta-operaattorin (x meta y) avulla.

metadata-expression:
      unary-expression
      unary-expression
metaunary-expression

Seuraava esimerkki muodostaa tekstiarvon metatietotietueen avulla -operaattorilla meta ja käyttää sitten tulokseksi saatavan arvon metatietotietuetta käyttämällä Value.Metadata:

Value.Metadata( "Mozart" meta [ Rating = 5 ] ) 
// [Rating = 5 ]
Value.Metadata( "Mozart" meta [ Rating = 5 ] )[Rating] 
// 5

Seuraava pätee, kun käytetään metatietoja yhdistämällä operaattoria x meta y:

  • tai x -ylausekkeiden arvioinnissa esiin tuodut virheet välitetään.

  • y Lausekkeen on oltava tietue, tai annetaan virhe syykoodilla "Expression.Error" .

  • Tulokseksi saatava metatietotietue on :n metatietotietue, joka on xyhdistetty kohteeseen y. (Tietueen yhdistämisen semantiikka on ohjeaiheessa Tietueen yhdistäminen.)

  • Tulokseksi saatava arvo on -lausekkeen x arvo ilman sen metatietoja, kun juuri laskettu metatietotietue on liitetty siihen.

Vakiokirjastofunktioita Value.RemoveMetadata ja Value.ReplaceMetadata voidaan käyttää kaikkien metatietojen poistamiseen arvosta ja arvon metatietojen korvaamiseen (metatietojen yhdistämisen sijaan mahdollisesti olemassa oleviin metatietoihin). Seuraavat lausekkeet vastaavat toisiaan:

x meta y  
Value.ReplaceMetadata(x, Value.Metadata(x) & y) 
Value.RemoveMetadata(x) meta (Value.Metadata(x) & y)

Yhtäläisyysoperaattorit

Yhtäläisyysoperaattoria = käytetään määrittämään, ovatko kaksi arvoa yhtä suuret. Epätasa-arvo-operaattoria <> käytetään määrittämään, ovatko kaksi arvoa eri suuret.

equality-expression:
      relational-expression
      relational-expression
=equality-expression
      relational-expression
<>equality-expression

Esimerkkejä:

1 = 1            // true 
1 = 2            // false 
1 <> 1           // false 
1 <> 2           // true 
null = true      // false 
null = null      // true

Metatiedot eivät ole osa yhtäläisyys- tai eriarvoisuusvertailua. Esimerkkejä:

(1 meta [ a = 1 ]) = (1 meta [ a = 2 ]) // true 
(1 meta [ a = 1 ]) = 1                  // true

Seuraava pätee, kun käytetään yhtäläisyysoperaattoreita x = y ja x <> y:

  • tai x -ylausekkeiden arvioinnissa esiin tuodut virheet välitetään.

  • operaattorilla = on tulos true , jos arvot ovat yhtä suuret, ja false muussa tapauksessa .

  • operaattorilla <> on tulos false , jos arvot ovat yhtä suuret, ja true muussa tapauksessa .

  • Metatietotietueita ei sisällytetä vertailuun.

  • Jos - ja x -ylausekkeiden avulla tuotetut arvot eivät ole samaa arvoa, arvot eivät ole yhtä suuret.

  • Jos - ja x -lausekkeen tuottamat y arvot ovat samaa arvoa, on olemassa erityisiä sääntöjä, joiden avulla määritetään, ovatko ne yhtä suuret, kuten alla on määritetty.

  • Seuraava on aina tosi:

    (x = y) = not (x <> y)

Yhtäläisyysoperaattorit on määritetty seuraaville tyypeille:

  • Arvo null on vain yhtä suuri kuin se itse.
    null = null    // true 
    null = true    // false 
    null = false   // false
  • Loogiset arvot true ja false ovat vain itseään vastaavat. Esimerkkejä:
    true = true      // true 
    false = false    // true 
    true = false     // false 
    true = 1         // false
  • Lukuja verrataan käyttäen määritettyä tarkkuutta:

    • Jos jompikumpi luku on #nan, luvut eivät ole samoja.

    • Kun kumpikaan luku ei ole #nan, lukuja verrataan lukuarvon bittitason vertailuun.

    • #nan on ainoa arvo, joka ei ole sama kuin se itse.

      Esimerkkejä:

        1 = 1,              // true 
        1.0 = 1             // true 
        2 = 1               // false 
        #nan = #nan         // false 
        #nan <> #nan        // true
  • Kaksi kestoa ovat samat, jos ne edustavat yhtä montaa 100 nanosekunnin jaksoa.

  • Kaksi aikaa ovat samat, jos niiden osien (tunnit, minuutit, sekunnit) suuruus on sama.

  • Kaksi päivämäärää ovat samat, jos niiden osien (vuosi, kuukausi, päivä) suuruus on sama.

  • Kaksi päivämäärää/aikaa ovat samat, jos niiden osien (vuosi, kuukausi, päivä, tunnit, minuutit, sekunnit) suuruus on sama.

  • Kaksi päivämäärää/aikavyöhykearvoa ovat samat, jos vastaavat UTC-päivämääräajat ovat samat. Jos haluat saapua vastaavaan UTC-päivämäärään/aikaan, tunnit/minuutit-siirtymä vähennetään datetimezone-kohteen datetime-osasta.

  • Kaksi tekstiarvoa ovat samat, jos käytössä on parametrinen, kirjainkoko huomioon ottava, kulttuurista riippumattoman vertailun yhteydessä saman pituinen ja yhtä suuri kuin vastaavassa kohdassa.

  • Kaksi luettelon arvoa ovat samat, jos kaikki seuraavista ovat tosia:

    • Molemmissa luetteloissa on sama määrä kohteita.

    • Luetteloiden vastaavien kohteiden arvot ovat yhtä suuret. Tämä tarkoittaa sitä, että luetteloiden on sisällettävä yhtä suuria kohteita, mutta kohteiden on oltava samassa järjestyksessä.

      Esimerkkejä:

        {1, 2} = {1, 2}     // true 
        {2, 1} = {1, 2}     // false 
        {1, 2, 3} = {1, 2}  // false
      
  • Kaksi tietuetta ovat samat, jos kaikki seuraavista ovat toisia:

    • Kenttien määrä on sama.

    • Toisessa tietueessa on myös yhden tietueen kunkin kentän nimi.

    • Yhden tietueen kunkin kentän arvo on sama kuin toisen tietueen Like-named-kenttä.

      Esimerkkejä:

        [ A = 1, B = 2 ] = [ A = 1, B = 2 ]        // true 
        [ B = 2, A = 1 ] = [ A = 1, B = 2 ]        // true 
        [ A = 1, B = 2, C = 3 ] = [ A = 1, B = 2 ] // false 
        [ A = 1 ] = [ A = 1, B = 2 ]               // false
      
  • Kaksi taulukkoa ovat samat, jos kaikki seuraavista ovat toisia:

    • Sarakkeiden määrä on sama.

    • Toisessa taulukossa on myös kunkin sarakkeen nimi yhdessä taulukossa.

    • Rivien määrä on sama.

    • Kullakin rivillä on samat arvot vastaavissa soluissa.

      Esimerkkejä:

        #table({"A","B"},{{1,2}}) = #table({"A","B"},{{1,2}}) // true 
        #table({"A","B"},{{1,2}}) = #table({"X","Y"},{{1,2}}) // false 
        #table({"A","B"},{{1,2}}) = #table({"B","A"},{{2,1}}) // true
      
  • Funktion arvo on sama kuin se itse, mutta se ei voi olla sama kuin toinen funktion arvo. Jos kaksi funktioiden arvoa katsotaan samanlaisiksi, ne toimivat samalla tavalla, kun ne käynnistetään.

    Kahdella annetulla funktioiden arvolla on aina sama yhtäsuuruussuhde.

  • Tyypin arvo on sama kuin se itse, mutta se ei voi olla sama kuin toinen tyypin arvo. Jos kaksi tyypin arvoa katsotaan samanlaisiksi, ne toimivat samalla tavalla, kun niitä pyydetään vastaamaan toisiaan.

    Kahdella annetulla tyypin arvolla on aina sama yhtäsuuruussuhde.

Relaatio-operaattorit

-, -, - ja < ->operaattoreita kutsutaan relaatio-operaattoreiksi<=. >=

relational-expression:
      additive-expression
      additive-expression
<relational-expression
      additive-expression
>relational-expression
      additive-expression
<=relational-expression
      additive-expression
>=relational-expression

Näiden operaattoreiden avulla määritetään kahden arvon välinen suhteellinen järjestys seuraavassa taulukossa esitetyllä tavalla:

Toiminto Result
x < y true jos x on pienempi kuin y, false muuten
x > y true jos x on suurempi kuin y, false muuten
x <= y true jos x on pienempi tai yhtä suuri ykuin , false muuten
x >= y true jos x on suurempi tai yhtä suuri ykuin , false muuten

Esimerkkejä:

0 <= 1            // true 
null < 1          // null 
null <= null      // null 
"ab" < "abc"      // true 
#nan >= #nan      // false  
#nan <= #nan      // false

Seuraava pätee arvioitaessa lauseketta, joka sisältää relaatio-operaattorit:

  • tai x -operandien lausekkeiden arvioinnissa y esiin tuodut virheet välitetään.

  • Sekä - että xy -lausekkeiden arvioinnin tuottamien arvojen on oltava binaariarvo, päivämäärä, päivämäärä/aika, päivämäärä/aikavyöhyke, kesto, looginen, luku, tyhjäarvo, teksti tai aika-arvo. Muussa tapauksessa esiin tulee virhe, joka sisältää syykoodin "Expression.Error" .

  • Molempien operandien on oltava samaa arvoa tai null. Muussa tapauksessa esiin tulee virhe, joka sisältää syykoodin "Expression.Error" .

  • Jos jompikumpi tai molemmat operandeista ovat null, tulos on null arvo.

  • Kahta binaaria verrataan tavutavuun.

  • Kahta päivämäärää verrataan niiden vuosiosiin, ja jos ne ovat yhtä suuret, niiden kuukausiosiin, ja jos ne ovat yhtä suuret, niiden päiväosiin.

  • Kahta päivämäärä/aikaosaa verrataan niiden vuosiosiin, ja jos ne ovat yhtä suuret, niiden kuukausiosiin, ja jos ne ovat yhtä suuret, niiden päiväosiin, ja jos ne ovat yhtä suuret, niiden tuntiosiin, ja jos ne ovat yhtä suuret, niiden minuutteihin, ja jos ne ovat yhtä suuret, niiden toiseen osaan.

  • Kahta päivämäärä/aikavyöhykearvoa verrataan normalisoimalla ne UTC-aikaan vähentämällä tunti/minuutti-siirtymä ja vertaamalla sitten niiden päivämäärä/aika-osiin.

  • Kahta kestoa verrataan niiden edustamien 100 nanosekunnin jaksojen kokonaismäärään.

  • Kahta loogista kohdetta verrataan siten, että true niitä pidetään suurempina kuin false.

  • Kahta lukua x ja y verrataan IEEE 754 -standardin sääntöjen mukaisesti:

    • Jos jompikumpi operandeista on #nan, tulos on false kaikille relaatio-operaattoreille.

    • Jos kumpikaan operandi ei ole #nan, operaattorit vertaavat kahden liukulukujen operandin arvoja järjestykseen -∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞ , jossa minimi ja maksimi ovat pienimmät ja suurimmat positiiviset finiittiset arvot, jotka voidaan esittää. -∞- ja +∞ M-nimet ovat -#infinity ja #infinity.

      Tämän järjestyksen merkittävät vaikutukset ovat seuraavat:

      • Negatiivisia ja positiivisia nollia pidetään samanarvoisina.

      • Arvoa -#infinity pidetään pienempinä kuin kaikkia muita lukuarvoja, mutta se on yhtä suuri kuin toinen -#infinity.

      • Arvoa #infinity pidetään suurempaa kuin kaikkia muita lukuarvoja, mutta se on yhtä suuri kuin toinen #infinity.

  • Kahta tekstiä verrataan käyttämällä merkkikohtaista muokkausta, kirjainkoko on merkitsevä, kulttuurista riippumattoman vertailun avulla.

  • Kahta aikaa verrataan niiden tuntiosiin, ja jos ne ovat yhtä suuret, niiden minuuttiosiin, ja jos ne ovat yhtä suuret, niiden sekuntiosiin.

Ehdolliset loogiset operaattorit

- ja and -oroperaattoreita kutsutaan ehdollisista loogisiksi operaattoreiksi.

logical-or-expression:
      logical-and-expression
logical-and-expression
orlogical-or-expression
logical-and-expression:
      is-expression
      is-expression
andlogical-and-expression

- or operaattori palauttaa true , kun vähintään yksi sen operandeista on true. Oikea operandi arvioidaan jos ja vain jos vasen operandi ei trueole .

- and operaattori palauttaa false , kun vähintään yksi sen operandeista on false. Oikea operandi arvioidaan jos ja vain jos vasen operandi ei falseole .

-ja or -andoperaattoreiden totuustaulukot näkyvät alla, kun vasemman operandilausekkeen arvioidaan olevan pystyakselilla ja oikean operandinlausekkeen vaaka-akselilla.

and true false null error
true true false null error
false false false false false
null null false null error
error error error error error
or true false null error
or true false null error
true true true true true
false true false null error
null true null null error
error error error error error

Seuraava pätee arvioitaessa lauseketta, joka sisältää ehdollisia loogisia operaattoreita:

  • tai x -ylausekkeiden arvioinnissa esiin tuodut virheet välitetään.

  • Ehdolliset loogiset operaattorit on määritetty tyyppien logical ja nullmukaan. Jos operandin arvot eivät ole näitä tyyppejä, esiin tulee virhe, joka sisältää syykoodin "Expression.Error" .

  • Tulos on looginen arvo.

  • Lausekkeessa x tai ylauseke y arvioidaan, jos ja vain jos x ei vertaudu kohteeseen true.

  • Lausekkeessa x ja ylauseke y arvioidaan, jos ja vain jos x ei vertaudu kohteeseen false.

Viimeiset kaksi ominaisuutta antavat ehdollisen loogisen operaattorin ehdollisen pätevyyden. ominaisuuksien lisäksi kutsutaan oikosulkuksi. Nämä ominaisuudet ovat hyödyllisiä, kun kirjoitetaan pienikokoisia valvottuja predikaatteja. Esimerkiksi seuraavat lausekkeet vastaavat toisiaan:

d <> 0 and n/d > 1 if d <> 0 then n/d > 1 else false

Aritmeettiset operaattorit

Operaattorit - +, -- * ja / ovat aritmeettisia operaattoreita.

additive-expression:
      multiplicative-expression
      additive-expression
+multiplicative-expression
      additive-expression
-multiplicative-expression
multiplicative-expression:
      metadata- expression
      multiplicative-expression
*metadata-expression
      multiplicative-expression
/metadata-expression

Tarkkuus

M-luvut tallennetaan käyttäen erilaisia esityksiä, joiden avulla säilytetään mahdollisimman paljon tietoja useista eri lähteistä peräisin olevista luvuista. Luvut muunnetaan vain yhdestä esityksestä toiseen, kun niitä käytetään. M tukee kahta tarkennuksia:

Tarkkuus Semantiikka
Precision.Decimal 128-bittinen desimaaliesitys alueella ±1,0 x 10-28 – ±7,9 x 1028 ja 28–29 merkitseviä numeroita.
Precision.Double Tieteellinen edustus käyttäen mantissaa ja eksponenttia; noudattaa 64-bittistä binaarista kaksitarkkuutta aritmeettista IEEE 754-standardia IEEE 754-2008.

Aritmeettisia toimintoja suoritetaan valitsemalla tarkkuus, muuntamalla molemmat operandit kyseiseen tarkkuuteen (tarvittaessa), suorittamalla sitten todellinen toiminto ja palauttamalla luku valitulla tarkkuudella.

Sisäiset aritmeettiset operaattorit (+, -, *, /) käyttävät kaksinkertaista tarkkuutta. Vakiokirjastofunktioita (Value.Add, Value.Subtract, Value.Multiply, Value.Divide) voidaan käyttää pyytämään näitä toimintoja käyttäen tiettyä tarkkuusmallia.

  • Numeerinen ylivuoto ei ole mahdollinen: #infinity tai -#infinity edustaa arvoja, joiden suuruus on liian suuri esitettäväksi.

  • Numeerinen alivuoto ei ole mahdollinen: 0 ja -0 edustaa arvoja, joiden suuruus on liian pieni esitettäväksi.

  • IEEE 754 -erikoisarvoa #nan (NaN – ei numero) käytetään kattamaan aritmeettisesti virheelliset tapaukset, kuten nollan jakaminen nollalla.

  • Muunto desimaalista kaksinkertaiseen tarkkuuteen suoritetaan pyöristämällä desimaalit lähimpään kaksinkertaiseen arvoon.

  • Muunto kaksinkertaisten desimaalien tarkkuudella suoritetaan pyöristämällä kaksinkertaiset luvut lähimpään vastaavaan desimaaliarvoon ja tarvittaessa tai #infinity arvoihin-#infinity.

Lisäämisoperaattori

Lisäämisoperaattorin (x + y) tulkinta on riippuvainen arvioitujen lausekkeiden x ja y:n arvosta seuraavasti:

x y Result Tulkinta
type number type number type number Numeerinen summa
type number null null
null type number null
type duration type duration type duration Suuruuden numeerinen summa
type duration null null
null type duration null
type päivämäärä ja aika type duration type päivämäärä ja aika Datetime-siirtymä keston mukaan
type duration type päivämäärä ja aika type päivämäärä ja aika
type päivämäärä ja aika null null
null type päivämäärä ja aika null

Datetime tarkoittaa taulukossa typetype time Kun lisätään kestoa ja jonkin tyyppistä datetime-arvoa, tulokseksi saatavan arvon tyyppi on sama tyyppi.

Muissa kuin taulukossa luetelluissa arvoyhdistelmissä on virhe, jonka syykoodi "Expression.Error" on . Kukin yhdistelmä käsitellään seuraavissa osissa.

Operandin arvioinnissa esiin tuodut virheet välitetään.

Numeerinen summa

Kahden luvun summa lasketaan käyttämällä lisäämisoperaattoria joka tuottaa luvun.

Esimerkkejä:

1 + 1             // 2 
#nan + #infinity  // #nan

Lisäämisoperaattori + lukujen päällä käyttää kaksinkertaista tarkkuutta; vakiokirjastofunktiolla Value.Add voidaan määrittää desimaalien tarkkuutta. Seuraava pätee, kun lasketaan lukujen summaa:

  • Summa kaksoistarkkuudella lasketaan 64-bittisen binaari doubleprecision IEEE 754 -aritmeettisen IEEE 754-2008:n sääntöjen mukaisesti. Seuraavassa taulukossa on luettelo kaikista mahdollisista yhdistelmista muista kuin nolla-arvoista rajattomaan arvoon, nolliin, äärettömiin ja NaN-arvoihin. Taulukossa , x ja y ovat ei-nollalukuja, ja z on :n x + ytulos. Jos x ja y on samaa suuruusluokkaa mutta vastakkaiset etumerkillä, z on positiivinen nolla. Jos x + y on liian suuri esitettäväksi kohdetyypissä, on ääretön, z jonka merkki on sama kuin x + y.

    + y +0 0- +∞ -∞ NaN
    x z x x +∞ -∞ NaN
    +0 y +0 +0 +∞ -∞ NaN
    -0 y +0 0- +∞ -∞ NaN
    +∞ +∞ +∞ +∞ +∞ NaN NaN
    -∞ -∞ -∞ -∞ NaN -∞ NaN
    Nan NaN NaN NaN NaN NaN NaN
  • Desimaalien tarkkuudella laskettu summa lasketaan menettämättä tarkkuutta. Tuloksen asteikko on kahden operandin asteikosta suurempi.

Kestojen summa

Kahden keston summa on kesto, joka edustaa niiden keston edustamien 100 pisteen jaksojen määrää. Esimerkkejä:

#duration(2,1,0,15.1) + #duration(0,1,30,45.3) 
// #duration(2, 2, 31, 0.4)

Datetime-siirtymä keston mukaan

DateTimey. Tässä datetime tarkoittaa mitä tahansa seuraavista: Date, DateTime, DateTimeZonetai Time , ja muu kuin tyhjäarvoinen tulos on samaa tyyppiä. Datetime-siirtymä kesto voidaan laskea seuraavasti:

  • Jos datetime-arvon päivämäärän jälkeen on määritetty aika-arvo, muodosta uusi datetime-arvo seuraavilla tietoelementeillä:

    • Laske uudet päivät aikakaudesta, joka vastaa y:n suuruuden jakaminen 100 nanosekunnin jaksojen määrällä 24 tunnin jaksossa, tuloksen desimaaliosan katkaiseminen ja tämän arvon lisääminen x-päiviin aikakaudesta lähtien.

    • Laske uusi jakso keskiyöstä lähtien, mikä vastaa y:n suuruuden lisäämistä x:n jaksoon keskiyön jälkeen ja moduloi 100 nanosekunnin jaksojen määrä 24 tunnin aikana. Jos x ei määritä jaksojen arvoa keskiyöstä alkaen, oletetaan, että arvo on 0.

    • Kopioi x:n arvo minuuttisiirtymalle UTC-arvosta muuttumattomana.

  • Jos datetime-arvon päivämäärän jälkeen ei ole määritetty aika-arvo, muodosta uusi datetime-arvo määritetyillä tietoelementeillä:

    • Laske uusi jakso keskiyöstä lähtien, mikä vastaa y:n suuruuden lisäämistä x:n jaksoon keskiyön jälkeen ja moduloi 100 nanosekunnin jaksojen määrä 24 tunnin aikana. Jos x ei määritä jaksojen arvoa keskiyöstä alkaen, oletetaan, että arvo on 0.

    • Kopioi x:n arvot aikakaudesta alkaen, koska aikakausi ja minuutit ovat muuttuneet UTC-arvosta.

Seuraavissa esimerkeissä näytetään absoluuttisen ajallisen summan laskeminen, kun datetime määrittää päiviä kauden jälkeen:

#date(2010,05,20) + #duration(0,8,0,0) 
    //#datetime( 2010, 5, 20, 8, 0, 0 ) 
    //2010-05-20T08:00:00 
 
#date(2010,01,31) + #duration(30,08,0,0) 
    //#datetime(2010, 3, 2, 8, 0, 0) 
    //2010-03-02T08:00:00 
 
#datetime(2010,05,20,12,00,00,-08) + #duration(0,04,30,00) 
    //#datetime(2010, 5, 20, 16, 30, 0, -8, 0) 
    //2010-05-20T16:30:00-08:00 
 
#datetime(2010,10,10,0,0,0,0) + #duration(1,0,0,0) 
   //#datetime(2010, 10, 11, 0, 0, 0, 0, 0) 
   //2010-10-11T00:00:00+00:00

Seuraavassa esimerkissä näytetään datetime-poikkeaman laskeminen keston mukaan tiettynä ajankohtana:

#time(8,0,0) + #duration(30,5,0,0) 
   //#time(13, 0, 0) 
   //13:00:00

Vähennyslaskuoperaattori

Vähennysoperaattorin (x - y) tulkinta on riippuvainen arvioitujen lausekkeiden x arvon tyypistä ja yseuraavasti:

x Y Result Tulkinta
type number type number type number Numeerinen ero
type number null null
null type number null
type duration type duration type duration Suuruuden numeerinen ero
type duration null null
null type duration null
type päivämäärä ja aika type päivämäärä ja aika type duration Datetimes-ajan välinen kesto
type päivämäärä ja aika type duration type päivämäärä ja aika Datetime-siirtymä negatiivisen keston mukaan
type päivämäärä ja aika null null
null type päivämäärä ja aika null

Datetime tarkoittaa taulukossa typetype time Kun vähennetään kestoa joistakin datetime-arvon tyypeistä, tulokseksi saatavan arvon tyyppi on sama tyyppi.

Muissa kuin taulukossa luetelluissa arvoyhdistelmissä on virhe, jonka syykoodi "Expression.Error" on . Kukin yhdistelmä käsitellään seuraavissa osissa.

Operandin arvioinnissa esiin tuodut virheet välitetään.

Numeerinen ero

Kahden luvun ero lasketaan käyttämällä vähennysoperaattoria joka tuottaa luvun. Esimerkkejä:

1 - 1                // 0 
#nan - #infinity     // #nan

Vähennysoperaattori - lukujen päällä käyttää kaksinkertaista tarkkuutta; vakiokirjastofunktiolla Value.Subtract voidaan määrittää desimaalien tarkkuutta. Seuraava pätee, kun lasketaan lukujen eroa:

  • Erotus kaksoistarkkuudella lasketaan 64-bittisen binaari double-precision IEEE 754 -aritmeettisen IEEE 754-2008:n sääntöjen mukaisesti. Seuraavassa taulukossa on luettelo kaikista mahdollisista yhdistelmista muista kuin nolla-arvoista rajattomaan arvoon, nolliin, äärettömiin ja NaN-arvoihin. Taulukossa , x ja y ovat ei-nollalukuja, ja z on :n x - ytulos. Jos x ja y ovat yhtä suuret, z on positiivinen nolla. Jos x - y on liian suuri esitettäväksi kohdetyypissä, on ääretön, z jonka merkki on sama kuin x - y.

    - y +0 0- +∞ -∞ NaN
    x z x x -∞ +∞ NaN
    +0 -y +0 +0 -∞ +∞ NaN
    -0 -y 0- +0 -∞ +∞ NaN
    +∞ +∞ +∞ +∞ NaN +∞ NaN
    -∞ -∞ -∞ -∞ -∞ NaN NaN
    Nan NaN NaN NaN NaN NaN NaN
  • Erotus desimaalien tarkkuudella lasketaan menettämättä tarkkuutta. Tuloksen asteikko on kahden operandin asteikosta suurempi.

Kestojen ero

Kahden keston ero on kesto, joka edustaa niiden keston edustamien 100 nanosekunnin jaksojen määrää. Esimerkkejä:

#duration(1,2,30,0) - #duration(0,0,0,30.45) 
// #duration(1, 2, 29, 29.55)

Datetime-siirtymä negatiivisen keston mukaan

x ja kesto y voidaan vähentää käyttämällä x - y uuden datetime-arvon laskemiseen. Tässä datetime tarkoittaa mitä tahansa arvoa date, datetime, datetimezonetai time. Tulokseksi saatava datetime-arvo on etäisyys x lineaarisella aikajanalla, joka on täsmälleen y, etumerkin vastakkaiseen ysuuntaan. Positiivisten kestojen vähentäminen tuottaa tuloksia, jotka ovat taaksepäin suhteessa arvoon x, ja negatiivisten arvojen vähentäminen tuottaa tuloksia, jotka ovat eteenpäin ajassa.

#date(2010,05,20) - #duration(00,08,00,00) 
   //#datetime(2010, 5, 19, 16, 0, 0) 
   //2010-05-19T16:00:00 
#date(2010,01,31) - #duration( 30,08,00,00) 
   //#datetime(2009, 12, 31, 16, 0, 0) 
   //2009-12-31T16:00:00

Kahden päivämäärän ja ajan välinen kesto

Kaksi datetimes-arvoat ja u voidaan vähentää käyttämällä t - u niiden keston laskemiseen. Tässä datetime tarkoittaa mitä tahansa arvoa date, datetime, datetimezonetai time. Kesto saadaan aikaan vähentämällä u arvosta t ja sen on tuotettava , t kun ne lisätään arvoon u.

#date(2010,01,31) - #date(2010,01,15) 
// #duration(16,00,00,00) 
// 16.00:00:00 
 
#date(2010,01,15)- #date(2010,01,31) 
// #duration(-16,00,00,00) 
// -16.00:00:00 
 
#datetime(2010,05,20,16,06,00,-08,00) - 
#datetime(2008,12,15,04,19,19,03,00) 
// #duration(521,22,46,41)
// 521.22:46:41

t - u Vähennetään, kun u > t tulokset ovat kestonsa suhteen negatiivisia:

#time(01,30,00) - #time(08,00,00) 
// #duration(0, -6, -30, 0)

Seuraava pätee, kun vähennetään kaksi datetimes-arvoa käyttämällä t - u:

  • u + (t - u) = t

Kertolaskuoperaattori

Kertolaskuoperaattorin (x * y) tulkinta on riippuvainen arvioitujen lausekkeiden x ja y:n arvosta seuraavasti:

X Y Result Tulkinta
type number type number type number Numeerinen tuote
type number null null
null type number null
type duration type number type duration Keston kerrannainen
type number type duration type duration Keston kerrannainen
type duration null null
null type duration null

Muissa kuin taulukossa luetelluissa arvoyhdistelmissä on virhe, jonka syykoodi "Expression.Error" on . Kukin yhdistelmä käsitellään seuraavissa osissa.

Operandin arvioinnissa esiin tuodut virheet välitetään.

Numeerinen tuote

Kahden luvun tulos lasketaan käyttämällä kertolaskuoperaattoria joka tuottaa luvun. Esimerkkejä:

2 * 4                // 8 
6 * null             // null 
#nan * #infinity     // #nan

Kertolaskuoperaattori * lukujen päällä käyttää kaksinkertaista tarkkuutta; vakiokirjastofunktiolla Value.Multiply voidaan määrittää desimaalien tarkkuutta. Seuraava pätee, kun lasketaan lukujen tulosta:

  • Tuote kaksoistarkkuudella lasketaan 64-bittisen binaari double-tarkkuuden aritmeettisen IEEE 754-tarkkuuden IEEE 754-2008 sääntöjen mukaisesti. Seuraavassa taulukossa on luettelo kaikista mahdollisista yhdistelmista muista kuin nolla-arvoista rajattomaan arvoon, nolliin, äärettömiin ja NaN-arvoihin. Taulukossa ja xy on positiivisia rajallisia arvoja. z on :n x * ytulos. Jos tulos on liian suuri kohdetyypille, z on ääretön. Jos tulos on liian pieni kohdetyypille, z on nolla.

    * +y -y +0 0- +∞ -∞ NaN
    +x +z –z +0 0- +∞ -∞ NaN
    -x –z +z 0- +0 -∞ +∞ NaN
    +0 +0 0- +0 0- NaN NaN NaN
    -0 0- +0 0- +0 NaN NaN NaN
    +∞ +∞ -∞ NaN NaN +∞ -∞ NaN
    -∞ -∞ +∞ NaN NaN -∞ +∞ NaN
    Nan NaN NaN NaN NaN NaN NaN NaN
  • Tuote desimaalien tarkkuudella lasketaan menettämättä tarkkuutta. Tuloksen asteikko on kahden operandin asteikosta suurempi.

Kestojen kerrannaiset

Keston ja luvun tulos on kesto, joka edustaa 100 sarakkeen jaksojen määrää, jota edustaa keston operandi ja numeron operandi. Esimerkkejä:

#duration(2,1,0,15.1) * 2 
// #duration(4, 2, 0, 30.2)

Jako-operaattori

Jako-operaattorin (x / y) tulkinta on riippuvainen arvioitujen lausekkeiden x arvon lajista ja yseuraavasti:

X Y Result Tulkinta
type number type number type number Numeerinen osamäärä
type number null null
null type number null
type duration type number type duration Keston murtoluku
type duration type duration type number Kestojen numeerinen osamäärä
type duration null null
null type duration null

Muissa kuin taulukossa luetelluissa arvoyhdistelmissä on virhe, jonka syykoodi "Expression.Error" on . Kukin yhdistelmä käsitellään seuraavissa osissa.

Operandin arvioinnissa esiin tuodut virheet välitetään.

Numeerinen osamäärä

Kahden luvun osamäärä lasketaan käyttämällä jako-operaattoria joka tuottaa luvun. Esimerkkejä:

8 / 2               // 4 
8 / 0               // #infinity 
0 / 0               // #nan 
0 / null            // null 
#nan / #infinity    // #nan

Jako-operaattori / lukujen päällä käyttää kaksinkertaista tarkkuutta; vakiokirjastofunktiolla Value.Divide voidaan määrittää desimaalien tarkkuutta. Seuraava pätee, kun lasketaan lukujen osamäärä:

  • Osamäärä kaksoistarkkuudella lasketaan 64-bittisen binaari double-tarkkuuden aritmeettisen IEEE 754-tarkkuuden IEEE 754-2008mukaisesti. Seuraavassa taulukossa on luettelo kaikista mahdollisista yhdistelmista muista kuin nolla-arvoista rajattomaan arvoon, nolliin, äärettömiin ja NaN-arvoihin. Taulukossa ja xy on positiivisia rajallisia arvoja. z on :n x / ytulos. Jos tulos on liian suuri kohdetyypille, z on ääretön. Jos tulos on liian pieni kohdetyypille, z on nolla.

    / +y -y +0 0- +∞ -∞ NaN
    +x +z –z +∞ -∞ +0 0- NaN
    -x –z +z -∞ +∞ 0- +0 NaN
    +0 +0 0- NaN NaN +0 0- NaN
    -0 0- +0 NaN NaN 0- +0 NaN
    +∞ +∞ -∞ +∞ -∞ NaN NaN NaN
    -∞ -∞ +∞ -∞ +∞ NaN NaN NaN
    Nan NaN NaN NaN NaN NaN NaN NaN
  • Desimaalien tarkkuudella laskettu summa lasketaan menettämättä tarkkuutta. Tuloksen asteikko on kahden operandin asteikosta suurempi.

Kestojen osamäärä

Kahden keston osamäärä on numero, joka edustaa niiden keston edustamien 100 nanosecond-jaksojen lukumäärän osamäärää. Esimerkkejä:

#duration(2,0,0,0) / #duration(0,1,30,0) 
// 32

Skaalatut kestot

Keston ja lukumäärän xy osamäärä on kesto, joka edustaa 100 nanosekunnin jaksojen lukumäärän osamäärää, joita edustavat kesto x ja lukumäärä y. Esimerkkejä:

#duration(2,0,0,0) / 32 
// #duration(0,1,30,0)

Rakenneyhdistelmä

Yhdistelmäoperaattori (x & y) on määritetty seuraaville arvotyypeille:

X Y Result Tulkinta
type text type text type text Ketjutus
type text null null
null type text null
type date type time type datetime Yhdistä
type date null null
null type time null
type list type list type list Ketjutus
type record type record type record Yhdistä
type table type table type table Ketjutus

Ketjutus

Kaksi tekstiä, kaksi luetteloa tai kaksi taulukon arvoa voidaan yhdistää :n avulla x & y.

Seuraavassa esimerkissä havainnollistetaan tekstiarvojen ketjutus:

"AB" & "CDE"     // "ABCDE"

Seuraavassa esimerkissä havainnollistetaan luetteloiden ketjutus:

{1, 2} & {3}     // {1, 2, 3}

Seuraava pätee, kun kahta arvoa ketjutettaessa käytetään x & y:

  • tai x -ylausekkeiden arvioinnissa esiin tuodut virheet välitetään.

  • Virhettä ei välitetä, jos joko x tai y sisältää virheen.

  • Kahden tekstiarvon ketjutuksen tulos on tekstiarvo, joka sisältää x-arvon välittömästi ja sen jälkeen y. Jos jompikumpi operandeista on tyhjäarvo ja toinen on tekstiarvo, tulos on tyhjäarvo.

  • Kahden luettelon ketjutuksen tuloksena on luettelo, joka sisältää kaikki kohteet x , joita seuraavat kaikki kohteet y.

  • Kahden taulukon ketjutuksen tuloksena on taulukko, jossa on kahden operanditaulukon sarakkeet. Sarakkeiden järjestys x säilyy, minkä jälkeen sarakkeet näkyvät yvain , säilyttäen suhteellisen järjestyksensä. Vain yhdessä operandissa null esiintyvissä sarakkeissa käytetään toisen operandin soluarvojen täyttämiseen.

Yhdistä

Tietueen yhdistäminen

Voit yhdistää kaksi tietuetta tuottamalla x & ytietueen, joka sisältää kentät ja xy.

Seuraavissa esimerkeissä havainnollistetaan tietueiden yhdistäminen:

[ x = 1 ] & [ y = 2 ]                // [ x = 1, y = 2 ] 
[ x = 1, y = 2 ] & [ x = 3, z = 4 ]  // [ x = 3, y = 2, z = 4 ]

Seuraava pätee, kun kahta tietuetta yhdistetään :n avulla x + y:

  • tai x -ylausekkeiden arvioinnissa esiin tuodut virheet välitetään.

  • Jos kenttä näkyy sekä kohdassa että xy, käytetään arvoa y .

  • Tuloksena saatavan tietueen kenttien järjestys on x, jota seuraavat kentät y , jotka eivät ole :n osa xsamassa järjestyksessä kuin ne näkyvät kohteessa y.

  • Tietueiden yhdistäminen ei aiheuta arvojen arviointia.

  • Virhettä ei ole annettu, koska kenttä sisältää virheen.

  • Tulos on tietue.

Päivämäärän ja ajan yhdistäminen

Päivämäärä x voidaan yhdistää aikaan y käyttämällä , x & ytuottamalla datetime-ajan, joka yhdistää sekä että -osat xy.

Seuraavassa esimerkissä havainnollistetaan päivämäärän ja kellonajan yhdistäminen:

#date(2013,02,26) & #time(09,17,00) 
// #datetime(2013,02,26,09,17,00)

Seuraava pätee, kun kahta tietuetta yhdistetään :n avulla x + y:

  • tai x -ylausekkeiden arvioinnissa esiin tuodut virheet välitetään.

  • Tuloksena on päivämäärä/aika.

Unaarioperaattorit

-, +- ja - -notoperaattorit ovat yksiarvoisia operaattoreita.

unary-expression:
      type-expression

       + yksiarvoinen lauseke
       - yksiarvoinen lauseke
       not yksiarvoinen lauseke

Yksiarvoinen plus-lauseke

Yksiarvoinen plus-lauseke (+x) on määritetty seuraaville arvotyypeille:

X Result Tulkinta
type number type number Yksiarvoinen plus
type duration type duration Yksiarvoinen plus
null 'tyhjäarvo

Muissa arvoissa esiin tulee virhe, joka sisältää syykoodin "Expression.Error" .

Yksiparametrinen plus-operaattori sallii + merkin käyttöön luku-, datetime- tai null-arvolle. Tulos on sama arvo. Esimerkkejä:

+ - 1                 // -1 
+ + 1                 // 1 
+ #nan                // #nan 
+ #duration(0,1,30,0) // #duration(0,1,30,0)

Seuraava pätee, kun arvioidaan yksiarvoista plus-lauseketta +x:

  • Arvioinnissa x esiin tuodut virheet välitetään.

  • Jos arvioinnin x tulos ei ole lukuarvo, esiin tulee virhe, joka sisältää syykoodin "Expression.Error" .

Yksiparametrinen miinus-operaattori

Yksiarvoinen miinus-lauseke (-x) on määritetty seuraaville arvotyypeille:

X Result Tulkinta
type number type number Negaatio
type duration type duration Negaatio
null null

Muissa arvoissa esiin tulee virhe, joka sisältää syykoodin "Expression.Error" .

Yksiparametrisen miinusoperaattorin avulla muutetaan luvun tai keston merkkiä. Esimerkkejä:

- (1 + 1)       // -2 
- - 1           // 1 
- - - 1         // -1 
- #nan          // #nan 
- #infinity     // -#infinity 
- #duration(1,0,0,0)  // #duration(-1,0,0,0) 
- #duration(0,1,30,0) // #duration(0,-1,-30,0)

Seuraava pätee, kun arvioidaan yksiarvoista miinus-lauseketta -x:

  • Arvioinnissa x esiin tuodut virheet välitetään.

  • Jos lauseke on luku, tulos on lausekkeen x lukuarvo, jonka etumerkki on muuttunut. Jos arvo on NaN, tulos on myös NaN.

Looginen negaatio-operaattori

Looginen negaatio-operaattori (not) on määritetty seuraaville arvotyypeille:

X Result Tulkinta
type logical type logical Negaatio
null null

Tämä operaattori laskee loogisen not toiminnon annetulle loogisille arvoille. Esimerkkejä:

not true             // false 
not false            // true 
not (true and true)  // false

Seuraava pätee, kun arvioidaan loogista negaatio-operaattoria not x:

  • Arvioinnissa x esiin tuodut virheet välitetään.

  • Lausekkeen x avulla tuotetun arvon on oltava looginen arvo, tai syntyy virhe, jonka syykoodi "Expression.Error" on . Jos arvo on true, tulos on false. Jos operandi on false, tulos on true.

Tulos on looginen arvo.

Tyyppioperaattorit

Operaattoreita is ja as kutsutaan tyyppioperaattoreiksi.

Tyypin yhteensopivuusoperaattori

Tyypin yhteensopivuusoperaattori x is y on määritetty seuraaville arvotyypeille:

X Y Result
type any nullable-primitive-type type logical

Lauseke x is y palauttaa true , jos määritetty tyyppi on yhteensopiva :n x kanssa y, ja palauttaa false , jos määritetty tyyppi ei ole yhteensopiva :n x kanssa y. y pitää olla nullable-primitivetype.

is-expression:
      as-expression
      is-expression
isnullable-primitive-type
nullable-primitive-type:

       nullable opt primitive-type

Tyypin yhteensopivuus, jota is -operaattori tukee, on yleisen tyypin yhteensopivuuden alijoukko, ja se on määritetty seuraavien sääntöjen avulla:

  • Jos x on tyhjäarvoinen, se on yhteensopiva, jos y on tyyppiä any, tyyppiä nulltai tyhjäarvoja sallivaa tyyppiä.

  • Jos x on muu kuin tyhjäarvo, jos se on yhteensopiva, jos primitiivityyppi x on sama kuin y.

Seuraava pätee, kun arvioidaan lauseketta x is y:

  • Lausekkeen x arvioinnissa esiin tuotu virhe välitetään.

Tyypin vahvistusoperaattori

Tyypin vahvistusoperaattori x as y on määritetty seuraaville arvotyypeille:

X Y Result
type any nullable-primitive-type type any

Lauseke x as y väittää, että arvo x on yhteensopiva -operaattorin y kanssais. Jos se ei ole yhteensopiva, esiin tulee virhe. y pitää olla nullable-primitive-type.

as-expression:
      equality-expression
      as-expression
asnullable-primitive-type

Lauseke x as y arvioidaan seuraavasti:

  • Tyypin yhteensopivuuden tarkistus x is y suoritetaan, ja vahvistus palauttaa x muuttumattomana, jos testi onnistuu.

  • Jos yhteensopivuuden tarkistus epäonnistuu, esiin tulee virhe, joka sisältää syykoodin "Expression.Error" .

Esimerkkejä:

1 as number               // 1 
"A" as number             // error 
null as nullable number   // null

Seuraava pätee, kun arvioidaan lauseketta x as y:

  • Lausekkeen x arvioinnissa esiin tuotu virhe välitetään.

Coalesce-operaattori

Coalesce-operaattori ?? palauttaa vasemman operandin tuloksen, jos se ei ole tyhjäarvo, muuten se palauttaa oikean operandin tuloksen. Oikea operandi arvioidaan, jos ja vain jos vasen operandi on tyhjäarvo.