Unsigned long field type

Unsigned long field type

Unsigned long is a numeric field type that represents an unsigned 64-bit integer with a minimum value of 0 and a maximum value of 264-1 (from 0 to 18446744073709551615 inclusive).

resp = client.indices.create(
    index="my_index",
    mappings={
        "properties": {
            "my_counter": {
                "type": "unsigned_long"
            }
        }
    },
)
print(resp)

response = client.indices.create(
  index: 'my_index',
  body: {
    mappings: {
      properties: {
        my_counter: {
          type: 'unsigned_long'
        }
      }
    }
  }
)
puts response

const response = await client.indices.create({
  index: "my_index",
  mappings: {
    properties: {
      my_counter: {
        type: "unsigned_long",
      },
    },
  },
});
console.log(response);

PUT my_index
{
  "mappings": {
    "properties": {
      "my_counter": {
        "type": "unsigned_long"
      }
    }
  }
}

Unsigned long can be indexed in a numeric or string form, representing integer values in the range [0, 18446744073709551615]. They can’t have a decimal part.

resp = client.bulk(
    index="my_index",
    refresh=True,
    operations=[
        {
            "index": {
                "_id": 1
            }
        },
        {
            "my_counter": 0
        },
        {
            "index": {
                "_id": 2
            }
        },
        {
            "my_counter": 9223372036854776000
        },
        {
            "index": {
                "_id": 3
            }
        },
        {
            "my_counter": 18446744073709552000
        },
        {
            "index": {
                "_id": 4
            }
        },
        {
            "my_counter": 18446744073709552000
        }
    ],
)
print(resp)

response = client.bulk(
  index: 'my_index',
  refresh: true,
  body: [
    {
      index: {
        _id: 1
      }
    },
    {
      my_counter: 0
    },
    {
      index: {
        _id: 2
      }
    },
    {
      my_counter: 9_223_372_036_854_776_000
    },
    {
      index: {
        _id: 3
      }
    },
    {
      my_counter: 18_446_744_073_709_552_000
    },
    {
      index: {
        _id: 4
      }
    },
    {
      my_counter: 18_446_744_073_709_552_000
    }
  ]
)
puts response

const response = await client.bulk({
  index: "my_index",
  refresh: "true",
  operations: [
    {
      index: {
        _id: 1,
      },
    },
    {
      my_counter: 0,
    },
    {
      index: {
        _id: 2,
      },
    },
    {
      my_counter: 9223372036854776000,
    },
    {
      index: {
        _id: 3,
      },
    },
    {
      my_counter: 18446744073709552000,
    },
    {
      index: {
        _id: 4,
      },
    },
    {
      my_counter: 18446744073709552000,
    },
  ],
});
console.log(response);

POST /my_index/_bulk?refresh
{"index":{"_id":1}}
{"my_counter": 0}
{"index":{"_id":2}}
{"my_counter": 9223372036854775808}
{"index":{"_id":3}}
{"my_counter": 18446744073709551614}
{"index":{"_id":4}}
{"my_counter": 18446744073709551615}

Term queries accept any numbers in a numeric or string form.

resp = client.search(
    index="my_index",
    query={
        "term": {
            "my_counter": 18446744073709552000
        }
    },
)
print(resp)

response = client.search(
  index: 'my_index',
  body: {
    query: {
      term: {
        my_counter: 18_446_744_073_709_552_000
      }
    }
  }
)
puts response

const response = await client.search({
  index: "my_index",
  query: {
    term: {
      my_counter: 18446744073709552000,
    },
  },
});
console.log(response);

GET /my_index/_search
{
    "query": {
        "term" : {
            "my_counter" : 18446744073709551615
        }
    }
}

Range query terms can contain values with decimal parts. In this case Elasticsearch converts them to integer values: gte and gt terms are converted to the nearest integer up inclusive, and lt and lte ranges are converted to the nearest integer down inclusive.

It is recommended to pass ranges as strings to ensure they are parsed without any loss of precision.

resp = client.search(
    index="my_index",
    query={
        "range": {
            "my_counter": {
                "gte": "9223372036854775808",
                "lte": "18446744073709551615"
            }
        }
    },
)
print(resp)

response = client.search(
  index: 'my_index',
  body: {
    query: {
      range: {
        my_counter: {
          gte: '9223372036854775808',
          lte: '18446744073709551615'
        }
      }
    }
  }
)
puts response

const response = await client.search({
  index: "my_index",
  query: {
    range: {
      my_counter: {
        gte: "9223372036854775808",
        lte: "18446744073709551615",
      },
    },
  },
});
console.log(response);

GET /my_index/_search
{
    "query": {
        "range" : {
            "my_counter" : {
                "gte" : "9223372036854775808",
                "lte" : "18446744073709551615"
            }
        }
    }
}

Sort values

For queries with sort on an unsigned_long field, for a particular document Elasticsearch returns a sort value of the type long if the value of this document is within the range of long values, or of the type BigInteger if the value exceeds this range.

REST clients need to be able to handle big integer values in JSON to support this field type correctly.

resp = client.search(
    index="my_index",
    query={
        "match_all": {}
    },
    sort={
        "my_counter": "desc"
    },
)
print(resp)

response = client.search(
  index: 'my_index',
  body: {
    query: {
      match_all: {}
    },
    sort: {
      my_counter: 'desc'
    }
  }
)
puts response

const response = await client.search({
  index: "my_index",
  query: {
    match_all: {},
  },
  sort: {
    my_counter: "desc",
  },
});
console.log(response);

GET /my_index/_search
{
    "query": {
        "match_all" : {}
    },
    "sort" : {"my_counter" : "desc"}
}

Stored fields

A stored field of unsigned_long is stored and returned as String.

Aggregations

For terms aggregations, similarly to sort values, Long or BigInteger values are used. For other aggregations, values are converted to the double type.

Script values

By default, script values of an unsigned_long field are returned as Java signed Long, which means that values that are greater than Long.MAX_VALUE are shown as negative values. You can use Long.compareUnsigned(long, long), Long.divideUnsigned(long, long) and Long.remainderUnsigned(long, long) to correctly work with these values.

For example, the script below returns a value of the counter divided by 10.

resp = client.search(
    index="my_index",
    query={
        "match_all": {}
    },
    script_fields={
        "count10": {
            "script": {
                "source": "Long.divideUnsigned(doc['my_counter'].value, 10)"
            }
        }
    },
)
print(resp)

response = client.search(
  index: 'my_index',
  body: {
    query: {
      match_all: {}
    },
    script_fields: {
      "count10": {
        script: {
          source: "Long.divideUnsigned(doc['my_counter'].value, 10)"
        }
      }
    }
  }
)
puts response

const response = await client.search({
  index: "my_index",
  query: {
    match_all: {},
  },
  script_fields: {
    count10: {
      script: {
        source: "Long.divideUnsigned(doc['my_counter'].value, 10)",
      },
    },
  },
});
console.log(response);

GET /my_index/_search
{
    "query": {
        "match_all" : {}
    },
    "script_fields": {
        "count10" : {
          "script": {
            "source": "Long.divideUnsigned(doc['my_counter'].value, 10)"
          }
        }
    }
}

Alternatively, you can treat the unsigned long type as BigInteger in your scripts by using the field API. For example, this script treats my_counter as BigInteger with a default value of BigInteger.ZERO:

"script": {
    "source": "field('my_counter').asBigInteger(BigInteger.ZERO)"
}

For scripts that need to return float or double values, you can further convert BigInteger values to double or float:

resp = client.search(
    index="my_index",
    query={
        "script_score": {
            "query": {
                "match_all": {}
            },
            "script": {
                "source": "field('my_counter').asBigInteger(BigInteger.ZERO).floatValue()"
            }
        }
    },
)
print(resp)

response = client.search(
  index: 'my_index',
  body: {
    query: {
      script_score: {
        query: {
          match_all: {}
        },
        script: {
          source: "field('my_counter').asBigInteger(BigInteger.ZERO).floatValue()"
        }
      }
    }
  }
)
puts response

const response = await client.search({
  index: "my_index",
  query: {
    script_score: {
      query: {
        match_all: {},
      },
      script: {
        source:
          "field('my_counter').asBigInteger(BigInteger.ZERO).floatValue()",
      },
    },
  },
});
console.log(response);

GET /my_index/_search
{
    "query": {
        "script_score": {
          "query": {"match_all": {}},
          "script": {
            "source": "field('my_counter').asBigInteger(BigInteger.ZERO).floatValue()"
          }
        }
    }
}

Queries with mixed numeric types

Searches with mixed numeric types one of which is unsigned_long are supported, except queries with sort. Thus, a sort query across two indexes where the same field name has an unsigned_long type in one index, and long type in another, doesn’t produce correct results and must be avoided. If there is a need for such kind of sorting, script based sorting can be used instead.

Aggregations across several numeric types one of which is unsigned_long are supported. In this case, values are converted to the double type.