Nested attribute on List<string> generating unwanted properties

NEST/Elasticsearch.Net version: 2.3.3

Elasticsearch version: 2.3.2

Description of the problem including expected versus actual behavior:

I have a mapping for a list<string> set with the Nested attribute and it’s creating unwanted properties on the ES mapping.

[Nested(IncludeInParent=true)]
public List<String> raw_amenities { get; set; }

yields

raw_amenities": {
     "type": "nested",
     "include_in_parent": true,
     "properties": {
          "chars": {
               "type": "string"
           },
           "length": {
               "type": "integer"
            }
      }
}

[russcam]

Just to follow up on what @gmarz has said, you would want to map it as a string type

[String]
public List<String> raw_amenities { get; set; }

in fact, if you don’t need to set any other properties for the type e.g. a different analyzer, not analyzed, etc. then you don’t even need the attribute applied, just calling AutoMap() will infer a string type mapping for List<string>. With Elasticsearch mappings, there is no distinction between a single property type and a collection property type i.e.

public class Household
{
    public string Amenity { get; set; }
    public List<string> Amenities { get; set; } 
}

Both Amenity and Amenities would be mapped as string data type in Elasticsearch.

Now, if you were dealing with say a List<Amenity> where Amenity type was

public class Amenity
{
    public string Name { get; set; }
    public DateTimeOffset Added { get; set; }
}

then the default inferred mapping for this would be object. This is fine for some scenarios, but with object mapping, the association between Name and Added for a given Amenity instance is not stored in the inverted index. For example, imagine the following amenities are indexed for a Household document

var household = new Household 
{
    Id = 1,
    Amenities = new List<Amenity>
    {
        new Amenity { Name = "electricity", Added = new DateTime(2016, 1, 1) },
        new Amenity { Name = "gas", Added = new DateTime(2016, 1, 8) },
    }
}

client.Index(household);

if Amenities is mapped as an object type, a search for Name="electricity" and Added=new DateTime(2016, 1, 8) would return the document as a match. If Amenities is mapped as a nested type however, the document would not be a match.

I hope that helps explain the difference.

[Mpdreamz]

Closing this before we attempt something too clever 😄 we’d have to unpack PropertyType see if its IEnumerable<T> then check if T is a reference type all for a small gain.