Zachowanie operatora

Artykuł
07/31/2024

W tej sekcji zdefiniowano zachowanie różnych operatorów języka M.

Kolejność wykonywania działań

Gdy wyrażenie zawiera wiele operatorów, pierwszeństwo operatorów kontroluje kolejność oceniania poszczególnych operatorów. Na przykład wyrażenie x + y * z jest oceniane jako x + (y * z) , ponieważ * operator ma wyższy priorytet niż operator binarny + . Pierwszeństwo operatora jest ustanawiane przez definicję jego skojarzonej produkcji gramatycznej. Na przykład wyrażenie-addytywne składa się z sekwencji wyrażenia mnożenia rozdzielanego + operatorami lub - , dając operatorom + i - niższe pierwszeństwo niż * operatory i / .

Środowisko produkcyjne wyrażeń nawiasów może służyć do zmiany domyślnej kolejności pierwszeństwa.

wyrażenie-nawiasowe:
( wyrażenie )

Na przykład:

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

W poniższej tabeli podsumowano operatory języka M z listą kategorii operatorów w kolejności od najwyższego do najniższego. Operatory w tej samej kategorii mają równe pierwszeństwo.

Kategoria	Expression	opis
Podstawowe	i @i	Wyrażenie identyfikatora
	(x)	Wyrażenie nawiasowe
	x[i]	Lookup
	x{y}	Dostęp do elementów
	x(...)	Wywołanie funkcji
	{x, y, ...}	Inicjowanie listy
	[ i = x, ... ]	Inicjowanie rekordów
	...	Nie zaimplementowano
Jednoargumentowy	+x	Tożsamość
	-x	Negacja
	`not`x	Logiczna negacja
Metadane	x `meta` y	Kojarzenie metadanych
Multiplikatywne	x * y	Mnożenie
Multiplikatywne	x / y	Dział
Dodatek	x + y	Dodatek
Dodatek	x - y	Odejmowanie
Relacyjne	x < y	Mniejsze niż
	x > y	Większe niż
	x <= y	Mniejsze niż lub równe
	x >= y	Większe niż lub równe
Równość	x = y	Równe
Równość	x <> y	Not equal
Aseracja typu	x `as` y	Jest zgodnym typem pierwotnym dopuszczanym wartości null lub błędem
Zgodność typu	x `is` y	Testowanie, czy zgodny typ pierwotny dopuszczany do wartości null
AND logiczne	x `and` y	Połączenie zwarciem
OR logiczne	x `or` y	Odłączenie od obwodu
Coalesce	x `??` y	Operator łączenia wartości null

Operatory i metadane

Każda wartość ma skojarzona wartość rekordu, która może zawierać dodatkowe informacje o wartości. Ten rekord jest określany jako rekord metadanych dla wartości. Rekord metadanych może być skojarzony z dowolną wartością, nawet null. Wynikiem takiego skojarzenia jest nowa wartość z podanymi metadanymi.

Rekord metadanych jest zwykłym rekordem i może zawierać dowolne pola i wartości, które mogą zawierać zwykły rekord i sam zawiera rekord metadanych. Kojarzenie rekordu metadanych z wartością jest "nieinwazyjne". Nie zmienia ona zachowania wartości w ocenach z wyjątkiem tych, które jawnie sprawdzają rekordy metadanych.

Każda wartość ma domyślny rekord metadanych, nawet jeśli nie został określony. Domyślny rekord metadanych jest pusty. W poniższych przykładach pokazano uzyskiwanie dostępu do rekordu metadanych wartości tekstowej przy użyciu standardowej Value.Metadata funkcji biblioteki:

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

Rekordy metadanych zazwyczaj nie są zachowywane , gdy wartość jest używana z operatorem lub funkcją tworzącą nową wartość. Jeśli na przykład dwie wartości tekstowe są łączone przy użyciu & operatora, metadane wynikowej wartości tekstowej są pustym rekordem []. Następujące wyrażenia są równoważne:

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

Standardowe funkcje Value.RemoveMetadata biblioteki i Value.ReplaceMetadata mogą służyć do usuwania wszystkich metadanych z wartości i zastępowania metadanych wartości (zamiast scalania metadanych z prawdopodobnie istniejącymi metadanymi).

Jedynym operatorem, który zwraca wyniki przenoszące metadane, jest operator meta.

Operatory rekursywne ze strukturą

Wartości mogą być cykliczne. Na przykład:

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

Język M obsługuje cykliczne wartości, zachowując konstrukcję rekordów, list i tabel z opóźnieniem. Próba skonstruowania cyklicznej wartości, która nie korzysta z wtrąconych wartości ustrukturyzowanych z opóźnieniem, powoduje wystąpienie błędu:

[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"), 
// ]

Niektóre operatory w języku M są definiowane przez rekursję strukturalną. Na przykład równość rekordów i list jest definiowana przez połączone równości odpowiednich pól rekordów i list elementów odpowiednio.

W przypadku wartości niecyklicznych zastosowanie rekursji strukturalnej daje skończone rozszerzenie wartości: współużytkowane wartości zagnieżdżone będą wielokrotnie przechodzine, ale proces rekursji zawsze kończy się.

Wartość cykliczna ma nieskończone rozszerzenie podczas stosowania rekursji strukturalnej. Semantyka języka M nie sprawia, że specjalne zakwaterowanie dla takich nieskończonych rozszerzeń — próba porównania cyklicznych wartości równości, na przykład, zwykle zabraknie zasobów i zakończy się wyjątkowo.

Operatory wyboru i projekcji

Operatory wyboru i projekcji umożliwiają wyodrębnianie danych z listy i wartości rekordów.

Dostęp do elementów

Wartość można wybrać z listy lub tabeli na podstawie pozycji zero opartej na tej liście lub tabeli przy użyciu wyrażenia-dostępu do elementu.

wyrażenie-dostępu do elementu:
      wybór elementu
      wybór opcjonalnego elementu
wybór elementu:
      selektor elementów wyrażeń { podstawowych }
wybór opcjonalnego elementu:
      selektor elementów wyrażeń { podstawowych } ?
selektor elementów:
      wyrażenie

Wyrażenie-dostęp-do-elementu x{y} zwraca:

W przypadku listy x i liczby yelement listy x na pozycji y. Pierwszy element listy jest uznawany za indeks porządkowy zera. Jeśli żądana pozycja nie istnieje na liście, zostanie zgłoszony błąd.
W przypadku tabeli x i liczby ywiersz tabeli x w pozycji y. Pierwszy wiersz tabeli jest uznawany za indeks porządkowy o wartości zero. Jeśli żądana pozycja nie istnieje w tabeli, zostanie zgłoszony błąd.
W przypadku tabeli x i rekordu ywiersz tabeli x , który pasuje do wartości pól rekordu y dla pól z nazwami pól, które pasują do odpowiednich nazw kolumn tabeli. Jeśli w tabeli nie ma unikatowego pasującego wiersza, zostanie zgłoszony błąd.

Na przykład:

{"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

Wyrażenie-dostępu-elementu obsługuje również formularz x{y}?, który zwraca null wartość, gdy pozycja (lub dopasowanie) y nie istnieje na liście lub tabeli x. Jeśli istnieje wiele dopasowań dla yelementu , błąd jest nadal zgłaszany.

Na przykład:

{"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

Dostęp do elementu nie wymusza oceny elementów listy ani tabel innych niż dostęp do elementu. Na przykład:

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

Podczas oceniania operatora x{y} dostępu do elementu są przechowywane następujące zasady:

Błędy zgłaszane podczas obliczania wyrażeń x lub y są propagowane.
Wyrażenie x tworzy listę lub wartość tabeli.
Wyrażenie y generuje wartość liczbową lub, jeśli x generuje wartość tabeli, wartość rekordu.
Jeśli y generuje wartość liczbową, a wartość y jest ujemna, zostanie zgłoszony błąd z kodem "Expression.Error" przyczyny.
Jeśli y generuje wartość liczbową, a wartość y jest większa lub równa liczbie x, zostanie zgłoszony błąd z kodem "Expression.Error" przyczyny, chyba że zostanie użyty opcjonalny formularz x{y}? operatora, w takim przypadku zwracana jest wartość null .
Jeśli x generuje wartość tabeli i y generuje wartość rekordu i nie ma dopasowań dla y elementu w xpliku , zostanie zgłoszony błąd z kodem "Expression.Error" przyczyny, chyba że zostanie użyty opcjonalny formularz x{y}? operatora, w tym przypadku zwracana jest wartość null .
Jeśli x generuje wartość tabeli i y generuje wartość rekordu i istnieje wiele dopasowań dla y elementu w xpliku , zostanie zgłoszony błąd z kodem "Expression.Error" przyczyny.

Podczas procesu zaznaczenia elementu nie są oceniane żadne elementy innej x niż pozycja y . (W przypadku list lub tabel przesyłania strumieniowego elementy lub wiersze poprzedzające pozycję y są pomijane, co może spowodować ich ocenę w zależności od źródła listy lub tabeli).

Dostęp do pola

Wyrażenie-dostępu do pola służy do wybierania wartości z rekordu lub do projekcji rekordu lub tabeli do jednej z mniej pól lub kolumn, odpowiednio.

wyrażenie-dostępu do pola:
      wybór pola
      niejawne zaznaczenie pola docelowego
      projekcja
      niejawna projekcja docelowa
wybór pola:
      selektor pól wyrażenia podstawowego
selektor pól:
      selektor pola wymaganego
      opcjonalny selektor pól
selektor-wymagane pole:
      [ nazwa-pola ]
opcjonalny selektor pól:
      [ nazwa-pola ] ?
nazwa-pola:
      uogólniony identyfikator
      identyfikator cytowany
niejawne zaznaczenie pola docelowego:
      selektor pól
projekcja:
      wyrażenie-podstawowe wymagane-projekcja
      wyrażenie-podstawowe opcjonalne-projekcja
projekcja wymagana:
      [lista selektorów wymaganych ]
projekcja opcjonalna:
      [lista selektorów wymaganych ] ?
required-selector-list:
      selektor pola wymaganego
      selektor-wymagana lista-pól-selektor-pola ,
niejawna projekcja docelowa:
      projekcja wymagana
      projekcja opcjonalna

Najprostszą formą dostępu do pól jest wymagany wybór pola. Używa operatora x[y] do wyszukiwania pola w rekordzie według nazwy pola. Jeśli pole y nie istnieje w pliku x, zostanie zgłoszony błąd. Formularz x[y]? jest używany do wykonywania opcjonalnego zaznaczenia pola i zwraca, null jeśli żądane pole nie istnieje w rekordzie.

Na przykład:

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

Zbiorczy dostęp do wielu pól jest obsługiwany przez operatory dla wymaganych projekcji rekordów i opcjonalne projekcji rekordów. Operator x[[y1],[y2],...] projektuje rekord do nowego rekordu z mniejszą liczbą pól (wybranych przez y1, y2, ...). Jeśli wybrane pole nie istnieje, zostanie zgłoszony błąd. x[[y1],[y2],...] Operator projektuje rekord do nowego rekordu z polami wybranymi przez y1, y2, ...; jeśli brakuje pola, null jest używany zamiast tego. Na przykład:

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

Formularze [y] i [y]? są obsługiwane jako skrócone odwołanie do identyfikatora _ (podkreślenie). Następujące dwa wyrażenia są równoważne:

[A]                 
_[A]

Poniższy przykład ilustruje skróconą formę dostępu do pól:

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

Formularz [[y1],[y2],...] i [[y1],[y2],...]? są również obsługiwane jako skrót, a następujące dwa wyrażenia są podobnie równoważne:

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

Skrócona forma jest szczególnie przydatna w połączeniu each z skrótem, czyli sposobem wprowadzenia funkcji pojedynczego parametru o nazwie _ (aby uzyskać szczegółowe informacje, zobacz Uproszczone deklaracje). Razem te dwa skróty upraszczają typowe wyrażenia funkcjonalne o wyższej kolejności:

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

Powyższe wyrażenie jest równoważne następującemu bardziej tajemniczemu wyglądowi od dawna:

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

Dostęp do pola nie wymusza oceny pól innych niż te, do których uzyskuje się dostęp. Na przykład:

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

Podczas oceniania operatora x[y]dostępu do pola , x[y]?, x[[y]]lub x[[y]]? są przechowywane następujące zasady:

Błędy zgłaszane podczas obliczania wyrażenia x są propagowane.
Błędy zgłaszane podczas oceny pola y są trwale skojarzone z polem y, a następnie propagowane. Każdy przyszły dostęp do pola y zgłosi identyczny błąd.
Wyrażenie x generuje wartość rekordu lub tabeli albo zgłaszany jest błąd.
Jeśli identyfikator y nazywa pole, które nie istnieje w xpliku , zostanie zgłoszony błąd z kodem "Expression.Error" przyczyny, chyba że zostanie użyty opcjonalny formularz ...? operatora, w takim przypadku zwracana jest wartość null .

Podczas procesu dostępu do pól nie są oceniane żadne pola x inne niż nazwane przez y .

Operator metadanych

Rekord metadanych dla wartości jest zmieniany przy użyciu operatora meta (x meta y).

wyrażenie-metadanych:
wyrażenie jednoargumentowe
jednoargumentowe wyrażenie-jednoargumentowemeta

Poniższy przykład tworzy wartość tekstową z rekordem metadanych przy użyciu operatora, a następnie uzyskuje dostęp do rekordu metadanych wynikowej wartości przy meta użyciu polecenia Value.Metadata:

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

Podczas stosowania operatora x meta yłączenia metadanych obowiązują następujące zasady:

Błędy zgłaszane podczas oceniania x wyrażeń lub y są propagowane.
Wyrażenie y musi być rekordem lub jest zgłaszany błąd z kodem "Expression.Error" przyczyny.
Wynikowy rekord metadanych to xrekord metadanych scalony z elementem y. (Semantyka scalania rekordów, zobacz Scalanie rekordów).
Wynikowa wartość to wartość z x wyrażenia bez jego metadanych z dołączonym nowo obliczonym rekordem metadanych.

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

Operatory równości

Operator = równości służy do określania, czy dwie wartości są równe. Operator <> nierówności służy do określania, czy dwie wartości nie są równe.

wyrażenie równości:
      wyrażenie-relacyjne
      wyrażenie-relacyjne = wyrażenie-równości
      wyrażenie-relacyjne <> wyrażenie-równości

Na przykład:

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

Metadane nie są częścią porównania równości ani nierówności. Na przykład:

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

Podczas stosowania operatorów x = y równości i x <> y:

Błędy zgłaszane podczas oceniania x wyrażeń lub y są propagowane.
Operator = ma wynik true , jeśli wartości są równe i false w przeciwnym razie.
Operator <> ma wynik false , jeśli wartości są równe i true w przeciwnym razie.
Rekordy metadanych nie są uwzględniane w porównaniu.
Jeśli wartości generowane przez ocenę x wyrażeń i y nie są tego samego rodzaju wartością, wartości nie są równe.
Jeśli wartości generowane przez ocenę x wyrażenia i y są tego samego rodzaju wartością, istnieją określone reguły określania, czy są równe, jak zdefiniowano poniżej.
Następujące informacje są zawsze prawdziwe:

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

Operatory równości są definiowane dla następujących typów:

Wartość null jest równa samej sobie.

    null = null    // true 
    null = true    // false 
    null = false   // false

Wartości true logiczne i false są równe tylko sobie. Na przykład:

    true = true      // true 
    false = false    // true 
    true = false     // false 
    true = 1         // false

Liczby są porównywane przy użyciu określonej precyzji:
- Jeśli którakolwiek z liczb to #nan, liczby nie są takie same.
- Jeśli żadna liczba nie jest #nanwartością , liczby są porównywane przy użyciu bitowego porównania wartości liczbowej.
- #nan jest jedyną wartością, która nie jest równa samej sobie.
  
  Na przykład:

        1 = 1,              // true 
        1.0 = 1             // true 
        2 = 1               // false 
        #nan = #nan         // false 
        #nan <> #nan        // true

Dwa czasy trwania są równe, jeśli reprezentują tę samą liczbę 100-nanosekundowych kleszczy.
Dwa razy są równe, jeśli wielkości ich części (godzina, minuta, sekunda) są równe.
Dwie daty są równe, jeśli wielkości ich części (rok, miesiąc, dzień) są równe.
Dwie daty/godziny są równe, jeśli wielkości ich części (rok, miesiąc, dzień, godzina, minuta, sekunda) są równe.
Dwie strefy daty/godziny są równe, jeśli odpowiadające im daty/godziny UTC są równe. Aby dotrzeć do odpowiedniej daty/godziny UTC, przesunięcie godzin/minut jest odejmowane od składnika datetime strefy czasowej daty/godziny.
Dwie wartości tekstowe są równe, jeśli używasz porządkowego, wrażliwego na wielkość liter, porównania bez uwzględniania kultury mają taką samą długość i równe znaki w odpowiednich pozycjach.
Dwie wartości listy są równe, jeśli wszystkie następujące wartości są prawdziwe:
- Obie listy zawierają taką samą liczbę elementów.
- Wartości każdego elementu odpowiadającego pozycji na listach są równe. Oznacza to, że nie tylko listy muszą zawierać równe elementy, elementy muszą być w tej samej kolejności.
  
  Na przykład:
```
  {1, 2} = {1, 2}     // true 
  {2, 1} = {1, 2}     // false 
  {1, 2, 3} = {1, 2}  // false
```
Dwa rekordy są równe, jeśli wszystkie następujące rekordy są prawdziwe:
- Liczba pól jest taka sama.
- Każda nazwa pola jednego rekordu jest również obecna w drugim rekordzie.
- Wartość każdego pola jednego rekordu jest równa polu o podobnej nazwie w drugim rekordzie.
  
  Na przykład:
```
  [ 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
```
Dwie tabele są równe, jeśli wszystkie z następujących wartości są prawdziwe:
- Liczba kolumn jest taka sama.
- Każda nazwa kolumny w jednej tabeli jest również obecna w drugiej tabeli.
- Liczba wierszy jest taka sama.
- Każdy wiersz ma równe wartości w odpowiednich komórkach.
  
  Na przykład:
```
  #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
```
Wartość funkcji jest równa samej sobie, ale może być równa innej wartości funkcji lub może nie być równa innej wartości funkcji. Jeśli dwie wartości funkcji są traktowane jako równe, będą zachowywać się identycznie po wywołaniu.

Dwie podane wartości funkcji zawsze będą miały taką samą relację równości.
Wartość typu jest równa sobie, ale może lub nie może być równa innej wartości typu. Jeśli dwie wartości typu są traktowane jako równe, będą zachowywać się identycznie podczas wykonywania zapytań o zgodność.

Dwie podane wartości typu zawsze będą miały taką samą relację równości.

Operatory relacyjne

Operatory <, >, <=i >= są nazywane operatorami relacyjnymi.

wyrażenie-relacyjne:
      wyrażenie-addytywne
      wyrażenie-addytywne wyrażenie-relacyjne<
      wyrażenie-addytywne wyrażenie-relacyjne>
      wyrażenie-addytywne wyrażenie-relacyjne<=
      wyrażenie-addytywne wyrażenie-relacyjne>=

Te operatory służą do określania względnej relacji porządkowania między dwiema wartościami, jak pokazano w poniższej tabeli:

Operacja	Wynik
`x < y`	`true` jeśli `x` wartość jest mniejsza niż `y`, `false` w przeciwnym razie
`x > y`	`true` jeśli `x` wartość jest większa niż `y`, `false` w przeciwnym razie
`x <= y`	`true` jeśli `x` wartość jest mniejsza lub równa `y`, `false` w przeciwnym razie
`x >= y`	`true` jeśli `x` wartość jest większa lub równa `y`, `false` w przeciwnym razie

Na przykład:

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

Podczas obliczania wyrażenia zawierającego operatory relacyjne obowiązują następujące zasady:

Błędy zgłaszane podczas oceniania x wyrażeń operandu lub y są propagowane.
Wartości generowane przez ocenę zarówno wyrażeń, jak x i y muszą być wartościami binarnymi, data/godzina, data/godzina, strefa czasowa, czas trwania, logiczny, liczba, wartość null, tekst lub godzina. W przeciwnym razie jest zgłaszany błąd z kodem "Expression.Error" przyczyny.
Oba operandy muszą być tego samego rodzaju wartością lub null. W przeciwnym razie jest zgłaszany błąd z kodem "Expression.Error" przyczyny.
Jeśli oba operandy to null, wynikiem jest null wartość .
Dwa pliki binarne są porównywane bajtami bajtów.
Dwie daty są porównywane przez porównanie ich części roku i, jeśli są równe, ich części miesiąca i, jeśli są równe, ich części dnia.
Dwie daty/godziny są porównywane przez porównanie ich części roku i, jeśli są równe, ich części miesiąca i, jeśli są równe, ich części dnia i, jeśli są równe, ich części godzin i, jeśli są równe, ich części minut i, jeśli są równe, ich drugie części.
Dwie strefy daty/godziny są porównywane przez normalizację ich do czasu UTC przez odjęcie przesunięcia godzin/minuty, a następnie porównanie ich składników daty/godziny.
Dwa czasy trwania są porównywane zgodnie z całkowitą liczbą 100-nanosekundowych kleszczy, które reprezentują.
Dwa logicznie są porównywane w taki sposób, że true jest uważany za większy niż false.
Dwie liczby x i y są porównywane zgodnie z regułami standardu IEEE 754:
- Jeśli jeden z operandów to #nan, wynik dotyczy false wszystkich operatorów relacyjnych.
- Jeśli żaden operand nie ma #nanwartości , operatory porównują wartości dwóch operandów zmiennoprzecinkowych w odniesieniu do kolejności -∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞ , w której wartości minimalne i maksymalne są najmniejszymi i największymi dodatnimi wartościami skończonymi, które mogą być reprezentowane. Nazwy M dla -∞ i +∞ to -#infinity i #infinity.
  
  Istotne skutki tego porządkowania są następujące:
  - Wartości ujemne i dodatnie są traktowane jako równe.
  - Wartość jest traktowana -#infinity jako mniejsza niż wszystkie inne wartości liczbowe, ale równa innej -#infinitywartości .
  - Wartość jest uznawana #infinity za większą niż wszystkie inne wartości liczbowe, ale równą innej #infinitywartości .
Dwa teksty są porównywane przy użyciu porządkowego znaku po znaku, z uwzględnieniem wielkości liter, porównania bez uwzględniania kultury.
Dwa razy są porównywane przez porównanie ich części godzin i, jeśli są równe, ich części minut i, jeśli są równe, ich drugiej części.

Warunkowe operatory logiczne

Operatory and i or są nazywane operatorami logicznymi warunkowych.

wyrażenie logiczne lub wyrażenie:
      wyrażenie logiczne i
wyrażenie logiczne i wyrażenieorlogiczne lub wyrażenie
wyrażenie logiczne i wyrażenie:
      is-expression
      wyrażenie-is-logical-and-expressionand

Operator or zwraca wartość true , gdy co najmniej jeden z jego operandów to true. Prawy operand jest oceniany, jeśli i tylko wtedy, gdy lewy operand nie truejest .

Operator and zwraca wartość false , gdy co najmniej jeden z jego operandów to false. Prawy operand jest oceniany, jeśli i tylko wtedy, gdy lewy operand nie falsejest .

Poniżej przedstawiono tabele prawdy dla or operatorów i and z wynikiem oceny wyrażenia lewego operandu na osi pionowej i wyniku oceny prawego wyrażenia operandu na osi poziomej.

`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`

Podczas obliczania wyrażenia zawierającego warunkowe operatory logiczne są przechowywane następujące zasady:

Błędy zgłaszane podczas oceniania x wyrażeń lub y są propagowane.
Warunkowe operatory logiczne są definiowane dla typów logical i null. Jeśli wartości operandu nie są tego typu, zostanie zgłoszony błąd z kodem "Expression.Error" przyczyny.
Wynik jest wartością logiczną.
W wyrażeniu lub wyrażenie zostanie obliczone, jeśli i tylko wtedy, gdy x nie zostanie obliczona wartość true.yx y
W wyrażeniu i wyrażenie zostanie obliczone, jeśli i tylko wtedy, gdy x nie zostanie obliczona wartość false.yx y

Dwie ostatnie właściwości dają warunkowym operatorom logicznym ich "warunkowe" kwalifikacje; właściwości określane również jako "zwarcie". Te właściwości są przydatne do pisania kompaktowych predykatów chronionych. Na przykład następujące wyrażenia są równoważne:

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

Operatory arytmetyczne

Operatory +, * -i / to operatory arytmetyczne.

wyrażenie-addytywne:
      wyrażenie mnożenia
      wyrażenie-add-expression+mnożenia wyrażenie-
      wyrażenie-add-expression-mnożenia wyrażenie-
wyrażenie-mnożenia:
      metadata- expression
      wyrażenie-metadanych wyrażenie-mnożenia*
      wyrażenie-metadanych wyrażenie-mnożenia/

Dokładność

Liczby w języku M są przechowywane przy użyciu różnych reprezentacji, aby zachować jak najwięcej informacji o liczbach pochodzących z różnych źródeł. Liczby są konwertowane tylko z jednej reprezentacji na inną zgodnie z potrzebami przez operatory zastosowane do nich. Dwie precyzje są obsługiwane w języku M:

Dokładność	semantyka
`Precision.Decimal`	128-bitowa reprezentacja dziesiętna z zakresem ±1,0 x 10–28 do ±7,9 x 1028 i 28–29 cyfr znaczących.
`Precision.Double`	Reprezentacja naukowa przy użyciu mantissa i wykładnika; jest zgodny z 64-bitową dwuwymiarową precyzją standardu arytmetycznego IEEE 754 IEEE 754-2008.

Operacje arytmetyczne są wykonywane przez wybranie dokładności, przekonwertowanie obu operandów na tę precyzję (w razie potrzeby), a następnie wykonanie rzeczywistej operacji, a na koniec zwrócenie liczby w wybranej precyzji.

Wbudowane operatory arytmetyczne (+, -, *, /) używają podwójnej precyzji. Standardowe funkcje biblioteki (Value.Add, Value.Subtract, Value.Multiply, Value.Divide) mogą służyć do żądania tych operacji przy użyciu określonego modelu precyzji.

Nie jest możliwe przepełnienie liczbowe: #infinity lub -#infinity reprezentują wartości wielkości zbyt dużych, aby były reprezentowane.
Nie jest możliwe żadne niedopełnienie liczbowe: 0 i -0 reprezentuje wartości wielkości zbyt małych, aby były reprezentowane.
Wartość #nan specjalna IEEE 754 (NaN — Not a Number) jest używana do pokrycia arytmetycznie nieprawidłowych przypadków, takich jak podział zera o zero.
Konwersja z liczby dziesiętnej na podwójną jest wykonywana przez zaokrąglanie liczb dziesiętnych do najbliższej równoważnej podwójnej wartości.
Konwersja z podwójnej na dziesiętną jest wykonywana przez zaokrąglanie podwójnych liczb do najbliższej równoważnej wartości dziesiętnej i, w razie potrzeby, przepełnianie wartości lub #infinity -#infinity .

operator dodawania

Interpretacja operatora dodawania (x + y) zależy od rodzaju wartości obliczonych wyrażeń x i y w następujący sposób:

x	t	Result	Interpretacja
`type number`	`type number`	`type number`	Suma liczbowa
`type number`	`null`	`null`
`null`	`type number`	`null`
`type duration`	`type duration`	`type duration`	Suma liczbowa wielkości
`type duration`	`null`	`null`
`null`	`type duration`	`null`
`type`data/godzina	`type duration`	`type`data/godzina	Przesunięcie daty/godziny według czasu trwania
`type duration`	`type`data/godzina	`type`data/godzina
`type`data/godzina	`null`	`null`
`null`	`type`data/godzina	`null`

W tabeli type data/godzina oznacza dowolną wartość type date, type datetime, type datetimezonelub type time. Podczas dodawania czasu trwania i wartości typu data/godzina wynikowa wartość jest tego samego typu.

W przypadku innych kombinacji wartości niż wymienione w tabeli jest zgłaszany błąd z kodem "Expression.Error" przyczyny. Każda kombinacja jest omówiona w poniższych sekcjach.

Błędy zgłaszane podczas oceniania dowolnego operandu są propagowane.

Suma liczbowa

Suma dwóch liczb jest obliczana przy użyciu operatora dodawania, tworząc liczbę.

Na przykład:

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

Operator + dodawania liczb używa podwójnej precyzji. Funkcja biblioteki Value.Add standardowej może służyć do określania dokładności dziesiętnej. Podczas obliczania sumy liczb są przechowywane następujące warunki:

Suma w podwójnej precyzji jest obliczana zgodnie z regułami 64-bitowych dwuprecyzji dwuprecyzji IEEE 754 arytmetyczne IEEE 754-2008. W poniższej tabeli wymieniono wyniki wszystkich możliwych kombinacji wartości niezerowych, zer, nieskończoności i wartości NaN. W tabeli x i y są wartościami niezerowymi i z są wynikiem x + y. Jeśli x i y mają taką samą wielkość, ale przeciwległe znaki, z jest dodatnie zero. Jeśli x + y jest zbyt duży, aby być reprezentowany w typie docelowym, z jest nieskończoność z tym samym znakiem co x + y.

+	t	+0	0–	+∞	-∞	NaN
x	z	x	x	+∞	-∞	NaN
+0	t	+0	+0	+∞	-∞	NaN
-0	t	+0	0–	+∞	-∞	NaN
+∞	+∞	+∞	+∞	+∞	NaN	NaN
-∞	-∞	-∞	-∞	NaN	-∞	NaN
Nan	NaN	NaN	NaN	NaN	NaN	NaN

Suma w precyzji dziesiętnej jest obliczana bez utraty precyzji. Skala wyniku jest większa od skali dwóch operandów.

Suma czasów trwania

Suma dwóch czasów trwania to czas trwania reprezentujący sumę liczby 100nanosecond kleszczy reprezentowanych przez czasy trwania. Na przykład:

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

Przesunięcie daty/godziny według czasu trwania

Data/godzina i czas trwania y mogą być dodawane do x + y obliczania nowej daty/ x godziny, której odległość od x na osi czasu liniowego jest dokładnie wielkością y. W tym miejscu data/godzina oznacza dowolną wartość Date, DateTimelub Time DateTimeZone, a wynik inny niż null będzie tego samego typu. Przesunięcie daty/godziny według czasu trwania może być obliczane w następujący sposób:

Jeśli określono wartość daty/godziny od czasu epoki, utwórz nową datę/godzinę z następującymi elementami informacji:
- Oblicz nowe dni od epoki równoważnej podzieleniu wielkości y przez liczbę 100-nanosekundowych kleszczy w okresie 24-godzinnym, obcinając część dziesiętną wyniku i dodając tę wartość do dni x od epoki.
- Oblicz nowe kleszcze od północy równoważne do dodania wielkości y do kleszczy x od północy, modulo liczbę 100-nanosekundowych kleszczy w okresie 24-godzinnym. Jeśli x nie określa wartości dla znaczników od północy, przyjmuje się wartość 0.
- Skopiuj wartość x dla przesunięcia minut z utc bez zmian.
Jeśli wartość daty/godziny od czasu epoki jest nieokreślona, utwórz nową datę/godzinę z określonymi następującymi elementami informacji:
- Oblicz nowe kleszcze od północy równoważne do dodania wielkości y do kleszczy x od północy, modulo liczbę 100-nanosekundowych kleszczy w okresie 24-godzinnym. Jeśli x nie określa wartości dla znaczników od północy, przyjmuje się wartość 0.
- Skopiuj wartości x dla dni od epoki i minut przesunięcia z czasu UTC bez zmian.

W poniższych przykładach pokazano obliczanie bezwzględnej sumy czasowej, gdy data/godzina określa dni od epoki:

#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

W poniższym przykładzie pokazano obliczanie przesunięcia daty/godziny według czasu trwania dla danego czasu:

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

operator odejmowania

Interpretacja operatora odejmowania (x - y) zależy od rodzaju wartości obliczonych wyrażeń x i y, w następujący sposób:

x	Y	Result	Interpretacja
`type number`	`type number`	`type number`	Różnica liczbowa
`type number`	`null`	`null`
`null`	`type number`	`null`
`type duration`	`type duration`	`type duration`	Różnica liczbowa wielkości
`type duration`	`null`	`null`
`null`	`type duration`	`null`
`type`data/godzina	`type`data/godzina	`type duration`	Czas trwania między datami/godzinami
`type`data/godzina	`type duration`	`type`data/godzina	Przesunięcie daty/godziny przez negowany czas trwania
`type`data/godzina	`null`	`null`
`null`	`type`data/godzina	`null`

W tabeli type data/godzina oznacza dowolną wartość type date, type datetime, type datetimezonelub type time. W przypadku odejmowania czasu trwania od wartości typu data/godzina wynikowa wartość jest tego samego typu.

W przypadku innych kombinacji wartości niż wymienione w tabeli jest zgłaszany błąd z kodem "Expression.Error" przyczyny. Każda kombinacja jest omówiona w poniższych sekcjach.

Błędy zgłaszane podczas oceniania dowolnego operandu są propagowane.

Różnica liczbowa

Różnica między dwiema liczbami jest obliczana przy użyciu operatora odejmowania, tworząc liczbę. Na przykład:

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

Operator - odejmowania liczb używa podwójnej precyzji. Funkcja biblioteki Value.Subtract standardowej może służyć do określania dokładności dziesiętnej. Podczas obliczania różnicy liczb są przechowywane następujące elementy:

Różnica w podwójnej precyzji jest obliczana zgodnie z regułami 64-bitowej binarnej podwójnej precyzji IEEE 754 arytmetyczne IEEE 754-2008. W poniższej tabeli wymieniono wyniki wszystkich możliwych kombinacji wartości niezerowych, zer, nieskończoności i wartości NaN. W tabeli x i y są wartościami niezerowymi i z są wynikiem x - y. Jeśli x i y są równe, z jest dodatnie zero. Jeśli x - y jest zbyt duży, aby być reprezentowany w typie docelowym, z jest nieskończoność z tym samym znakiem co x - y.

-	t	+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

Różnica w precyzji dziesiętnej jest obliczana bez utraty precyzji. Skala wyniku jest większa od skali dwóch operandów.

Różnica czasu trwania

Różnica dwóch czasów trwania to czas trwania reprezentujący różnicę między liczbą 100-nanosekundowych kleszczy reprezentowanych przez każdy czas trwania. Na przykład:

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

Przesunięcie daty/godziny przez negowany czas trwania

Data /godzina x i czas trwania y mogą być odejmowane przy użyciu funkcji x - y obliczania nowej daty/godziny. W tym miejscu data/godzina oznacza dowolną wartość date, datetime, datetimezonelub time. Wynikowa data/godzina ma odległość od x osi czasu liniowej, która jest dokładnie wielkością y, w kierunku przeciwnym od znaku y. Odejmowanie dodatnich czasów trwania daje wyniki, które są wstecz w czasie względem x, podczas odjęcie wartości ujemnych daje wyniki, które są przekazywane w czasie.

#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

Czas trwania między dwiema datami/godzinami

Dwie daty/godziny t i u mogą być odejmowane przy użyciu funkcji t - u obliczania czasu trwania między nimi. W tym miejscu data/godzina oznacza dowolną wartość date, datetime, datetimezonelub time. Czas trwania generowany przez odjęcie u od t elementu musi być zwracany t po dodaniu do uelementu .

#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

Odejmowanie t - u w przypadku u > t ujemnego czasu trwania:

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

Podczas odejmowania dwóch dat/godzin przy użyciu polecenia t - u:

u + (t - u) = t

operator mnożenia

Interpretacja operatora mnożenia (x * y) zależy od rodzaju wartości obliczonych wyrażeń x i y w następujący sposób:

X	Y	Result	Interpretacja
`type number`	`type number`	`type number`	Produkt liczbowy
`type number`	`null`	`null`
`null`	`type number`	`null`
`type duration`	`type number`	`type duration`	Wielokrotność czasu trwania
`type number`	`type duration`	`type duration`	Wielokrotność czasu trwania
`type duration`	`null`	`null`
`null`	`type duration`	`null`

W przypadku innych kombinacji wartości niż wymienione w tabeli jest zgłaszany błąd z kodem "Expression.Error" przyczyny. Każda kombinacja jest omówiona w poniższych sekcjach.

Błędy zgłaszane podczas oceniania dowolnego operandu są propagowane.

Produkt liczbowy

Produkt dwóch liczb jest obliczany przy użyciu operatora mnożenia, tworząc liczbę. Na przykład:

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

Operator * mnożenia liczb używa podwójnej precyzji. Funkcja biblioteki Value.Multiply standardowej może służyć do określania dokładności dziesiętnej. Podczas obliczania produktu liczb następujące elementy są przechowywane:

Produkt w podwójnej precyzji jest obliczany zgodnie z regułami 64-bitowej podwójnej precyzji binarnej IEEE 754 arytmetyczne IEEE 754-2008. W poniższej tabeli wymieniono wyniki wszystkich możliwych kombinacji wartości niezerowych, zer, nieskończoności i wartości NaN. W tabeli x i y są dodatnimi wartościami skończonymi. zjest wynikiem .x * y Jeśli wynik jest zbyt duży dla typu docelowego, z jest nieskończoność. Jeśli wynik jest za mały dla typu docelowego, z ma wartość zero.

*	+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

Produkt w precyzji dziesiętnej jest obliczany bez utraty precyzji. Skala wyniku jest większa od skali dwóch operandów.

Wielokrotności czasów trwania

Iloczyn czasu trwania i liczby to czas trwania reprezentujący liczbę 100nanosecond kleszczy reprezentowanych przez operand czasu trwania w operand liczbie. Na przykład:

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

operator dzielenia

Interpretacja operatora dzielenia (x / y) zależy od rodzaju wartości obliczonych wyrażeń x i y, w następujący sposób:

X	Y	Result	Interpretacja
`type number`	`type number`	`type number`	Iloraz liczbowy
`type number`	`null`	`null`
`null`	`type number`	`null`
`type duration`	`type number`	`type duration`	Ułamek czasu trwania
`type duration`	`type duration`	`type number`	Iloraz liczbowy czasu trwania
`type duration`	`null`	`null`
`null`	`type duration`	`null`

W przypadku innych kombinacji wartości niż wymienione w tabeli jest zgłaszany błąd z kodem "Expression.Error" przyczyny. Każda kombinacja jest omówiona w poniższych sekcjach.

Błędy zgłaszane podczas oceniania dowolnego operandu są propagowane.

Iloraz liczbowy

Iloraz dwóch liczb jest obliczany przy użyciu operatora dzielenia, tworząc liczbę. Na przykład:

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

Operator / dzielenia liczb używa podwójnej precyzji. Funkcja Value.Divide biblioteki standardowej może służyć do określania dokładności dziesiętnej. Podczas obliczania ilorazu liczb są przechowywane następujące elementy:

Iloraz w podwójnej precyzji jest obliczany zgodnie z regułami 64-bitowej podwójnej precyzji binarnej IEEE 754 arytmetyczne IEEE 754-2008. W poniższej tabeli wymieniono wyniki wszystkich możliwych kombinacji wartości niezerowych, zer, nieskończoności i wartości NaN. W tabeli x i y są dodatnimi wartościami skończonymi. zjest wynikiem .x / y Jeśli wynik jest zbyt duży dla typu docelowego, z jest nieskończoność. Jeśli wynik jest za mały dla typu docelowego, z ma wartość zero.

/	+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

Suma w precyzji dziesiętnej jest obliczana bez utraty precyzji. Skala wyniku jest większa od skali dwóch operandów.

Iloraz czasu trwania

Iloraz dwóch czasów trwania jest liczbą reprezentującą iloraz liczby 100nanosecond kleszczy reprezentowanych przez czasy trwania. Na przykład:

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

Skalowane czasy trwania

Iloraz czasu trwania x i liczby y to czas trwania reprezentujący iloraz liczby 100-nanosekundowych kleszczy reprezentowanych przez czas trwania x i liczbę y. Na przykład:

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

Kombinacja struktury

Operator kombinacji (x & y) jest definiowany w następujących rodzajach wartości:

X	Y	Result	Interpretacja
`type text`	`type text`	`type text`	Łączenie
`type text`	`null`	`null`
`null`	`type text`	`null`
`type date`	`type time`	`type datetime`	Scal
`type date`	`null`	`null`
`null`	`type time`	`null`
`type list`	`type list`	`type list`	Łączenie
`type record`	`type record`	`type record`	Scal
`type table`	`type table`	`type table`	Łączenie

Łączenie

Dwa tekst, dwie listy lub dwie wartości tabeli można połączyć przy użyciu polecenia x & y.

Poniższy przykład ilustruje łączenie wartości tekstowych:

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

Poniższy przykład ilustruje łączenie list:

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

Podczas łączenia dwóch wartości przy użyciu polecenia x & y:

Błędy zgłaszane podczas oceniania x wyrażeń lub y są propagowane.
Brak propagacji błędu, jeśli element x albo y zawiera błąd.
Wynikiem łączenia dwóch wartości tekstowych jest wartość tekstowa zawierająca wartość x natychmiast po y. Jeśli jeden z operandów ma wartość null, a drugi jest wartością tekstową, wynik ma wartość null.
Wynikiem łączenia dwóch list jest lista zawierająca wszystkie elementy, x po których następuje wszystkie elementy elementu y.
Wynikiem łączenia dwóch tabel jest tabela zawierająca związek dwóch kolumn tabeli operandu. Kolejność x kolumn jest zachowywana, a następnie kolumny wyświetlane tylko w ypliku , zachowując ich względną kolejność. W przypadku kolumn wyświetlanych tylko w jednym z operandów null służy do wypełniania wartości komórek dla drugiego operandu.

Scal

Scalanie rekordów

Dwa rekordy można scalić przy użyciu metody x & y, tworząc rekord zawierający pola z obu x yi .

Poniższe przykłady ilustrują scalanie rekordów:

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

Następujące blokady są przechowywane podczas scalania dwóch rekordów przy użyciu polecenia x + y:

Błędy zgłaszane podczas oceniania x wyrażeń lub y są propagowane.
Jeśli pole pojawi się zarówno w , jak x i y, zostanie użyta wartość z y .
Kolejność pól w rekordzie wynikowym to pole typu x, a po nim pola y , które nie są częścią xelementu , w tej samej kolejności, w której są wyświetlane w y.
Scalanie rekordów nie powoduje oceny wartości.
Nie jest zgłaszany żaden błąd, ponieważ pole zawiera błąd.
Wynik jest rekordem.

Scalanie daty i godziny

Datę można scalić z godziną y przy użyciu metody x & y, tworząc datęx/godzinę, która łączy części z obu x elementów i y.

Poniższy przykład ilustruje scalanie daty i godziny:

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

Następujące blokady są przechowywane podczas scalania dwóch rekordów przy użyciu polecenia x + y:

Błędy zgłaszane podczas oceniania x wyrażeń lub y są propagowane.
Wynik jest datą/godziną.

Operatory jednoargumentowe

Operatory +, -i not są operatorami jednoargumentowymi.

jednoargumentowe wyrażenie:
      wyrażenie-typ
      +wyrażenie jednoargumentowe
      -wyrażenie jednoargumentowe
      notwyrażenie jednoargumentowe

Jednoargumentowy operator plus

Jednoargumentowy operator plus (+x) jest zdefiniowany dla następujących rodzajów wartości:

X	Result	Interpretacja
`type number`	`type number`	Jednoargumentowy plus
`type duration`	`type duration`	Jednoargumentowy plus
`null`	"null

W przypadku innych wartości jest zgłaszany błąd z kodem "Expression.Error" przyczyny.

Jednoargumentowy operator plus umożliwia + zastosowanie znaku do wartości liczbowej, daty/godziny lub wartości null. Wynikiem jest ta sama wartość. Na przykład:

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

Podczas oceniania jednoargumentowego operatora +xplus są przechowywane następujące warunki:

Błędy zgłaszane podczas oceny x są propagowane.
Jeśli wynik oceny x nie jest wartością liczbową, zostanie zgłoszony błąd z kodem "Expression.Error" przyczyny.

Jednoargumentowy operator minus

Jednoargumentowy operator minus (-x) jest zdefiniowany dla następujących rodzajów wartości:

X	Result	Interpretacja
`type number`	`type number`	Negacja
`type duration`	`type duration`	Negacja
`null`	`null`

W przypadku innych wartości jest zgłaszany błąd z kodem "Expression.Error" przyczyny.

Jednoargumentowy operator minus służy do zmiany znaku liczby lub czasu trwania. Na przykład:

- (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)

Podczas oceniania jednoargumentowego operatora -xminus są przechowywane następujące elementy:

Błędy zgłaszane podczas oceny x są propagowane.
Jeśli wyrażenie jest liczbą, wynikiem jest wartość liczbowa z wyrażenia x ze zmienionym znakiem. Jeśli wartość to NaN, wynik jest również wartością NaN.

Operator negacji logicznej

Operator negacji logicznej (not) jest definiowany dla następujących rodzajów wartości:

X	Result	Interpretacja
`type logical`	`type logical`	Negacja
`null`	`null`

Ten operator oblicza operację logiczną not dla danej wartości logicznej. Na przykład:

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

Podczas oceniania operatora not xnegacji logicznej obowiązują następujące warunki:

Błędy zgłaszane podczas oceny x są propagowane.
Wartość wygenerowana z obliczania wyrażenia x musi być wartością logiczną lub musi zostać zgłoszony błąd z kodem "Expression.Error" przyczyny. Jeśli wartość to true, wynik to false. Jeśli operand ma falsewartość , wynikiem jest true.

Wynik jest wartością logiczną.

Operatory typów

Operatory i as są nazywane operatorami is typów.

Operator zgodności typów

Operator x is y zgodności typów jest zdefiniowany dla następujących typów wartości:

X	Y	Result
`type any`	typ-pierwotny dopuszczany do wartości null	`type logical`

Wyrażenie x is y zwraca true wartość , jeśli przypisany typ x jest zgodny z elementem yi zwraca false wartość , jeśli przypisany typ x jest niezgodny z y. y musi być typu nullable-primitivetype.

is-expression:
      as-expression
      is-expression is nullable-primitive-type
typ-pierwotny dopuszczany do wartości null:
      nullable_opt typ pierwotny

Zgodność typu, obsługiwana przez is operatora, jest podzbiorem ogólnej zgodności typów i jest definiowana przy użyciu następujących reguł:

Jeśli x wartość ma wartość null, jest zgodna, jeśli y jest typem any, typem lub typem nulldopuszczanym do wartości null.
Jeśli x parametr ma wartość inną niż null, jeśli jest zgodny, jeśli typ pierwotny jest x taki sam jak y.

Następujące zasady są przechowywane podczas obliczania wyrażenia x is y:

Podczas oceniania wyrażenia x jest zgłaszany błąd.

Operator asercji typu

Operator x as y asercji typu jest definiowany dla następujących typów wartości:

X	Y	Result
`type any`	typ-pierwotny dopuszczany do wartości null	`type any`

Wyrażenie x as y potwierdza, że wartość x jest zgodna z y operatorem is . Jeśli nie jest zgodny, zostanie zgłoszony błąd. ymusi być typem pierwotnym dopuszczalnym wartości null.

as-expression:
wyrażenie równości
as-expression as nullable-primitive-type

Wyrażenie x as y jest oceniane w następujący sposób:

Wykonywane jest sprawdzanie x is y zgodności typów, a aseracja zwraca x niezmienione, jeśli test zakończy się pomyślnie.
Jeśli sprawdzanie zgodności zakończy się niepowodzeniem, zostanie zgłoszony błąd z kodem "Expression.Error" przyczyny.

Przykłady:

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

Następujące zasady są przechowywane podczas obliczania wyrażenia x as y:

Podczas oceniania wyrażenia x jest zgłaszany błąd.

Operator coalesce

Operator ?? połączenia zwraca wynik lewego operandu, jeśli nie ma wartości null, w przeciwnym razie zwróci wynik prawego operandu. Prawy operand jest obliczany, jeśli argument i tylko wtedy, gdy lewy operand ma wartość null.

Udostępnij za pośrednictwem

Zachowanie operatora

Kolejność wykonywania działań

Operatory i metadane

Operatory rekursywne ze strukturą

Operatory wyboru i projekcji

Dostęp do elementów

Dostęp do pola

Operator metadanych

Operatory równości

Operatory relacyjne

Warunkowe operatory logiczne

Operatory arytmetyczne

Dokładność

operator dodawania

Suma liczbowa

Suma czasów trwania

Przesunięcie daty/godziny według czasu trwania

operator odejmowania

Różnica liczbowa

Różnica czasu trwania

Przesunięcie daty/godziny przez negowany czas trwania

Czas trwania między dwiema datami/godzinami

operator mnożenia

Produkt liczbowy

Wielokrotności czasów trwania

operator dzielenia

Iloraz liczbowy

Iloraz czasu trwania

Skalowane czasy trwania

Kombinacja struktury

Łączenie

Scal

Scalanie rekordów

Scalanie daty i godziny

Operatory jednoargumentowe

Jednoargumentowy operator plus

Jednoargumentowy operator minus

Operator negacji logicznej

Operatory typów

Operator zgodności typów

Operator asercji typu

Operator coalesce

Opinia

Dodatkowe zasoby