Boolean field type

edit

Boolean fields accept JSON true and false values, but can also accept strings which are interpreted as either true or false:

False values

false, "false", "" (empty string)

True values

true, "true"

For example:

resp = client.indices.create(
    index="my-index-000001",
    mappings={
        "properties": {
            "is_published": {
                "type": "boolean"
            }
        }
    },
)
print(resp)

resp1 = client.index(
    index="my-index-000001",
    id="1",
    refresh=True,
    document={
        "is_published": "true"
    },
)
print(resp1)

resp2 = client.search(
    index="my-index-000001",
    query={
        "term": {
            "is_published": True
        }
    },
)
print(resp2)
response = client.indices.create(
  index: 'my-index-000001',
  body: {
    mappings: {
      properties: {
        is_published: {
          type: 'boolean'
        }
      }
    }
  }
)
puts response

response = client.index(
  index: 'my-index-000001',
  id: 1,
  refresh: true,
  body: {
    is_published: 'true'
  }
)
puts response

response = client.search(
  index: 'my-index-000001',
  body: {
    query: {
      term: {
        is_published: true
      }
    }
  }
)
puts response
const response = await client.indices.create({
  index: "my-index-000001",
  mappings: {
    properties: {
      is_published: {
        type: "boolean",
      },
    },
  },
});
console.log(response);

const response1 = await client.index({
  index: "my-index-000001",
  id: 1,
  refresh: "true",
  document: {
    is_published: "true",
  },
});
console.log(response1);

const response2 = await client.search({
  index: "my-index-000001",
  query: {
    term: {
      is_published: true,
    },
  },
});
console.log(response2);
PUT my-index-000001
{
  "mappings": {
    "properties": {
      "is_published": {
        "type": "boolean"
      }
    }
  }
}

POST my-index-000001/_doc/1?refresh
{
  "is_published": "true" 
}

GET my-index-000001/_search
{
  "query": {
    "term": {
      "is_published": true 
    }
  }
}

Indexing a document with "true", which is interpreted as true.

Searching for documents with a JSON true.

Aggregations like the terms aggregation use 1 and 0 for the key, and the strings "true" and "false" for the key_as_string. Boolean fields when used in scripts, return true and false:

resp = client.index(
    index="my-index-000001",
    id="1",
    refresh=True,
    document={
        "is_published": True
    },
)
print(resp)

resp1 = client.index(
    index="my-index-000001",
    id="2",
    refresh=True,
    document={
        "is_published": False
    },
)
print(resp1)

resp2 = client.search(
    index="my-index-000001",
    aggs={
        "publish_state": {
            "terms": {
                "field": "is_published"
            }
        }
    },
    sort=[
        "is_published"
    ],
    fields=[
        {
            "field": "weight"
        }
    ],
    runtime_mappings={
        "weight": {
            "type": "long",
            "script": "emit(doc['is_published'].value ? 10 : 0)"
        }
    },
)
print(resp2)
response = client.index(
  index: 'my-index-000001',
  id: 1,
  refresh: true,
  body: {
    is_published: true
  }
)
puts response

response = client.index(
  index: 'my-index-000001',
  id: 2,
  refresh: true,
  body: {
    is_published: false
  }
)
puts response

response = client.search(
  index: 'my-index-000001',
  body: {
    aggregations: {
      publish_state: {
        terms: {
          field: 'is_published'
        }
      }
    },
    sort: [
      'is_published'
    ],
    fields: [
      {
        field: 'weight'
      }
    ],
    runtime_mappings: {
      weight: {
        type: 'long',
        script: "emit(doc['is_published'].value ? 10 : 0)"
      }
    }
  }
)
puts response
const response = await client.index({
  index: "my-index-000001",
  id: 1,
  refresh: "true",
  document: {
    is_published: true,
  },
});
console.log(response);

const response1 = await client.index({
  index: "my-index-000001",
  id: 2,
  refresh: "true",
  document: {
    is_published: false,
  },
});
console.log(response1);

const response2 = await client.search({
  index: "my-index-000001",
  aggs: {
    publish_state: {
      terms: {
        field: "is_published",
      },
    },
  },
  sort: ["is_published"],
  fields: [
    {
      field: "weight",
    },
  ],
  runtime_mappings: {
    weight: {
      type: "long",
      script: "emit(doc['is_published'].value ? 10 : 0)",
    },
  },
});
console.log(response2);
POST my-index-000001/_doc/1?refresh
{
  "is_published": true
}

POST my-index-000001/_doc/2?refresh
{
  "is_published": false
}

GET my-index-000001/_search
{
  "aggs": {
    "publish_state": {
      "terms": {
        "field": "is_published"
      }
    }
  },
  "sort": [ "is_published" ],
  "fields": [
    {"field": "weight"}
  ],
  "runtime_mappings": {
    "weight": {
      "type": "long",
      "script": "emit(doc['is_published'].value ? 10 : 0)"
    }
  }
}

Parameters for boolean fields

edit

The following parameters are accepted by boolean fields:

doc_values

Should the field be stored on disk in a column-stride fashion, so that it can later be used for sorting, aggregations, or scripting? Accepts true (default) or false.

index

Should the field be quickly searchable? Accepts true (default) and false. Fields that only have doc_values enabled can still be queried using term or range-based queries, albeit slower.

ignore_malformed

Trying to index the wrong data type into a field throws an exception by default, and rejects the whole document. If this parameter is set to true, it allows the exception to be ignored. The malformed field is not indexed, but other fields in the document are processed normally. Accepts true or false. Note that this cannot be set if the script parameter is used.

null_value

Accepts any of the true or false values listed above. The value is substituted for any explicit null values. Defaults to null, which means the field is treated as missing. Note that this cannot be set if the script parameter is used.

on_script_error

Defines what to do if the script defined by the script parameter throws an error at indexing time. Accepts fail (default), which will cause the entire document to be rejected, and continue, which will register the field in the document’s _ignored metadata field and continue indexing. This parameter can only be set if the script field is also set.

script

If this parameter is set, then the field will index values generated by this script, rather than reading the values directly from the source. If a value is set for this field on the input document, then the document will be rejected with an error. Scripts are in the same format as their runtime equivalent.

store

Whether the field value should be stored and retrievable separately from the _source field. Accepts true or false (default).

meta

Metadata about the field.

Synthetic _source

edit

Synthetic _source is Generally Available only for TSDB indices (indices that have index.mode set to time_series). For other indices synthetic _source is in technical preview. Features in technical preview may be changed or removed in a future release. Elastic will work to fix any issues, but features in technical preview are not subject to the support SLA of official GA features.

boolean fields support synthetic _source in their default configuration. Synthetic _source cannot be used together with copy_to or with doc_values disabled.

Synthetic source always sorts boolean fields. For example:

resp = client.indices.create(
    index="idx",
    mappings={
        "_source": {
            "mode": "synthetic"
        },
        "properties": {
            "bool": {
                "type": "boolean"
            }
        }
    },
)
print(resp)

resp1 = client.index(
    index="idx",
    id="1",
    document={
        "bool": [
            True,
            False,
            True,
            False
        ]
    },
)
print(resp1)
response = client.indices.create(
  index: 'idx',
  body: {
    mappings: {
      _source: {
        mode: 'synthetic'
      },
      properties: {
        bool: {
          type: 'boolean'
        }
      }
    }
  }
)
puts response

response = client.index(
  index: 'idx',
  id: 1,
  body: {
    bool: [
      true,
      false,
      true,
      false
    ]
  }
)
puts response
const response = await client.indices.create({
  index: "idx",
  mappings: {
    _source: {
      mode: "synthetic",
    },
    properties: {
      bool: {
        type: "boolean",
      },
    },
  },
});
console.log(response);

const response1 = await client.index({
  index: "idx",
  id: 1,
  document: {
    bool: [true, false, true, false],
  },
});
console.log(response1);
PUT idx
{
  "mappings": {
    "_source": { "mode": "synthetic" },
    "properties": {
      "bool": { "type": "boolean" }
    }
  }
}
PUT idx/_doc/1
{
  "bool": [true, false, true, false]
}

Will become:

{
  "bool": [false, false, true, true]
}