Operaattorin toiminta
Tässä osiossa määritetään eri M-operaattoreiden toiminta.
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 |
xmeta y |
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 |
xas y |
On yhteensopiva nullable-primitive-tyyppi tai virhe |
Tyypin vastaavuus |
xis y |
Testaa, onko yhteensopiva nullable-primitive-tyypin kanssa |
Looginen JA |
xand y |
Oikosulukonjunktio |
Looginen TAI |
xor y |
Oikosulun erottaminen |
Coalesce |
x?? y |
Tyhjäarvoinen hiilitysoperaattori |
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.
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 sallivat tietojen poimimisen luettelo- ja tietuearvoista.
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 lukuay
varten luettelokohdex
sijainnissay
. Luettelon ensimmäisen kohteen koordinaattorin koordinaattoriarvo on nolla. Jos pyydettyä sijaintia ei ole luettelossa, esiin tulee virhe.Taulukolle
x
ja luvulley
taulukonx
rivi sijainnissay
. Taulukon ensimmäisen rivin koordinaattoriindeksi on nolla. Jos pyydettyä sijaintia ei ole taulukossa, esiin tulee virhe.Taulukolle
x
ja tietueelley
taulukonx
rivi, joka vastaa tietueeny
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 y
on 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
x
y
virheet välitetään.Lauseke
x
tuottaa luettelon tai taulukon arvon.Lauseke
y
tuottaa lukuarvon tai josx
tuottaa taulukkoarvon, se tuottaa tietuearvon.Jos
y
tuottaa lukuarvon ja -arvoy
on negatiivinen, annetaan syykoodin"Expression.Error"
sisältävä virhe.Jos
y
tuottaa lukuarvon ja -arvoy
on suurempi tai yhtä suuri kuin -x
määrä, virhe ja syykoodi"Expression.Error"
annetaan, ellei valinnaista operaattorilomakettax{y}?
käytetä, jolloin palautetaan arvonull
.Jos
x
tuottaa taulukkoarvon jay
tuottaa tietuearvon eikä kohdassay
sisällä vastaavuuksiax
, annetaan virhe ja syykoodi"Expression.Error"
, ellei valinnaista operaattorilomakettax{y}?
käytetä, jolloin palautetaan arvonull
.Jos
x
tuottaa taulukkoarvon jay
tuottaa tietuearvon ja kohdassay
sisä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.)
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 , y1
y2
, ...
). Jos valittua kenttää ei ole, esiin tulee virhe. Operaattori x[[y1],[y2],...]?
projisoi tietueen uuteen tietueeseen käyttäen , ja valitsemia y1
y2
...
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ääny
, 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 kohteessax
, syykoodin"Expression.Error"
sisältävä virhe annetaan, ellei valinnaista operaattorilomaketta...?
käytetä, jolloin palautetaan arvonull
.
Kentän käyttöprosessin aikana ei arvioida mitään muuta kuin nimeämää x
kenttääy
.
Arvon metatietotietuetta muutetaan meta-operaattorin (x meta y
) avulla.
metadata-expression:
unary-expression
unary-expressionmeta
unary-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
-y
lausekkeiden 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
x
yhdistetty kohteeseeny
. (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ä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
-y
lausekkeiden arvioinnissa esiin tuodut virheet välitetään.operaattorilla
=
on tulostrue
, jos arvot ovat yhtä suuret, jafalse
muussa tapauksessa .operaattorilla
<>
on tulosfalse
, jos arvot ovat yhtä suuret, jatrue
muussa tapauksessa .Metatietotietueita ei sisällytetä vertailuun.
Jos - ja
x
-y
lausekkeiden avulla tuotetut arvot eivät ole samaa arvoa, arvot eivät ole yhtä suuret.Jos - ja
x
-lausekkeen tuottamaty
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
jafalse
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.
-, -, - 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 y kuin , false muuten |
x >= y |
true jos x on suurempi tai yhtä suuri y kuin , 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 arvioinnissay
esiin tuodut virheet välitetään.Sekä - että
x
y
-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 onnull
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 kuinfalse
.Kahta lukua
x
jay
verrataan IEEE 754 -standardin sääntöjen mukaisesti:Jos jompikumpi operandeista on
#nan
, tulos onfalse
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.
- ja and
-or
operaattoreita kutsutaan ehdollisista loogisiksi operaattoreiksi.
logical-or-expression:
logical-and-expression
logical-and-expressionor
logical-or-expression
logical-and-expression:
is-expression
is-expressionand
logical-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 true
ole .
- and
operaattori palauttaa false
, kun vähintään yksi sen operandeista on false
. Oikea operandi arvioidaan jos ja vain jos vasen operandi ei false
ole .
-ja or
-and
operaattoreiden 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
-y
lausekkeiden arvioinnissa esiin tuodut virheet välitetään.Ehdolliset loogiset operaattorit on määritetty tyyppien
logical
janull
mukaan. Jos operandin arvot eivät ole näitä tyyppejä, esiin tulee virhe, joka sisältää syykoodin"Expression.Error"
.Tulos on looginen arvo.
Lausekkeessa
x
taiy
lausekey
arvioidaan, jos ja vain josx
ei vertaudu kohteeseentrue
.Lausekkeessa
x
jay
lausekey
arvioidaan, jos ja vain josx
ei vertaudu kohteeseenfalse
.
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
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
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ää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 type
type 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.
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
jay
ovat ei-nollalukuja, jaz
on :nx + y
tulos. Josx
jay
on samaa suuruusluokkaa mutta vastakkaiset etumerkillä,z
on positiivinen nolla. Josx + y
on liian suuri esitettäväksi kohdetyypissä, on ääretön,z
jonka merkki on sama kuinx + 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.
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)
DateTimey
.
Tässä datetime tarkoittaa mitä tahansa seuraavista: Date
, DateTime
, DateTimeZone
tai 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ähennysoperaattorin (x - y
) tulkinta on riippuvainen arvioitujen lausekkeiden x
arvon tyypistä ja y
seuraavasti:
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 type
type 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.
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
jay
ovat ei-nollalukuja, jaz
on :nx - y
tulos. Josx
jay
ovat yhtä suuret,z
on positiivinen nolla. Josx - y
on liian suuri esitettäväksi kohdetyypissä, on ääretön,z
jonka merkki on sama kuinx - 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.
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)
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
, datetimezone
tai time
. Tulokseksi saatava datetime-arvo on etäisyys x
lineaarisella aikajanalla, joka on täsmälleen y
, etumerkin vastakkaiseen y
suuntaan. 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
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
, datetimezone
tai 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
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.
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
x
y
on positiivisia rajallisia arvoja.z
on :nx * y
tulos. 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.
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-operaattorin (x / y
) tulkinta on riippuvainen arvioitujen lausekkeiden x
arvon lajista ja y
seuraavasti:
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.
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
x
y
on positiivisia rajallisia arvoja.z
on :nx / y
tulos. 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.
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
Keston ja lukumäärän x
y
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)
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 |
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
-y
lausekkeiden arvioinnissa esiin tuodut virheet välitetään.Virhettä ei välitetä, jos joko
x
taiy
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 kohteety
.Kahden taulukon ketjutuksen tuloksena on taulukko, jossa on kahden operanditaulukon sarakkeet. Sarakkeiden järjestys
x
säilyy, minkä jälkeen sarakkeet näkyväty
vain , säilyttäen suhteellisen järjestyksensä. Vain yhdessä operandissanull
esiintyvissä sarakkeissa käytetään toisen operandin soluarvojen täyttämiseen.
Voit yhdistää kaksi tietuetta tuottamalla x & y
tietueen, joka sisältää kentät ja x
y
.
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
-y
lausekkeiden arvioinnissa esiin tuodut virheet välitetään.Jos kenttä näkyy sekä kohdassa että
x
y
, käytetään arvoay
.Tuloksena saatavan tietueen kenttien järjestys on
x
, jota seuraavat kentäty
, jotka eivät ole :n osax
samassa järjestyksessä kuin ne näkyvät kohteessay
.Tietueiden yhdistäminen ei aiheuta arvojen arviointia.
Virhettä ei ole annettu, koska kenttä sisältää virheen.
Tulos on tietue.
Päivämäärä x
voidaan yhdistää aikaan y
käyttämällä , x & y
tuottamalla datetime-ajan, joka yhdistää sekä että -osat x
y
.
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
-y
lausekkeiden arvioinnissa esiin tuodut virheet välitetään.Tuloksena on päivämäärä/aika.
-, +
- ja -
-not
operaattorit ovat yksiarvoisia operaattoreita.
unary-expression:
type-expression
+
yksiarvoinen lauseke
-
yksiarvoinen lauseke
not
yksiarvoinen 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"
.
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 (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 ontrue
, tulos onfalse
. Jos operandi onfalse
, tulos ontrue
.
Tulos on looginen arvo.
Operaattoreita is
ja as
kutsutaan tyyppioperaattoreiksi.
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-expressionis
nullable-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, josy
on tyyppiäany
, tyyppiänull
tai tyhjäarvoja sallivaa tyyppiä.Jos
x
on muu kuin tyhjäarvo, jos se on yhteensopiva, jos primitiivityyppix
on sama kuiny
.
Seuraava pätee, kun arvioidaan lauseketta x is y
:
- Lausekkeen
x
arvioinnissa esiin tuotu virhe välitetään.
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-expressionas
nullable-primitive-type
Lauseke x as y
arvioidaan seuraavasti:
Tyypin yhteensopivuuden tarkistus
x is y
suoritetaan, ja vahvistus palauttaax
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 ??
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.