typeless | running wild with shapeless

Reflection is not the recommended way to do this. Probably refactoring is in order. For example, it's not clear how var comparer would actually be used once it is created via Reflection in this way.

To mitigate performance concerns, you could cache the comparers as they are created, much like the source of EqualityComparer does internally for each T. But your code just gets messier this way.

That said...

This is just a warning right now, but it will become an error in Elasticsearch 8.

From last few version, Elasticsearch has been planning the removal of index types inside an index

1. ES5 - Setting index.mapping.single_type: true on an index will enable the single-type-per-index behavior which will be enforced in 6.0.
2. In ES6 - you can't have more than 1 index type inside 1 index
3. In ES7 - the concept of types inside an index has been deprecated
4. In ES8 - it will be removed, and you can't use types for query or while inserting documents

My suggestion would be to design an application and mapping in such a way that it doesn't include type parameter in index

To know the reason why elastic search has done this here is a link: https://www.elastic.co/guide/en/elasticsearch/reference/current/removal-of-types.html#_why_are_mapping_types_being_removed

The standard and best approach is writing a wrapper with the #ifdefs testing inside it:

You can find the reason as why types have been removed in this link and below is the excerpt from that very link.

In an Elasticsearch index, fields that have the same name in different mapping types are backed by the same Lucene field internally. In other words, using the example above, the user_name field in the user type is stored in exactly the same field as the user_name field in the tweet type, and both user_name fields must have the same mapping (definition) in both types.

This can lead to frustration when, for example, you want deleted to be a date field in one type and a boolean field in another type in the same index.

On top of that, storing different entities that have few or no fields in common in the same index leads to sparse data and interferes with Lucene’s ability to compress documents efficiently.

For these reasons, we have decided to remove the concept of mapping types from Elasticsearch.

I am assuming that there should be another way to divide documents according to their collection within an index.

Basically you have the below options:

• Have an altogether a separate index for different document type
• Have a separate field in the same index which would help you differentiate two types of documents.

More information on that in here

As for when you would want to make use of one over other, my bet is that if you find the fields in two different types, almost or mostly similar, then you can simply go for approach two. However if your old index has two types with different fields altogether, it would make sense to go for separate index.

Also your design of entire system comes into place, ingestion patterns, querying patterns(scoring, aggregations, transformations, index to index pipeline reindexing so other teams can use them for more insightful analytical info), what if one type is constantly getting lot of updates while other hardly any updates, best to keep them apart, right.

I believe the links I've shared has enough information.

Hope that helps!

I believe this would be a re-work, unless the Ingest/Reindex API in ES version 8, comes with some form of remote-reindex mechanism which would allow the documents to be ingested from version 7 to 8 by taking into consideration to adjust _doc accordingly, you may have to re-ingest the documents from source/ingestion layer by re-creating indexes and mapping and similarly making end point changes to index documents from the service/ingestion tool.

Also note that, I haven't seen anything what I mentioned in their reindex breaking changes section. You may want to keep an eye on this and revisit once ES version 8 comes out.

Note that from this link it states this

Note that in 7.0, _doc is a permanent part of the path, and represents the endpoint name rather than the document type

Hope this helps!

Something like this could work.
Only one pointer is needed for getline. Since the pointer is assigned array->memory[++array->index] = data; more memory needs to be allocated for each iteration. Set line to NULL and len to zero.
Consider breaking out of the loop when an empty line is entered. '\n' == line[0].
Free line at the very end.

Update, I found the solution, which is actually pretty stupid..

see Any.pm6#L519, the candidate

You are using ES 7.x that doesn't support anymore doc_type -doc here - it is written also in the message returned from index creation: