Spec-Zone.ru › Elasticsearch 8
›Elasticsearch Руководство [8.17] ›Отображение ›Типы данных полей

Типы полей диапазонов

Типы полей диапазонов представляют собой непрерывный диапазон значений между верхней и нижней границами. Например, диапазон может представлять любую дату в октябре или любое целое число от 0 до 9. Они определяются с помощью операторов gt или gte для нижней границы и lt или lte для верхней границы. Они могут использоваться для запросов и имеют ограниченную поддержку агрегаций. Поддерживаются только агрегации гистограммы и количества уникальных значений.

Поддерживаются следующие типы диапазонов:

integer_range

Диапазон целых 32-битных знаковых чисел с минимальным значением -231 и максимальным 231-1.

float_range

Диапазон одноточных 32-битных значений с плавающей точкой IEEE 754.

long_range

Диапазон целых 64-битных знаковых чисел с минимальным значением -263 и максимальным 263-1.

double_range

Диапазон двойных 64-битных значений с плавающей точкой IEEE 754.

date_range

Диапазон значений date. Диапазоны дат поддерживают различные форматы дат через параметр отображения format. Независимо от используемого формата, значения дат анализируются в беззнаковое 64-битное целое число, представляющее миллисекунды с момента эпохи Unix в UTC. Значения, содержащие выражение now date math, не поддерживаются.

ip_range

Диапазон значений IP, поддерживающий адреса IPv4 или IPv6 (или смешанные).

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

resp = client.indices.create(
    index="range_index",
    settings={
        "number_of_shards": 2
    },
    mappings={
        "properties": {
            "expected_attendees": {
                "type": "integer_range"
            },
            "time_frame": {
                "type": "date_range",
                "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
            }
        }
    },
)
print(resp)

resp1 = client.index(
    index="range_index",
    id="1",
    refresh=True,
    document={
        "expected_attendees": {
            "gte": 10,
            "lt": 20
        },
        "time_frame": {
            "gte": "2015-10-31 12:00:00",
            "lte": "2015-11-01"
        }
    },
)
print(resp1)
response = client.indices.create(
  index: 'range_index',
  body: {
    settings: {
      number_of_shards: 2
    },
    mappings: {
      properties: {
        expected_attendees: {
          type: 'integer_range'
        },
        time_frame: {
          type: 'date_range',
          format: 'yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis'
        }
      }
    }
  }
)
puts response

response = client.index(
  index: 'range_index',
  id: 1,
  refresh: true,
  body: {
    expected_attendees: {
      gte: 10,
      lt: 20
    },
    time_frame: {
      gte: '2015-10-31 12:00:00',
      lte: '2015-11-01'
    }
  }
)
puts response
const response = await client.indices.create({
  index: "range_index",
  settings: {
    number_of_shards: 2,
  },
  mappings: {
    properties: {
      expected_attendees: {
        type: "integer_range",
      },
      time_frame: {
        type: "date_range",
        format: "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis",
      },
    },
  },
});
console.log(response);

const response1 = await client.index({
  index: "range_index",
  id: 1,
  refresh: "true",
  document: {
    expected_attendees: {
      gte: 10,
      lt: 20,
    },
    time_frame: {
      gte: "2015-10-31 12:00:00",
      lte: "2015-11-01",
    },
  },
});
console.log(response1);
PUT range_index
{
  "settings": {
    "number_of_shards": 2
  },
  "mappings": {
    "properties": {
      "expected_attendees": {
        "type": "integer_range"
      },
      "time_frame": {
        "type": "date_range", 
        "format": "yyyy-MM-dd HH:mm:ss||yyyy-MM-dd||epoch_millis"
      }
    }
  }
}

PUT range_index/_doc/1?refresh
{
  "expected_attendees" : { 
    "gte" : 10,
    "lt" : 20
  },
  "time_frame" : {
    "gte" : "2015-10-31 12:00:00", 
    "lte" : "2015-11-01"
  }
}

Типы date_range принимают те же параметры поля, что и тип date.

Пример индексирования встречи с 10 до 20 участниками, не включая 20.

Пример диапазона дат, использующего временной отметки.

Следующий пример — запрос термина к полю integer_range с именем "expected_attendees". 12 — значение внутри диапазона, поэтому оно будет соответствовать.

resp = client.search(
    index="range_index",
    query={
        "term": {
            "expected_attendees": {
                "value": 12
            }
        }
    },
)
print(resp)
response = client.search(
  index: 'range_index',
  body: {
    query: {
      term: {
        expected_attendees: {
          value: 12
        }
      }
    }
  }
)
puts response
const response = await client.search({
  index: "range_index",
  query: {
    term: {
      expected_attendees: {
        value: 12,
      },
    },
  },
});
console.log(response);
GET range_index/_search
{
  "query" : {
    "term" : {
      "expected_attendees" : {
        "value": 12
      }
    }
  }
}
{
  "took": 13,
  "timed_out": false,
  "_shards" : {
    "total": 2,
    "successful": 2,
    "skipped" : 0,
    "failed": 0
  },
  "hits" : {
    "total" : {
        "value": 1,
        "relation": "eq"
    },
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "range_index",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "expected_attendees" : {
            "gte" : 10, "lt" : 20
          },
          "time_frame" : {
            "gte" : "2015-10-31 12:00:00", "lte" : "2015-11-01"
          }
        }
      }
    ]
  }
}

Ниже приведен пример запроса date_range по полю date_range с именем "time_frame".

resp = client.search(
    index="range_index",
    query={
        "range": {
            "time_frame": {
                "gte": "2015-10-31",
                "lte": "2015-11-01",
                "relation": "within"
            }
        }
    },
)
print(resp)
response = client.search(
  index: 'range_index',
  body: {
    query: {
      range: {
        time_frame: {
          gte: '2015-10-31',
          lte: '2015-11-01',
          relation: 'within'
        }
      }
    }
  }
)
puts response
const response = await client.search({
  index: "range_index",
  query: {
    range: {
      time_frame: {
        gte: "2015-10-31",
        lte: "2015-11-01",
        relation: "within",
      },
    },
  },
});
console.log(response);
GET range_index/_search
{
  "query" : {
    "range" : {
      "time_frame" : { 
        "gte" : "2015-10-31",
        "lte" : "2015-11-01",
        "relation" : "within" 
      }
    }
  }
}

Запросы диапазонов работают так же, как описано в запросе диапазона.

Запросы диапазонов для полей диапазонов поддерживают параметр relation, который может быть WITHIN, CONTAINS или INTERSECTS (по умолчанию).

 
{
  "took": 13,
  "timed_out": false,
  "_shards" : {
    "total": 2,
    "successful": 2,
    "skipped" : 0,
    "failed": 0
  },
  "hits" : {
    "total" : {
        "value": 1,
        "relation": "eq"
    },
    "max_score" : 1.0,
    "hits" : [
      {
        "_index" : "range_index",
        "_id" : "1",
        "_score" : 1.0,
        "_source" : {
          "expected_attendees" : {
            "gte" : 10, "lt" : 20
          },
          "time_frame" : {
            "gte" : "2015-10-31 12:00:00", "lte" : "2015-11-01"
          }
        }
      }
    ]
  }
}

Диапазон IP

В дополнение к вышеуказанному формату диапазонов IP можно указывать в CIDR формате:

resp = client.indices.put_mapping(
    index="range_index",
    properties={
        "ip_allowlist": {
            "type": "ip_range"
        }
    },
)
print(resp)

resp1 = client.index(
    index="range_index",
    id="2",
    document={
        "ip_allowlist": "192.168.0.0/16"
    },
)
print(resp1)
response = client.indices.put_mapping(
  index: 'range_index',
  body: {
    properties: {
      ip_allowlist: {
        type: 'ip_range'
      }
    }
  }
)
puts response

response = client.index(
  index: 'range_index',
  id: 2,
  body: {
    ip_allowlist: '192.168.0.0/16'
  }
)
puts response
const response = await client.indices.putMapping({
  index: "range_index",
  properties: {
    ip_allowlist: {
      type: "ip_range",
    },
  },
});
console.log(response);

const response1 = await client.index({
  index: "range_index",
  id: 2,
  document: {
    ip_allowlist: "192.168.0.0/16",
  },
});
console.log(response1);
PUT range_index/_mapping
{
  "properties": {
    "ip_allowlist": {
      "type": "ip_range"
    }
  }
}

PUT range_index/_doc/2
{
  "ip_allowlist" : "192.168.0.0/16"
}

Параметры для полей диапазонов

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

coerce

Попытаться преобразовать строки в числа и обрезать дроби для целых чисел. Принимает true (по умолчанию) и false.

doc_values

Необходимо ли хранить поле на диске в столбце, чтобы его можно было в дальнейшем использовать для сортировки, агрегаций или сценариев? Принимает true (по умолчанию) или false.

index

Должно ли поле быть поисковым? Принимает true (по умолчанию) и false.

store

Нужно ли хранить значение поля отдельно от поля _source? Принимает true или false (по умолчанию).

Синтетическая _source

Синтетическая _source доступна только для индексов TSDB (индексов, у которых index.mode установлено в значение time_series). Для других индексов синтетическая _source находится в техническом предварительном просмотре. Функции в техническом предварительном просмотре могут быть изменены или удалены в будущих выпусках. Elastic будет работать над устранением любых проблем, но функции в техническом предварительном просмотре не подпадают под SLA поддержки официальных функций GA.

Поля range поддерживают синтетическое _source в их конфигурации по умолчанию.

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

resp = client.indices.create(
    index="idx",
    settings={
        "index": {
            "mapping": {
                "source": {
                    "mode": "synthetic"
                }
            }
        }
    },
    mappings={
        "properties": {
            "my_range": {
                "type": "long_range"
            }
        }
    },
)
print(resp)

resp1 = client.index(
    index="idx",
    id="1",
    document={
        "my_range": [
            {
                "gte": 200,
                "lte": 300
            },
            {
                "gte": 1,
                "lte": 100
            },
            {
                "gte": 200,
                "lte": 300
            },
            {
                "gte": 200,
                "lte": 500
            }
        ]
    },
)
print(resp1)
const response = await client.indices.create({
  index: "idx",
  settings: {
    index: {
      mapping: {
        source: {
          mode: "synthetic",
        },
      },
    },
  },
  mappings: {
    properties: {
      my_range: {
        type: "long_range",
      },
    },
  },
});
console.log(response);

const response1 = await client.index({
  index: "idx",
  id: 1,
  document: {
    my_range: [
      {
        gte: 200,
        lte: 300,
      },
      {
        gte: 1,
        lte: 100,
      },
      {
        gte: 200,
        lte: 300,
      },
      {
        gte: 200,
        lte: 500,
      },
    ],
  },
});
console.log(response1);
PUT idx
{
  "settings": {
    "index": {
      "mapping": {
        "source": {
          "mode": "synthetic"
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "my_range": { "type": "long_range" }
    }
  }
}

PUT idx/_doc/1
{
  "my_range": [
    {
        "gte": 200,
        "lte": 300
    },
    {
        "gte": 1,
        "lte": 100
    },
    {
        "gte": 200,
        "lte": 300
    },
    {
        "gte": 200,
        "lte": 500
    }
  ]
}

Преобразуется в:

{
  "my_range": [
    {
        "gte": 1,
        "lte": 100
    },
    {
        "gte": 200,
        "lte": 300
    },
    {
        "gte": 200,
        "lte": 500
    }
  ]
}

Значения полей ip_range не сортируются, но исходный порядок не сохраняется. Дублирующиеся диапазоны удаляются. Если значение поля ip_range предоставляется как CIDR, оно будет представлено как диапазон IP-адресов в синтетическом источнике.

Например:

resp = client.indices.create(
    index="idx",
    settings={
        "index": {
            "mapping": {
                "source": {
                    "mode": "synthetic"
                }
            }
        }
    },
    mappings={
        "properties": {
            "my_range": {
                "type": "ip_range"
            }
        }
    },
)
print(resp)

resp1 = client.index(
    index="idx",
    id="1",
    document={
        "my_range": [
            "10.0.0.0/24",
            {
                "gte": "10.0.0.0",
                "lte": "10.0.0.255"
            }
        ]
    },
)
print(resp1)
const response = await client.indices.create({
  index: "idx",
  settings: {
    index: {
      mapping: {
        source: {
          mode: "synthetic",
        },
      },
    },
  },
  mappings: {
    properties: {
      my_range: {
        type: "ip_range",
      },
    },
  },
});
console.log(response);

const response1 = await client.index({
  index: "idx",
  id: 1,
  document: {
    my_range: [
      "10.0.0.0/24",
      {
        gte: "10.0.0.0",
        lte: "10.0.0.255",
      },
    ],
  },
});
console.log(response1);
PUT idx
{
  "settings": {
    "index": {
      "mapping": {
        "source": {
          "mode": "synthetic"
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "my_range": { "type": "ip_range" }
    }
  }
}

PUT idx/_doc/1
{
  "my_range": [
    "10.0.0.0/24",
    {
      "gte": "10.0.0.0",
      "lte": "10.0.0.255"
    }
  ]
}

Преобразуется в:

{
  "my_range": {
      "gte": "10.0.0.0",
      "lte": "10.0.0.255"
    }

}

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

resp = client.indices.create(
    index="idx",
    settings={
        "index": {
            "mapping": {
                "source": {
                    "mode": "synthetic"
                }
            }
        }
    },
    mappings={
        "properties": {
            "my_range": {
                "type": "long_range"
            }
        }
    },
)
print(resp)

resp1 = client.index(
    index="idx",
    id="1",
    document={
        "my_range": {
            "gt": 200,
            "lt": 300
        }
    },
)
print(resp1)
const response = await client.indices.create({
  index: "idx",
  settings: {
    index: {
      mapping: {
        source: {
          mode: "synthetic",
        },
      },
    },
  },
  mappings: {
    properties: {
      my_range: {
        type: "long_range",
      },
    },
  },
});
console.log(response);

const response1 = await client.index({
  index: "idx",
  id: 1,
  document: {
    my_range: {
      gt: 200,
      lt: 300,
    },
  },
});
console.log(response1);
PUT idx
{
  "settings": {
    "index": {
      "mapping": {
        "source": {
          "mode": "synthetic"
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "my_range": { "type": "long_range" }
    }
  }
}

PUT idx/_doc/1
{
  "my_range": {
    "gt": 200,
    "lt": 300
  }
}

Преобразуется в:

{
  "my_range": {
    "gte": 201,
    "lte": 299
  }
}

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

resp = client.indices.create(
    index="idx",
    settings={
        "index": {
            "mapping": {
                "source": {
                    "mode": "synthetic"
                }
            }
        }
    },
    mappings={
        "properties": {
            "my_range": {
                "type": "integer_range"
            }
        }
    },
)
print(resp)

resp1 = client.index(
    index="idx",
    id="1",
    document={
        "my_range": {
            "lte": 2147483647
        }
    },
)
print(resp1)
const response = await client.indices.create({
  index: "idx",
  settings: {
    index: {
      mapping: {
        source: {
          mode: "synthetic",
        },
      },
    },
  },
  mappings: {
    properties: {
      my_range: {
        type: "integer_range",
      },
    },
  },
});
console.log(response);

const response1 = await client.index({
  index: "idx",
  id: 1,
  document: {
    my_range: {
      lte: 2147483647,
    },
  },
});
console.log(response1);
PUT idx
{
  "settings": {
    "index": {
      "mapping": {
        "source": {
          "mode": "synthetic"
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "my_range": { "type": "integer_range" }
    }
  }
}

PUT idx/_doc/1
{
  "my_range": {
    "lte": 2147483647
  }
}

Преобразуется в:

{
  "my_range": {
    "gte": null,
    "lte": null
  }
}

Диапазоны date форматируются с использованием предоставленного format или по умолчанию используя формат yyyy-MM-dd'T'HH:mm:ss.SSSZ. Например:

resp = client.indices.create(
    index="idx",
    settings={
        "index": {
            "mapping": {
                "source": {
                    "mode": "synthetic"
                }
            }
        }
    },
    mappings={
        "properties": {
            "my_range": {
                "type": "date_range"
            }
        }
    },
)
print(resp)

resp1 = client.index(
    index="idx",
    id="1",
    document={
        "my_range": [
            {
                "gte": 1504224000000,
                "lte": 1504569600000
            },
            {
                "gte": "2017-09-01",
                "lte": "2017-09-10"
            }
        ]
    },
)
print(resp1)
const response = await client.indices.create({
  index: "idx",
  settings: {
    index: {
      mapping: {
        source: {
          mode: "synthetic",
        },
      },
    },
  },
  mappings: {
    properties: {
      my_range: {
        type: "date_range",
      },
    },
  },
});
console.log(response);

const response1 = await client.index({
  index: "idx",
  id: 1,
  document: {
    my_range: [
      {
        gte: 1504224000000,
        lte: 1504569600000,
      },
      {
        gte: "2017-09-01",
        lte: "2017-09-10",
      },
    ],
  },
});
console.log(response1);
PUT idx
{
  "settings": {
    "index": {
      "mapping": {
        "source": {
          "mode": "synthetic"
        }
      }
    }
  },
  "mappings": {
    "properties": {
      "my_range": { "type": "date_range" }
    }
  }
}

PUT idx/_doc/1
{
  "my_range": [
    {
      "gte": 1504224000000,
      "lte": 1504569600000
    },
    {
      "gte": "2017-09-01",
      "lte": "2017-09-10"
    }
  ]
}

Преобразуется в:

{
  "my_range": [
    {
      "gte": "2017-09-01T00:00:00.000Z",
      "lte": "2017-09-05T00:00:00.000Z"
    },
    {
      "gte": "2017-09-01T00:00:00.000Z",
      "lte": "2017-09-10T23:59:59.999Z"
    }
  ]
}

© 2023-2025 Elasticsearch
As of September 2024, Elasticsearch is available under a choice of three licenses: the Server Side Public License (SSPL), the Elastic License, or the AGPLv3 (OSI approved).
Elasticsearch and the Elasticsearch logo are trademarks of Elasticsearch B.V., registered in the U.S. and in other countries.
https://www.elastic.co/guide/en/elasticsearch/reference/8.17/range.html

Spec-Zone.ru

Настройки Оффлайн Что нового Помощь О нас
Spec-Zone .ru
спецификации, руководства, описания, API