How can I create an index for multiple values

[MikeAlhayek]

I have the following part

public class VehicleMakersPart : ContentPart
{
    public string[] YearContentItemIds { get; set; }

    public string Maker { get; set; }
}

The previous part will allow me to capture one Maker to multiple Years (content Items). I want to be able to query the index to get any maker where YearContentItemId == "xyz" for example.

Initially I was using one to one relation "One Maker" to "One Year" so I was doing the following. But but now I want to change the index.

public class VehicleMakersIndex : MapIndex
{
    public string ContentItemId { get; set; }

    public string YearContentItemId { get; set; }

    public string Maker { get; set; }
}

public class VehicleMakersIndexProvider : IndexProvider<ContentItem>
{
    public override void Describe(DescribeContext<ContentItem> context) =>
        context.For<VehicleMakersIndex>()
            .Map(contentItem =>
            {
                if (contentItem.ContentType != "VehicleMakers")
                {
                    return null;
                }

                var titlePart = contentItem.As<TitlePart>();
                var yearsPart = contentItem.As<VehicleYearsPart>();

                return titlePart == null || yearsPart == null
                    ? null
                    : new VehicleMakersIndex
                    {
                        ContentItemId = contentItem.ContentItemId,
                        YearContentItemId = yearPart.ContentItemId,
                        Maker = titlePart.Title,
                    };
            });
}

How can I create an index to allow me to pull all makers where YearContentItemIds contains "xyz"?

[jtkech]

To return many ones you just need to return an enumerable, there is a map overload for this

E.g. here a piece of code that I use in an index map

                var countryIds = trackPart.Countries.ContentItemIds;
                if (countryIds == null || countryIds.Length == 0)
                {
                    return null;
                }

                var results = new List<TrackCountryIndex>();
                var albumId = track.As<ContainedPart>()?.ListContentItemId;

                foreach (var countryId in countryIds)
                {
                    results.Add(new TrackCountryIndex
                    {
                        TrackId = track.ContentItemId,
                        AlbumId = albumId,
                        CountryId = countryId,
                        Published = track.Published,
                        Latest = track.Latest,
                    });
                }

                return results;

[MikeAlhayek]

@jtkech are you saying here that would just create two different indexes and use two describers to describe how to handle both indexes? If so, how would I describe the removal of one when one does not exists?

Here is what I have done based on what I understood from your code above

// This index will allow me to store all kinds of relations between a single ContentItemId to many KindContentItemId.
 public class VehicleTypeRelationIndex : MapIndex
    {
        public string ContentItemId { get; set; }

        public string KindContentItemId { get; set; }

        public string Kind { get; set; }

    }

// this index will allow me to capture one unique maker value which is 
    public class VehicleMakersIndex : MapIndex
    {
        public string ContentItemId { get; set; }
        // This info would be stored into the VehicleTypeRelationIndex using "Year" kind.
        // public string[] YearContentItemIds { get; set; }

        public string Maker { get; set; }
    }

    public class VehicleMakersIndexProvider : IndexProvider<ContentItem>
    {
        public override void Describe(DescribeContext<ContentItem> context)
        {
            context.For<VehicleMakersIndex>()
                .Map(contentItem =>
                {
                    if (contentItem.ContentType != "VehicleMakers")
                    {
                        return null;
                    }

                    var titlePart = contentItem.As<TitlePart>();

                    return titlePart == null 
                        ? null
                        : new VehicleMakersIndex
                        {
                            ContentItemId = contentItem.ContentItemId,
                            Maker = titlePart.Title,
                        };
                });

            context.For<VehicleTypeRelationIndex>()
                .Map(contentItem =>
                {
                    if (contentItem.ContentType != "VehicleMakers")
                    {
                        return null;
                    }

                    var yearsPart = contentItem.As<VehicleYearsPart>();

                    if (yearsPart == null || yearsPart.YearContentItemIds == null)
                    {
                        return null;
                    }

                    var results = new List<VehicleTypeRelationIndex>();

                    foreach(var yearContentItemId in yearsPart.YearContentItemIds)
                    {
                        var result = new VehicleTypeRelationIndex
                        {
                            ContentItemId = contentItem.ContentItemId,
                            KindContentItemId = yearContentItemId,
                            Kind = "Year",
                        };

                        results.Add(result);
                    }

                    return results;
                });

        }

    }

If this is how this is done, how can I handle the removal of an item? Meaning, when if there are 5 items selected, and now there are only 3 selected, 2 needs to be deleted from that index. How would I describe that?

[jtkech]

If at some point you have 5 rows related to a given contentItem, and then here return 3 results, only these 3 new results are kept, the old rows related to the same contentItem DocumentId are removed.

Also good to do at the beginning something like this

                // Remove index records of soft deleted items.
                if (!agent.Published && !agent.Latest)
                {
                    return null;
                }

[MikeAlhayek]

@jtkech I am confused here. What removes the records? Are you saying that every time context.For<VehicleTypeRelationIndex>() is called, it delete all old records automatically and new once "if any" are added? So I don't need to worry about the delete myself?

[jtkech]

Yes for a given contentItem DocumentId (so a specific version), so it's up to you to keep or not the records of all versions e.g. by using the code I showed to keep published and draft (published = false, latest = true) versions but not the soft removed ones (latest = published = false). Note: You can also opt to only keep the data related to published versions.

Most of the time we also have the Published and Latest columns in an index table, useful when you query the index table directly, not a joined query from the document table, and also to check what happens. Maybe not needed if your content type is not draftable / versionable because in that case you will work with only one version, but still useful to see if this unique version (always latest) is published or not.