Поведение оператора

  • Статья

В этом разделе определяется поведение различных операторов M.

Приоритет операторов

Если выражение содержит несколько операторов, порядок вычисления этих операторов определяется их приоритетом. Например, выражение x + y * z вычисляется так, x + (y * z) как * оператор имеет более высокий приоритет, чем двоичный + оператор. Приоритет оператора устанавливается определением связанной рабочей грамматики. Например, аддитивное выражение состоит из последовательности мультипликативных выражений, разделенных + или - операторов, что дает + и - операторам более низкий приоритет, чем * операторы./

Рабочую среду с скобками можно использовать для изменения порядка приоритета по умолчанию.

круглые скобки:
      (выражение)

Например:

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

В следующей таблице перечислены операторы M, в котором перечислены категории операторов в порядке приоритета от самого высокого до низкого. Операторы в одной категории имеют одинаковый приоритет.

Категория Expression Description
Основной i
@i		 Выражение идентификатора
(x) Скобки выражения
x[i] Подстановка
x{y} Доступ к элементам
x(...) Вызов функции
{x, y, ...} Инициализация списком
[ i = x, ... ] Инициализация записей
... Не реализовано
Унарный +x Идентификация
-x Отрицание
notx Логическое отрицание
Метаданные xmetay Связывание метаданных
Мультипликативные x * y Умножение
x / y Подразделение
Аддитивный x + y Дополнение
x - y Вычитание
Реляционная x< y Меньше
x > y Больше
x<= y Меньше или равно
x >= y Больше или равно
Equality x = y Equal
x<> y Not equal
Утверждение типа xasy Совместим с типом или ошибкой, допускающей значение NULL
Соответствие типам xisy Проверьте, совместим ли совместимый тип nullable-primitive
Логическое И xandy Сочетание коротких каналов
Логическое ИЛИ xory Короткое прерывание
Coalesce x??y Оператор объединения с NULL

Операторы и метаданные

Каждое значение имеет связанное значение записи, которое может содержать дополнительные сведения о значении. Эта запись называется записью метаданных для значения. Запись метаданных может быть связана с любым типом значения, даже null. Результатом такой связи является новое значение с заданными метаданными.

Запись метаданных — это только обычная запись, которая может содержать любые поля и значения, которые может выполнять обычная запись, и сама по себе имеет запись метаданных. Связывание записи метаданных со значением является "ненавязчивым". Он не изменяет поведение значения в оценках, за исключением тех, которые явно проверяют записи метаданных.

Каждое значение имеет запись метаданных по умолчанию, даже если она не указана. Запись метаданных по умолчанию пуста. В следующих примерах показано, как получить доступ к записи метаданных текстового значения с помощью стандартной Value.Metadata функции библиотеки:

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

Записи метаданных обычно не сохраняются при использовании значения с оператором или функцией, которая создает новое значение. Например, если два текстовых значения объединяются с помощью & оператора, метаданные результирующего текстового значения — пустая запись []. Следующие выражения эквивалентны:

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

Стандартные функции Value.RemoveMetadata библиотеки и Value.ReplaceMetadata могут использоваться для удаления всех метаданных из значения и замены метаданных значения (а не слияния метаданных в возможно существующие метаданные).

Единственным оператором, возвращающим результаты, которые несут метаданные, является мета-оператор.

Структурные рекурсивные операторы

Значения могут быть циклическими. Например:

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

M обрабатывает циклические значения, сохраняя построение записей, списков и таблиц с отложенными. Попытка создать циклическое значение, которое не получает преимущества от перемешанных структурированных значений, приводит к ошибке:

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

Некоторые операторы в M определяются структурным рекурсией. Например, равенство записей и списков определяется соответствующим равенством соответствующих полей записей и списков элементов соответственно.

Для нециклических значений применение структурной рекурсии дает конечное расширение значения: общие вложенные значения будут проходить многократно, но процесс рекурсии всегда завершается.

Циклическое значение имеет бесконечное расширение при применении структурной рекурсии. Семантика M не предусматривает специальных операций для такого бесконечного расширения — например, при попытке сравнить цикличные значения на равенство обычно расходуются все ресурсы и сравнение завершается с исключением.

Операторы выбора и проекции

Операторы выбора и проекции позволяют извлекать данные из списка и значений записей.

Доступ к элементам

Значение может быть выбрано из списка или таблицы на основе его нулевой позиции в этом списке или таблице с помощью выражения доступа к элементу.

выражение-доступа-к-элементу:
      выбор-элемента
      выбор-необязательного-элемента
выбор-элемента:
      основное-выражение{селектор-элементов}
выбор-необязательного-элемента:
      основное-выражение{селектор-элементов} ?
селектор-элементов:
      выражение

Выражение-доступа-к-элементамx{y} возвращает:

  • Для списка x и числа yэлемент списка x в позиции y. Первый элемент списка считается порядковый индекс нулевым. Если запрошенная позиция не существует в списке, возникает ошибка.

  • Для таблицы x и числа yстрока таблицы x в позиции y. Первая строка таблицы считается порядковой индекс нулевой. Если запрошенная позиция не существует в таблице, возникает ошибка.

  • Для таблицы x и записи yy строка таблицыx, которая соответствует значениям полей для полей с именами полей, соответствующими именам столбцов таблицы. Если в таблице нет уникальной строки сопоставления, возникает ошибка.

Например:

{"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-expression также поддерживает форму x{y}?, которая возвращается null , когда позиция (или совпадение) y не существует в списке или таблице x. При наличии нескольких совпадений yвозникает ошибка.

Например:

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

Доступ к элементам не принудительно проверяет элементы списка или таблицы, отличные от доступного к элементу. Например:

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

Ниже приведено значение, когда вычисляется оператор x{y} доступа к элементу:

  • Ошибки, возникающие во время оценки выражений x или y распространяются.

  • Выражение x создает список или табличное значение.

  • Выражение y создает числовое значение или, если x создает табличное значение, значение записи.

  • При y создании числа и отрицательном y значении возникает ошибка с кодом "Expression.Error" причины.

  • Если y создается число и значение y больше или равно количеству x, возникает ошибка с кодом "Expression.Error" причины, если не используется необязательная форма x{y}? оператора, в этом случае возвращается значение null .

  • Если x создается табличное значение и создается значение записи и y отсутствуют совпадения yx, возникает ошибка с кодом "Expression.Error" причины, если не используется необязательная форма x{y}? оператора, в этом случае возвращается значение null .

  • Если x вы создаете табличное значение и создает значение записи и y имеется несколько совпадений yx, возникает ошибка с кодом "Expression.Error" причины.

Элементы, отличные от того, что находится в x позиции y , вычисляются во время процесса выбора элемента. (Для потоковых списков или таблиц элементы или строки, предшествующие позиции y , пропускаются, что может привести к их оценке в зависимости от источника списка или таблицы.)

Доступ к полю

Выражение field-access-expression используется для выбора значения из записи или для проецировать запись или таблицу в одну с меньшим количеством полей или столбцов соответственно.

выражение-доступа-к-полю:
      выбор-поля
      выбор-неявного-целевого-поля
      проекция
      неявная-целевая-проекция
выбор-поля:
      основное-выражение селектор-поля
селектор поля:
      селектор-обязательного-поля
      селектор-необязательного-поля
селектор-обязательного-поля:
      [имя-поля]
необязательный селектор полей:
      [имя-поля] ?
имя-поля:
      обобщенный-идентификатор
      нестандартный-идентификатор
выбор-неявного-целевого-поля:
      селектор поля
проекция:
      основное-выражение обязательная-проекция
      основное-выражение необязательная-проекция
обязательная-проекция:
      [список-обязательных-селекторов]
необязательная проекция:
      [список-обязательных-селекторов] ?
список-обязательных-селекторов:
      селектор-обязательного-поля
      список-обязательных-селекторов,селектор-обязательного-поля
неявная-целевая-проекция:
      обязательная-проекция
      необязательная-проекция

Простейшая форма доступа к полю — это обязательный выбор поля. Он использует оператор x[y] для поиска поля в записи по имени поля. Если поле y не существует x, возникает ошибка. x[y]? Форма используется для выполнения необязательного выбора поля и возвращаетсяnull, если запрошенное поле не существует в записи.

Например:

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

Коллективный доступ к нескольким полям поддерживается операторами для обязательной проекции записей и необязательной проекции записей. Оператор x[[y1],[y2],...] проектируют запись в новую запись с меньшим количеством полей (выбранным параметром y1, y2). ... Если выбранное поле не существует, возникает ошибка. Оператор x[[y1],[y2],...] проектируют запись в новую запись с полями, выбранными y1параметром , ...y2; если поле отсутствует, null используется вместо него. Например:

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

Формы [y] и [y]? поддерживаются в качестве краткой ссылки на идентификатор _ (подчеркивание). Следующие два выражения эквивалентны:

[A]                 
_[A]

В следующем примере показана сокращенная форма доступа к полю:

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

[[y1],[y2],...] Форма и [[y1],[y2],...]? также поддерживаются как сокращенные и следующие два выражения также эквивалентны:

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

Сокращенная форма особенно полезна в сочетании с each сокращенной, способом ввести функцию одного параметра с именем _ (дополнительные сведения см . в упрощенных объявлениях. Вместе два коротких выражения упрощают распространенные функциональные выражения более высокого порядка:

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

Приведенное выше выражение эквивалентно следующему более криптографическому просмотру:

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

Доступ к полям не принудительно выполняет оценку полей, отличных от доступа к полям. Например:

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

В следующих случаях при оценке оператора x[y]x[y]?x[[y]]доступа к полю или x[[y]]? оценки:

  • Ошибки, возникающие при оценке выражения x , распространяются.

  • Ошибки, возникающие при оценке поля, постоянно связаны с полем yy, а затем распространяются. Любой будущий доступ к полю y приведет к той же ошибке.

  • Выражение x создает запись или табличное значение, или возникает ошибка.

  • Если идентификатор y именуется поле, которое не существует x, возникает ошибка с кодом "Expression.Error" причины, если не используется необязательная форма ...? оператора, в этом случае возвращается значение null .

Ни один из полей, отличных от x именованного y , вычисляется во время процесса доступа к полям.

Оператор метаданных

Запись метаданных для значения изменяется с помощью мета-оператора (x meta y).

выражение-метаданных:
      unary-expression
      унарное-выражениеmetaунарное-выражение

В следующем примере создается текстовое значение с записью метаданных с помощью meta оператора, а затем получает доступ к записи метаданных результирующего значения с помощью Value.Metadata:

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

В следующих случаях при применении оператора x meta yобъединения метаданных:

  • Ошибки, возникающие при оценке выражений x , y распространяются.

  • Выражение y должно быть записью или возникает ошибка с кодом "Expression.Error" причины.

  • Результирующая запись метаданных — xэто запись метаданных, объединенная с y. (Семантика слияния записей см. в разделе .Запись слияния.)

  • Результирующее значение — это значение из x выражения без его метаданных, при этом только что вычисляемая запись метаданных подключена.

Стандартные функции Value.RemoveMetadata библиотеки и Value.ReplaceMetadata могут использоваться для удаления всех метаданных из значения и замены метаданных значения (а не слияния метаданных в возможно существующие метаданные). Следующие выражения эквивалентны:

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

Операторы равенства

Оператор равенства= используется для определения равенства двух значений. Оператор неравенства<> используется для определения неравенства двух значений.

выражение-равенства:
      relational-expression
      выражение-отношения=выражение-равенства
      выражение-отношения<>выражение-равенства

Например:

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

Метаданные не являются частью сравнения равенства или неравенства. Например:

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

При применении операторов x = y равенства и x <> y:

  • Ошибки, возникающие при оценке выражений x , y распространяются.

  • Оператор = имеет результат, true если значения равны и false в противном случае.

  • Оператор <> имеет результат, false если значения равны и true в противном случае.

  • Записи метаданных не включаются в сравнение.

  • Если значения, созданные путем x вычисления выражений y , не совпадают с типом значения, то значения не равны.

  • Если значения, созданные при оценке x выражения, y совпадают с типом значения, существуют определенные правила для определения того, равны ли они, как определено ниже.

  • Следующее выражение всегда является истинным.

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

Операторы равенства определяются для следующих типов:

  • Значение null равно только самому себе.
    null = null    // true 
    null = true    // false 
    null = false   // false
  • Логические значения true и false равны только себе. Например:
    true = true      // true 
    false = false    // true 
    true = false     // false 
    true = 1         // false

  • Числа сравниваются с помощью указанной точности:

    • Если любое число равно #nan, то числа не совпадают.

    • Если ни число не равно #nan, то числа сравниваются с помощью битового сравнения числового значения.

    • #nan — единственное значение, которое не равно самому себе.

      Например:

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

  • Две длительности равны, если они представляют одинаковое число 100-наносекунд галок.

  • Два раза равны, если величины их частей (час, минута, вторая) равны.

  • Две даты равны, если величины их частей (год, месяц, день) равны.

  • Два значения даты равны, если величины их частей (год, месяц, день, час, минута, вторая) равны.

  • Два даты и времени равны, если соответствующие даты и времени UTC равны. Чтобы прибыть в соответствующее время в формате UTC, смещение часов и минут вычитается из компонента datetimezone.

  • Два текстовых значения равны при использовании порядкового номера, учета регистра, нечувствительного к языку и региональных параметров, они имеют одинаковую длину и равные символы в соответствующих позициях.

  • Два значения списка равны, если все из следующих значений имеют значение true:

    • Оба списка содержат одинаковое количество элементов.

    • Значения каждого позиционально соответствующего элемента в списках равны. Это означает, что не только списки должны содержать равные элементы, элементы должны находиться в одном порядке.

      Например:

        {1, 2} = {1, 2}     // true 
  {2, 1} = {1, 2}     // false 
  {1, 2, 3} = {1, 2}  // false

  • Две записи равны, если все из следующих значений имеют значение true:

    • Число полей совпадает.

    • Каждое имя поля одной записи также присутствует в другой записи.

    • Значение каждого поля одной записи равно аналогичному полю в другой записи.

      Например:

        [ 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

  • Две таблицы равны, если все из следующих значений имеют значение true:

    • Число столбцов совпадает.

    • Каждое имя столбца в одной таблице также присутствует в другой таблице.

    • Число строк совпадает.

    • Каждая строка имеет равные значения в соответствующих ячейках.

      Например:

        #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

  • Значение функции равно самому себе, но может быть или не равно другому значению функции. Если два значения функции считаются равными, они будут вести себя одинаково при вызове.

    Два заданных значения функции всегда будут иметь одинаковые отношения равенства.

  • Значение типа равно самому себе, но может или не равно другому значению типа. Если два значения типа считаются равными, они будут вести себя одинаково при запросе на соответствие.

    Два заданных значения типа всегда будут иметь одинаковые отношения равенства.

Реляционные операторы

Операторы <, <=>и >= операторы называются реляционными операторами.

выражение-отношения:
      additive-expression
      выражение-сложения<выражение-отношения
      выражение-сложения>выражение-отношения
      выражение-сложения<= _выражение-отношения
      выражение-сложения >=выражение-отношения

Эти операторы используются для определения относительной упорядочения между двумя значениями, как показано в следующей таблице:

Операция Результат
x < y true Значение , если x меньше y, false в противном случае
x > y trueЗначение , yесли x больше , false в противном случае
x <= y true Значение x меньше или равно y, false в противном случае
x >= y true Значение , если x больше или равно y, false в противном случае

Например:

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

При оценке выражения, содержащего реляционные операторы, следует учитывать следующее:

  • Ошибки, возникающие при оценке выражений x или y операндов, распространяются.

  • Значения, созданные при xy вычислении как выражений, должны быть двоичными, датами, датой, временем, длительностью, логическим, числом, значением null, текстом или временем. В противном случае возникает ошибка с кодом "Expression.Error" причины.

  • Оба операнда должны быть одинаковыми или nullодинаковыми. В противном случае возникает ошибка с кодом "Expression.Error" причины.

  • Если оба операнда nullявляются, результатом является null значение.

  • Два двоичных файла сравниваются байтами байтов.

  • Две даты сравниваются по сравнению с их частями года и, если равны, их месяцы и, если равны, их дни.

  • Два даты и времени сравниваются по сравнению с частями года и, если равны, их месяцы и, если равны, их дневные части и, если равны, их часовые части и, если равны, их минутные части и, если равны, их второй части.

  • Два даты и времени сравниваются путем нормализации их с UTC, вычитая их смещение часа в минуту, а затем сравнивая их компоненты даты и времени.

  • По сравнению с общим количеством 100-наносекундных тиков, которые они представляют, сравниваются с двумя длительностью.

  • Два логических выражения сравниваются таким образом, что true считается больше false.

  • Два числа x и y сравниваются в соответствии с правилами стандарта IEEE 754:

    • Если один из операндов является #nanрезультатом false для всех реляционных операторов.

    • Если ни операнды, операторы сравнивают значения двух операндов #nanс плавающей запятой относительно порядка -∞ < -max < ... < -min < -0.0 = +0.0 < +min < ... < +max < +∞ , где минимальное и максимальное значение являются наименьшими и самыми большими положительными конечными значениями, которые могут быть представлены. Имена M для -∞ и +∞.-#infinity#infinity

      Важные эффекты этого упорядочения:

      • Отрицательные и положительные нули считаются равными.

      • -#infinity Значение считается меньше всех остальных значений чисел, но равно другому-#infinity.

      • #infinity Значение считается больше всех остальных значений чисел, но равно другому#infinity.

  • Два текста сравниваются с помощью порядкового порядкового номера символов, учета регистра и региональных параметров.

  • Два раза сравниваются путем сравнения их часовых частей и, если равны, их минутные части и, если равны, их второй части.

Условные логические операторы

or Операторы and называются условными логическими операторами.

выражение-логического-ИЛИ:
      выражение-логического-И
выражение-логического-Иorвыражение-логического-ИЛИ
выражение-логического-И:
      выражение-is
      выражение-isandвыражение-логического-И

Оператор or возвращает true по крайней мере один из операндов true. Правый операнд оценивается, если и только если левый операнд не trueявляется.

Оператор and возвращает false по крайней мере один из операндов false. Правый операнд оценивается, если и только если левый операнд не falseявляется.

Таблицы истины для orand операторов показаны ниже, с результатом оценки левого операнда на вертикальной оси и результатом оценки правого операнда на горизонтальной оси.

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

При оценке выражения, содержащего условные логические операторы, следует учитывать следующее:

  • Ошибки, возникающие при оценке выражений x , y распространяются.

  • Условные логические операторы определяются по типам logical и null. Если значения операнда не относятся к этим типам, возникает ошибка с кодом "Expression.Error" причины.

  • Результатом является логическое значение.

  • В выражении x или yy выражение будет оцениваться только в том случае, если x оно не оцениваетсяtrue.

  • В выражении и выражение будет оцениваться только в том случае, если x оно не вычисляетсяfalse.yyx

Последние два свойства дают условным логическим операторам их "условный" квалификацию; свойства также называются "коротким замыканием". Эти свойства полезны для записи компактных защищенных предикатов. Например, следующие выражения эквивалентны:

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

Арифметические операторы

-* Операторы +, и / операторы являются арифметическими операторами.

выражение-сложения:
      multiplicative-expression
      выражение-сложения+выражение-умножения
      выражение-сложения-выражение-умножения
выражение-умножения:
      выражение-метаданных
      выражение-умножения*выражение-метаданных
      выражение-умножения/выражение-метаданных

Точность

Числа в M хранятся с помощью различных представлений для хранения максимальной информации о числах, поступающих из различных источников. Числа преобразуются только из одного представления в другое по мере необходимости операторами, примененными к ним. В M поддерживаются две точности:

Точность Семантика
Precision.Decimal 128-разрядное десятичное представление с диапазоном от ±1,0 x 10-28 до ±7,9 x 10-28 и 28-29 значащими цифрами.
Precision.Double Научное представление с помощью мантиссы и экспонента; соответствует 64-разрядной двоичной двойной точности IEEE 754 арифметического стандарта IEEE 754-2008.

Арифметические операции выполняются путем выбора точности, преобразования обоих операндов в эту точность (при необходимости), а затем выполнения фактической операции и, наконец, возвращения числа в выбранной точности.

Встроенные арифметические операторы (+, , -) */используют двойную точность. Стандартные функции библиотеки (Value.Add, Value.Subtract, Value.Multiply) Value.Divideможно использовать для запроса этих операций с помощью определенной модели точности.

  • Числовой переполнение невозможно: #infinity или -#infinity представлять значения слишком больших величин, которые должны быть представлены.

  • Числовой поток не может быть возможным: 0 и -0 представляет значения слишком небольших значений, которые должны быть представлены.

  • Специальное значение IEEE 754 #nan (NaN — "не является числом") используется для выявления арифметически недопустимых вариантов, таких как деление ноля на ноль.

  • Преобразование из десятичного и двойного точности выполняется путем округления десятичных чисел до ближайшего эквивалентного двойного значения.

  • Преобразование из Double в десятичную точность выполняется путем округления двойных чисел до ближайшего эквивалентного десятичного значения и при необходимости переполнения #infinity или -#infinity значений.

оператор сложения

Интерпретация оператора сложения (x + y) зависит от типа вычисляемых выражений x и y, как показано ниже.

x y Результат Интерпретация
type number type number type number Числовая сумма
type number null null
null type number null
type duration type duration type duration Числовая сумма величины
type duration null null
null type duration null
typedatetime type duration typedatetime Смещение даты и времени по длительности
type duration typedatetime typedatetime
typedatetime null null
null typedatetime null

В таблице typedatetime обозначает type date, type datetime, type datetimezone или type time. При добавлении длительности и значения определенного типа datetime результирующее значение имеет тот же тип.

Для других сочетаний значений, отличных от перечисленных в таблице, возникает ошибка с кодом "Expression.Error" причины. Каждая комбинация рассматривается в следующих разделах.

Ошибки, возникающие при оценке операнда, распространяются.

Числовая сумма

Сумма двух чисел вычисляется с помощью оператора сложения, создающего число.

Например:

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

Оператор сложения + по числам использует двойную точность. Стандартная функция Value.Add библиотеки может использоваться для указания десятичной точности. В следующих случаях при вычислении суммы чисел:

  • Сумма в двойной точности вычисляется в соответствии с правилами 64-разрядного двоичного двоичного двойника IEEE 754 арифметического IEEE 754-2008. В следующей таблице перечислены результаты всех возможных сочетаний ненулевого конечного значения, нули, неопределенных значений и naN. В таблице x и y являются конечными значениями ненулевого значения и z являются результатом x + y. Если x и y имеют ту же величину, но противоположные признаки, z является положительным нулем. Если x + y слишком большой для представления в целевом типе, z то это бесконечность с тем же знаком, что x + yи .

    + y +0 0– +∞ -∞ Не число
    x z x x +∞ -∞ Не число
    +0 y +0 +0 +∞ -∞ Не число
    -0 y +0 0– +∞ -∞ Не число
    +∞ +∞ +∞ +∞ +∞ Не число Не число
    -∞ -∞ -∞ -∞ Не число -∞ Не число
    Nan Не число Не число Не число Не число Не число Не число

  • Сумма в десятичной точности вычисляется без потери точности. Масштаб результата — это больше масштабов двух операндов.

Сумма длительности

Сумма двух длительности — это длительность, представляющая сумму числа 100наносеконд, представленных длительностью. Например:

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

Смещение даты и времени по длительности

Значение datetimex и длительность y можно сложить с помощью x + y, чтобы вычислить новое значение datetime, которое находится от x на линейной временной шкале на расстоянии y. Здесь дата и время имеет любой тип Date, DateTimeDateTimeZoneили Time результат, отличный от NULL. Смещение даты и времени может быть вычислено следующим образом:

  • Если дата и время с момента указания значения эпохи, создайте новое время даты и времени со следующими элементами информации:

    • Вычислите новые дни с эпохи, эквивалентной делении величины y на число 100-наносекунд в течение 24-часового периода, усечение десятичной части результата и добавление этого значения в дни x с эпохи.

    • Вычислите новые галочки с полночью эквивалента добавлению величины y к тикам x с полуночи, модулировать число 100-наносекунд в течение 24-часового периода. Если x не указывает значение для галок с полуночи, предполагается значение 0.

    • Скопируйте значение x для смещения минут из UTC без изменений.

  • Если дни даты и времени с момента значения эпохи не указаны, создайте новое время даты и времени со следующими элементами информации:

    • Вычислите новые галочки с полночью эквивалента добавлению величины y к тикам x с полуночи, модулировать число 100-наносекунд в течение 24-часового периода. Если x не указывает значение для галок с полуночи, предполагается значение 0.

    • Скопируйте значения x в течение нескольких дней с момента смещения эпохи и минут от UTC без изменений.

В следующих примерах показано вычисление абсолютной временной суммы, когда дата и время указывает дни с эпохи:

#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

В следующем примере показано вычисление смещения даты и времени в течение заданного времени:

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

оператор вычитания

Интерпретация оператора вычитания (x - y) зависит от типа вычисляемых выражений x и yследующим образом:

x Y Результат Интерпретация
type number type number type number Числовое различие
type number null null
null type number null
type duration type duration type duration Числовое различие величин
type duration null null
null type duration null
typedatetime typedatetime type duration Длительность между датами и временем
typedatetime type duration typedatetime Смещение даты и времени на отрицание длительности
typedatetime null null
null typedatetime null

В таблице typedatetime обозначает type date, type datetime, type datetimezone или type time. При вычитание длительности из значения определенного типа datetime результирующее значение имеет тот же тип.

Для других сочетаний значений, отличных от перечисленных в таблице, возникает ошибка с кодом "Expression.Error" причины. Каждая комбинация рассматривается в следующих разделах.

Ошибки, возникающие при оценке операнда, распространяются.

Числовое различие

Разница между двумя числами вычисляется с помощью оператора вычитания, создающего число. Например:

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

Оператор вычитания - по числам использует двойную точность; стандартная функция Value.Subtract библиотеки может использоваться для указания десятичной точности. В следующих случаях при вычислении разницы чисел:

  • Разница в двойной точности вычисляется в соответствии с правилами 64-разрядной двоичной двойной точности IEEE 754 арифметической IEEE 754-2008. В следующей таблице перечислены результаты всех возможных сочетаний ненулевого конечного значения, нули, неопределенных значений и naN. В таблице x и y являются конечными значениями ненулевого значения и z являются результатом x - y. Если x и y равны, z положительный нуль. Если x - y слишком большой для представления в целевом типе, z то это бесконечность с тем же знаком, что x - yи .

    - y +0 0– +∞ -∞ Не число
    x z x x -∞ +∞ Не число
    +0 -y +0 +0 -∞ +∞ Не число
    -0 -y 0– +0 -∞ +∞ Не число
    +∞ +∞ +∞ +∞ Не число +∞ Не число
    -∞ -∞ -∞ -∞ -∞ Не число Не число
    Nan Не число Не число Не число Не число Не число Не число

  • Разница в десятичной точности вычисляется без потери точности. Масштаб результата — это больше масштабов двух операндов.

Разница длительности

Разница в двух длительности — это длительность, представляющая разницу между числом 100-наносекунд, представленных каждой длительностью. Например:

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

Смещение даты и времени на отрицание длительности

Из значения datetimex можно вычесть длительность y с помощью x - y для вычисления нового значения datetime. Здесь дата и время обозначает любой из date, datetimedatetimezoneили time. Результат даты и времени имеет расстояние от x линейного временная шкала, что именно величинаy, в направлении, противоположном знакуy. Вычитание положительных длительности дает результаты, которые возвращаются назад во времени относительно x, а вычитание отрицательных значений дает результаты, которые перенаправляются во времени.

#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

Длительность между двумя датами и временем

Два значения datetimet и u можно вычесть друг из друга с помощью t - u, чтобы вычислить значение длительности между ними. Здесь дата и время обозначает любой из date, datetimedatetimezoneили time. Длительность, созданная путем вычитания u из t нее, должна быть получена t при добавлении 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 при u > t получении отрицательной длительности:

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

При вычитания двух дат и времени используется t - uследующее:

  • u + (t - u) = t

оператор умножения

Интерпретация оператора умножения (x * y) зависит от типа вычисляемых выражений x и y, как показано ниже.

X Y Результат Интерпретация
type number type number type number Числовое произведение
type number null null
null type number null
type duration type number type duration Несколько длительности
type number type duration type duration Несколько длительности
type duration null null
null type duration null

Для других сочетаний значений, отличных от перечисленных в таблице, возникает ошибка с кодом "Expression.Error" причины. Каждая комбинация рассматривается в следующих разделах.

Ошибки, возникающие при оценке операнда, распространяются.

Числовое произведение

Продукт из двух чисел вычисляется с помощью оператора умножения, создающего число. Например:

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

Оператор умножения * по числам использует двойную точность. Стандартная функция Value.Multiply библиотеки может использоваться для указания десятичной точности. В следующих случаях при вычислении продукта чисел:

  • Продукт в Double Precision вычисляется в соответствии с правилами 64-разрядной двоичной двойной точности IEEE 754 арифметической IEEE 754-2008. В следующей таблице перечислены результаты всех возможных сочетаний ненулевого конечного значения, нули, неопределенных значений и naN. В таблице x и y являются положительными конечными значениями. zx * yрезультат . Если результат слишком велик для целевого типа, z бесконечность. Если результат слишком мал для типа назначения, z равно нулю.

    * +y -y +0 0– +∞ -∞ Не число
    +x +z -Z +0 0– +∞ -∞ Не число
    -x -Z +z 0– +0 -∞ +∞ Не число
    +0 +0 0– +0 0– Не число Не число Не число
    -0 0– +0 0– +0 Не число Не число Не число
    +∞ +∞ -∞ Не число Не число +∞ -∞ Не число
    -∞ -∞ +∞ Не число Не число -∞ +∞ Не число
    Nan Не число Не число Не число Не число Не число Не число Не число

  • Продукт в десятичной точности вычисляется без потери точности. Масштаб результата — это больше масштабов двух операндов.

Несколько длительности

Произведение длительности и числа — это длительность, представляющая число 1000 тиков, представленных длительностью операнды, число операндов. Например:

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

оператор деления

Интерпретация оператора деления (x / y) зависит от типа вычисляемых выражений x и yследующим образом:

X Y Результат Интерпретация
type number type number type number Числовой кавыч
type number null null
null type number null
type duration type number type duration Доля длительности
type duration type duration type duration Числовое значение длительности
type duration null null
null type duration null

Для других сочетаний значений, отличных от перечисленных в таблице, возникает ошибка с кодом "Expression.Error" причины. Каждая комбинация рассматривается в следующих разделах.

Ошибки, возникающие при оценке операнда, распространяются.

Числовой кавыч

Коэффициент двух чисел вычисляется с помощью оператора деления, создающего число. Например:

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

Оператор / деления по числам использует двойную точность. Стандартная функция Value.Divide библиотеки может использоваться для указания десятичной точности. В следующих случаях при вычислении квотиента чисел:

  • Коэффициент в двойной точности вычисляется в соответствии с правилами 64-разрядной двойной точности IEEE 754 арифметической IEEE 754-2008. В следующей таблице перечислены результаты всех возможных сочетаний ненулевого конечного значения, нули, неопределенных значений и naN. В таблице x и y являются положительными конечными значениями. zx / yрезультат . Если результат слишком велик для целевого типа, z бесконечность. Если результат слишком мал для типа назначения, z равно нулю.

    / +y -y +0 0– +∞ -∞ Не число
    +x +z -Z +∞ -∞ +0 0– Не число
    -x -Z +z -∞ +∞ 0– +0 Не число
    +0 +0 0– Не число Не число +0 0– Не число
    -0 0– +0 Не число Не число 0– +0 Не число
    +∞ +∞ -∞ +∞ -∞ Не число Не число Не число
    -∞ -∞ +∞ -∞ +∞ Не число Не число Не число
    Nan Не число Не число Не число Не число Не число Не число Не число

  • Сумма в десятичной точности вычисляется без потери точности. Масштаб результата — это больше масштабов двух операндов.

Кворент длительности

Кворот из двух длительности — это число, представляющее кворот числа 1000 нэносеконд, представленных длительностью. Например:

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

Масштабируемые длительности

Цитент длительности x и числа y — это длительность, представляющая кворот числа 100-наносекунд, представленных x длительностью и числом y. Например:

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

Сочетание структуры

Оператор сочетания (x & y) определяется по следующим типам значений:

X Y Результат Интерпретация
type text type text type text Объединение
type text null null
null type text null
type date type time type datetime Слияние
type date null null
null type time null
type list type list type list Объединение
type record type record type record Слияние
type table type table type table Объединение

Объединение

Два текста, два списка или два значения таблицы можно объединить с помощью x & y.

В следующем примере показано объединение текстовых значений:

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

В следующем примере показано объединение списков:

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

При объединениях двух значений используется x & yследующее:

  • Ошибки, возникающие при оценке выражений x , y распространяются.

  • Ошибка не распространяется, если элемент либо xy содержит ошибку.

  • Результат объединения двух текстовых значений — текстовое значение, содержащее значение x сразу после y. Если один из операндов имеет значение NULL, а другой — текстовое значение, результат имеет значение NULL.

  • Результат объединения двух списков — это список, содержащий все элементы x , за которыми следует все элементы y.

  • Результат объединения двух таблиц — это таблица с объединением двух столбцов операнда. Порядок столбцов x сохраняется, а затем столбцы отображаются только в y, сохраняя их относительное упорядочение. Для столбцов, отображаемых только в одном из операндов, null используется для заполнения значений ячеек для другого операнда.

Слияние

Слияние записей

Две записи можно объединить с помощью x & y, создав запись, содержащую поля из обоих x и y.

В следующих примерах показано объединение записей:

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

При слиянии двух записей при слиянии двух записей используется x + yследующее:

  • Ошибки, возникающие при оценке выражений x , y распространяются.

  • Если поле отображается как в обоихx, y так и yзначение используется.

  • Порядок полей в результирующей записи состоит в том, что xполя, за которыми не xвходят, y в том же порядке, в который они отображаютсяy.

  • Объединение записей не приводит к оценке значений.

  • Ошибка не возникает, так как поле содержит ошибку.

  • Результатом является запись.

Слияние даты и времени

Дата x может быть объединена с использованием x & yвремениy, создавая дату, которая объединяет части из обоих x иy.

В следующем примере показано объединение даты и времени:

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

При слиянии двух записей при слиянии двух записей используется x + yследующее:

  • Ошибки, возникающие при оценке выражений x , y распространяются.

  • Результатом является дата и время.

Унарные операторы

Операторы +, -и not операторы являются унарными операторами.

унарное-выражение:
      выражение-типа
      +Унарное выражение
      -Унарное выражение
      notУнарное выражение

Оператор унарного плюса

Унарный оператор плюс (+x) определяется для следующих типов значений:

X Результат Интерпретация
type number type number Унарный плюс
type duration type duration Унарный плюс
null 'NULL

Для других значений возникает ошибка с кодом "Expression.Error" причины.

Унарный оператор плюс позволяет применять знак к числу + , дате или значению NULL. Результатом является то же значение. Например:

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

При оценке унарного оператора +xплюс:

  • Ошибки, возникающие при оценке x , распространяются.

  • Если результат оценки x не является числом, возникает ошибка с кодом "Expression.Error" причины.

Оператор унарного минуса

Унарный оператор минус (-x) определяется для следующих типов значений:

X Результат Интерпретация
type number type number Отрицание
type duration type duration Отрицание
null null

Для других значений возникает ошибка с кодом "Expression.Error" причины.

Унарный оператор минус используется для изменения знака числа или длительности. Например:

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

При оценке унарного оператора -xминус:

  • Ошибки, возникающие при оценке x , распространяются.

  • Если выражение является числом, результатом является число из выражения x с измененным знаком. Если значение равно NaN, результат также является NaN.

Оператор логического отрицания

Оператор логического отрицания (not) определяется для следующих типов значений:

X Результат Интерпретация
type logical type logical Отрицание
null null

Этот оператор вычисляет логическую операцию с заданным логическим not значением. Например:

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

При оценке оператора not xлогического отрицания необходимо следующее:

  • Ошибки, возникающие при оценке x , распространяются.

  • Значение, полученное из вычисления выражения x, должно быть логическим значением или ошибкой с кодом "Expression.Error" причины должно быть поднято. Если значение равно true, результатом является false. Если операнд имеет значение false, результатом является true.

Результатом является логическое значение.

Операторы типов

Операторы is и as называются операторами типа.

Оператор совместимости типов

Оператор совместимости типов x is y определяется для следующих типов значений:

X Y Результат
type any тип-примитива-допускающий-значение-NULL type logical

Выражение x is y возвращаетсяtrue, если атрибутизированный тип x совместим с y, и возвращаетсяfalse, если атрибутизированный тип x несовместим.y yдолжен быть примитивным типом, допускаемым значением NULL.

выражение-is:
      выражение-as
      выражение-isisтип-примитива-допускающий-значение-NULL
тип-примитива-допускающий-значение-NULL:
      nullableнеобязательно тип-примитива

Совместимость типов, поддерживаемая is оператором, представляет собой подмножество общего типа совместимости и определяется с помощью следующих правил:

  • Если x значение null, то оно совместимо, если y тип, тип anynullили тип, допускающий значение NULL.

  • Если значение не равно null, то если x оно совместимо, если примитивный тип x совпадает y.

При оценке выражения x is yнеобходимо следующее:

  • Ошибка, возникающая при оценке выражения x , распространяется.

Оператор утверждения типа

Оператор x as y утверждения типа определяется для следующих типов значений:

X Y Результат
type any тип-примитива-допускающий-значение-NULL type any

Выражение x as y утверждает, что значение x совместимо с y оператором is . Если оно несовместимо, возникает ошибка. yдолжен быть типом nullable-primitive.

выражение-as:
      выражение-равенства
      выражение-asasтип-примитива-допускающий-значение-NULL

Выражение x as y вычисляется следующим образом:

  • Выполняется проверка x is y совместимости типов, и утверждение возвращает x без изменений, если этот тест выполнен успешно.

  • Если проверка совместимости завершается ошибкой, возникает ошибка с кодом "Expression.Error" причины.

Примеры:

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

При оценке выражения x as yнеобходимо следующее:

  • Ошибка, возникающая при оценке выражения x , распространяется.

Оператор объединения

Оператор объединения ?? возвращает результат своего левого операнда, если он не равен NULL, в противном случае возвращается результат правого операнда. Правый операнд вычисляется только в том случае, если левый операнд равен NULL.