Numeric field types in Elasticsearch - Mini Project: Build & Apply

Numeric Field Types in Elasticsearch

📖 Scenario: You are setting up an Elasticsearch index to store product information. Each product has a price and a quantity in stock. You want to use the correct numeric field types to store these values efficiently and correctly.

🎯 Goal: Create an Elasticsearch index mapping that defines numeric fields for price and quantity. Then add a document with sample values and retrieve it to see the stored data.

📋 What You'll Learn

Create an index mapping with price as a float field

Create an index mapping with quantity as an integer field

Index a sample document with price 19.99 and quantity 100

Retrieve and print the stored document

💡 Why This Matters

🌍 Real World

Numeric fields in Elasticsearch are used to store numbers like prices, quantities, and IDs efficiently. Choosing the right numeric type helps with performance and storage.

💼 Career

Understanding numeric field types is important for roles like data engineers, backend developers, and search specialists who design and maintain Elasticsearch indexes.

1

Create the index mapping with numeric fields

Create an index mapping called products with a properties object that defines price as a float field and quantity as an integer field.

Elasticsearch

{
  "mappings": {
    "properties": {
      // Define price and quantity fields here
    }
  }
}

Hint

Use "type": "float" for price and "type": "integer" for quantity inside properties.

2

Add a sample document to the index

Create a JSON document with price set to 19.99 and quantity set to 100 to index into the products index.

Elasticsearch

{
  "price": 0.0,
  "quantity": 0
  // Your code here
}

Hint

Set "price" to 19.99 and "quantity" to 100 in the document.

3

Index the document using Elasticsearch API

Use the Elasticsearch index API to add the document with price 19.99 and quantity 100 to the products index.

Elasticsearch

// Use the index API call here
// Your code here

Hint

Use PUT /products to create the index and PUT /products/_doc/1 to add the document.

4

Retrieve and print the stored document

Use the Elasticsearch GET API to retrieve the document with ID 1 from the products index and print the _source field showing price and quantity.

Elasticsearch

// Use GET API to retrieve document and print _source
// Your code here

Hint

Use GET /products/_doc/1 to retrieve the document and check the _source field.

Practice

1.

Which numeric field type in Elasticsearch should you use to store whole numbers without decimals?

easy

A. double

B. integer

C. float

D. text

Solution

1. Step 1: Understand numeric field types

   Integer type stores whole numbers without decimals, suitable for counts or IDs.

2. Step 2: Compare with other types

   Float and double store decimal numbers; text is for strings, not numbers.

3. Final Answer:

   integer -> Option B

4. Quick Check:

   Whole numbers = integer [OK]

Hint: Whole numbers use integer type, decimals need float/double [OK]

Common Mistakes:

• Choosing float or double for whole numbers
• Using text type for numbers
• Confusing integer with long for small numbers

2.

Which of the following is the correct way to define a long numeric field in an Elasticsearch mapping?

{
  "mappings": {
    "properties": {
      "user_id": {
        "type": "_____"
      }
    }
  }
}

easy

A. "long"

B. "integer"

C. "float"

D. "keyword"

Solution

1. Step 1: Identify the field type for large whole numbers

   Long type stores larger whole numbers than integer, suitable for big IDs.

2. Step 2: Match the correct type string in mapping

   Use "long" as the type value in the mapping JSON for such fields.

3. Final Answer:

   "long" -> Option A

4. Quick Check:

   Big whole numbers = "long" [OK]

Hint: Use "long" for large whole numbers in mapping [OK]

Common Mistakes:

• Using "integer" for very large numbers
• Using "keyword" which is for text
• Using "float" for whole numbers

3.

Given this Elasticsearch mapping snippet, what type of number can price store?

{
  "mappings": {
    "properties": {
      "price": {
        "type": "float"
      }
    }
  }
}

medium

A. Boolean true/false values

B. Only whole numbers

C. Text values representing numbers

D. Decimal numbers with floating point

Solution

1. Step 1: Check the type assigned to price

   The type is "float", which stores decimal numbers with floating point precision.

2. Step 2: Understand what float means

   Float allows decimals, unlike integer or long which store whole numbers only.

3. Final Answer:

   Decimal numbers with floating point -> Option D

4. Quick Check:

   Float type = decimals allowed [OK]

Hint: Float type stores decimal numbers, not just whole numbers [OK]

Common Mistakes:

• Thinking float stores only whole numbers
• Confusing float with text or boolean
• Assuming float stores exact decimal precision always

4.

What is wrong with this Elasticsearch mapping for a numeric field?

{
  "mappings": {
    "properties": {
      "score": {
        "type": "integer",
        "index": "not_analyzed"
      }
    }
  }
}

medium

A. 'type' should be 'float' instead of 'integer'

B. 'score' field name is not allowed

C. 'index' parameter is invalid for numeric fields

D. Mapping syntax is missing a closing brace

Solution

1. Step 1: Review the 'index' parameter usage

   Numeric fields do not support 'index' with 'not_analyzed'; this is for text fields.

2. Step 2: Confirm correct mapping for numeric fields

   Numeric fields are indexed by default and do not use 'not_analyzed'.

3. Final Answer:

   'index' parameter is invalid for numeric fields -> Option C

4. Quick Check:

   Numeric fields don't use 'index': 'not_analyzed' [OK]

Hint: Don't use 'index':'not_analyzed' on numeric fields [OK]

Common Mistakes:

• Using text field options on numeric fields
• Changing type unnecessarily
• Ignoring Elasticsearch mapping syntax rules

5.

You want to store product weights that can be very large and may have decimals. Which Elasticsearch numeric field type is best?

hard

A. double

B. long

C. float

D. integer

Solution

1. Step 1: Analyze the requirements for product weights

   Weights can be very large and have decimals, so the type must support large range and decimals.

2. Step 2: Compare float and double types

   Float supports decimals but has less precision and smaller range than double.

3. Step 3: Choose the best type for large decimal numbers

   Double supports large decimal numbers with higher precision, suitable for weights.

4. Final Answer:

   double -> Option A

5. Quick Check:

   Large decimals = double type [OK]

Hint: Use double for large decimal numbers needing precision [OK]

Common Mistakes:

• Choosing integer or long which don't support decimals
• Using float which may lose precision
• Ignoring size and precision needs