code: def test_nested_payload_indexing_operations():
      response = request_with_validation(
          api="/collections/{collection_name}",
          method="GET",
          path_params={"collection_name": collection_name},
      )
      assert response.ok
  
      # Create nested index
      response = request_with_validation(
          api="/collections/{collection_name}/index",
          method="PUT",
          path_params={"collection_name": collection_name},
          query_params={"wait": "true"},
          body={
              "field_name": "country.capital",
              "field_schema": "keyword",
          },
      )
      assert response.ok
  
      # Create nested array index
      response = request_with_validation(
          api="/collections/{collection_name}/index",
          method="PUT",
          path_params={"collection_name": collection_name},
          query_params={"wait": "true"},
          body={
              "field_name": "country.cities[].population",
              "field_schema": "float",
          },
      )
      assert response.ok
  
      # Validate index creation
      response = request_with_validation(
          api="/collections/{collection_name}",
          method="GET",
          path_params={"collection_name": collection_name},
      )
      assert response.ok
      assert (
          response.json()["result"]["payload_schema"][
              "country.capital"
          ]["data_type"]
          == "keyword"
      )
      assert (
          response.json()["result"]["payload_schema"][
              "country.capital"
          ]["points"]
          == 4
      )
      assert (
          response.json()["result"]["payload_schema"][
              "country.cities[].population"
          ]["data_type"]
          == "float"
      )
      assert (
          response.json()["result"]["payload_schema"][
              "country.cities[].population"
          ]["points"]
          == 4
      )  # indexed records
  
      # Search nested through with payload index
      response = request_with_validation(
          api="/collections/{collection_name}/points/scroll",
          method="POST",
          path_params={"collection_name": collection_name},
          body={
              "filter": {
                  "should": [
                      {
                          "key": "country.capital",
                          "match": {"value": "London"},
                      }
                  ]
              },
              "limit": 3,
          },
      )
      assert response.ok
      assert len(response.json()["result"]["points"]) == 1
      assert (
          response.json()["result"]["points"][0]["payload"]["country"][
              "name"
          ]
          == "England"
      )
  
      # Search nested without payload index
      response = request_with_validation(
          api="/collections/{collection_name}/points/scroll",
          method="POST",
          path_params={"collection_name": collection_name},
          body={
              "filter": {
                  "should": [
                      {
                          "key": "country.name",
                          "match": {"value": "France"},
                      }
                  ]
              },
              "limit": 3,
          },
      )
      assert response.ok
      assert len(response.json()["result"]["points"]) == 1
      assert (
          response.json()["result"]["points"][0]["payload"]["country"][
              "capital"
          ]
          == "Paris"
      )
  
      # Search through array without payload index
      response = request_with_validation(
          api="/collections/{collection_name}/points/scroll",
          method="POST",
          path_params={"collection_name": collection_name},
          body={
              "filter": {
                  "should": [
                      {
                          "key": "country.cities.population",  # Do not implicitly do inside nested array
                          "range": {
                              "gte": 9.0,
                          },
                      }
                  ]
              },
              "limit": 3,
          },
      )
      assert response.ok
      assert len(response.json()["result"]["points"]) == 0
  
      # Search through array with payload index
      response = request_with_validation(
          api="/collections/{collection_name}/points/scroll",
          method="POST",
          path_params={"collection_name": collection_name},
          body={
              "filter": {
                  "should": [
                      {
                          "key": "country.cities[].population",
                          "range": {
                              "gte": 9.0,
                          },
                      }
                  ]
              },
              "limit": 3,
          },
      )
      assert response.ok
      assert len(response.json()["result"]["points"]) == 1
      # Only Japan has a city with population greater than 9.0
      assert (
          response.json()["result"]["points"][0]["payload"]["country"][
              "name"
          ]
          == "Japan"
      )
  
      # Search through array without payload index
      response = request_with_validation(
          api="/collections/{collection_name}/points/scroll",
          method="POST",
          path_params={"collection_name": collection_name},
          body={
              "filter": {
                  "should": [
                      {
                          "key": "country.cities[].sightseeing",
                          "match": {"value": "Eiffel Tower"},
                      }
                  ]
              },
              "limit": 3,
          },
      )
      assert response.ok
      assert len(response.json()["result"]["points"]) == 1
      assert (
          response.json()["result"]["points"][0]["payload"]["country"][
              "capital"
          ]
          == "Paris"
      )
  
      # Search through array without payload index (indexed on array of objects)
      response = request_with_validation(
          api="/collections/{collection_name}/points/scroll",
          method="POST",
          path_params={"collection_name": collection_name},
          body={
              "filter": {
                  "should": [
                      {
                          "key": "country.cities[0].name",
                          "match": {"value": "Paris"},
                      }
                  ]
              },
              "limit": 3,
          },
      )
      assert response.ok
      assert len(response.json()["result"]["points"]) == 1
      assert (
          response.json()["result"]["points"][0]["payload"]["country"][
              "capital"
          ]
          == "Paris"
      )
  
      # Search through array without payload index (indexed on array of scalars)
      response = request_with_validation(
          api="/collections/{collection_name}/points/scroll",
          method="POST",
          path_params={"collection_name": collection_name},
          body={
              "filter": {
                  "should": [
                      {
                          "key": "country.cities[].sightseeing[1]",
                          "match": {"value": "Louvre"},
                      }
                  ]
              },
              "limit": 3,
          },
      )
      assert response.ok
      assert len(response.json()["result"]["points"]) == 1
      assert (
          response.json()["result"]["points"][0]["payload"]["country"][
              "capital"
          ]
          == "Paris"
      )
  
      # Delete indexes
      response = request_with_validation(
          api="/collections/{collection_name}/index/{field_name}",
          method="DELETE",
          path_params={
              "collection_name": collection_name,
              "field_name": "country.capital",
          },
          query_params={"wait": "true"},
      )
      assert response.ok
  
      response = request_with_validation(
          api="/collections/{collection_name}/index/{field_name}",
          method="DELETE",
          path_params={
              "collection_name": collection_name,
              "field_name": "country.cities[].population",
          },
          query_params={"wait": "true"},
      )
      assert response.ok
  
      response = request_with_validation(
          api="/collections/{collection_name}",
          method="GET",
          path_params={"collection_name": collection_name},
      )
      assert response.ok
      assert len(response.json()["result"]["payload_schema"]) == 0
  
imports: import pytest
  from .helpers.collection_setup import drop_collection
  from .helpers.helpers import request_with_validation
label_desc: Use image node_id 3 for calling a global function with example usage: test_nested_payload_indexing_operations() without return types