Uploaded image for project: 'Infinispan'
  1. Infinispan
  2. ISPN-12419

Expose indexed-embedding as a separate annotation in Protobuf index mapping

    XMLWordPrintable

Details

    • Enhancement
    • Status: Closed (View Workflow)
    • Major
    • Resolution: Out of Date
    • None
    • None
    • Remote Querying
    • DataGrid Sprint #50, DataGrid Sprint #53

    Description

      This ticket is about a behavior change between Infinispan 11 and 12 caused by the upgrade to Hibernate Search 6; it must be addressed before the release of Infinispan 12.

      In Infinispan 11, when mapping a Protobuf type to an index, one must use the @Field annotation in order to mark a composite type as "embedded", e.g.:

      message User {
      
         /**
          * @Field(store = Store.YES)
          * @SortableField
          */
         required int32 id = 1;
      
         /**
          * @Field(store = Store.YES)
          */
         optional User manager = 2;
      
      }
      

      The @Field annotation on manager does not actually create a field: instead, it specifies that all fields defined in manager should be embedded in User. In this case, it means user will have a field named manager.id.

      One obvious problem is that we're hijacking an annotation to express something really different from what it was intended for. It would arguably be better to have a dedicated annotation for that kind of embedding, similar to the @IndexedEmbedded annotation from Hibernate Search.

      But a less obvious and much more problematic consequence of that choice is that we are forced to put implicit limits on recursive models, and users cannot control these limits. Indeed, Infinispan 12 only uses static metamodels when defining Hibernate Search indexes, so infinite recursion is simply not an option. In the example above, we have to declare all fields at bootstrap, and that includes the recursions such as manager.id, manager.manager.id, manager.manager.manager.id, etc. Currently we limit embedding depth to 7, which is very arbitrary.

      To solve that problem, we have two alternatives:

      1. Embrace infinite recursion, meaning we will define a dynamic schema. In the example above, we would define static fields manager, manager.id and manager.manager, and inside manager we would define dynamic fields for path patterns *.manager (object field) and *.manager.id (Integer field, stored, sortable). The main problem with this behavior is there is a possibility that user schemas introduce conflicts (e.g. two definitions of "manager" in two different embedded types), which will probably lead to runtime errors or non-matching queries.
      2. Switch to a dedicated annotation to configure embedding, e.g. @IndexedEmbedded. This annotation could be unlimited by default. Hibernate Search will throw an exception if that leads infinite recursion, and when that happens, users will be able to set attributes on the annotation to control recursion, for example with @IndexedEmbedded(includePaths = <finite list of field paths to embed>) or @IndexedEmbedded(includeDepth = <depth of recursion when indexing>).

      I'd be in favor of solution 2, which is the solution we implement in the Hibernate Search / Hibernate ORM mapper : https://docs.jboss.org/hibernate/search/6.0/reference/en-US/html_single/#mapper-orm-indexedembedded-filtering

      Judging from a previous conversation, it seems anistor agrees.
      See also the full conversation, starting here: https://infinispan.zulipchat.com/#narrow/stream/118645-infinispan/topic/ISPN.20Query.20-.20schema/near/191445997

      Attachments

        Activity

          People

            fercoli@redhat.com Fabio Massimo Ercoli
            yrodiere Yoann Rodière
            Votes:
            0 Vote for this issue
            Watchers:
            4 Start watching this issue

            Dates

              Created:
              Updated:
              Resolved: