Chapter 3. Querying remote caches

Procedure

1. Add indexing annotations to your class, as in the following example:

   Book.java

   import org.infinispan.api.annotations.indexing.Basic;
   import org.infinispan.api.annotations.indexing.Indexed;
   import org.infinispan.api.annotations.indexing.Text;
   import org.infinispan.protostream.annotations.ProtoFactory;
   import org.infinispan.protostream.annotations.ProtoField;
   
   @Indexed
   public class Book {
   
      @Text
      @ProtoField(number = 1)
      final String title;
   
      @Text
      @ProtoField(number = 2)
      final String description;
   
      @Basic
      @ProtoField(number = 3, defaultValue = "0")
      final int publicationYear;
   
      @ProtoFactory
      Book(String title, String description, int publicationYear) {
         this.title = title;
         this.description = description;
         this.publicationYear = publicationYear;
      }
      // public Getter methods omitted for brevity
   }

2. Implement the SerializationContextInitializer interface in a new class and then add the @ProtoSchema annotation.

   1. Reference the class that includes the @ProtoField annotations with the includeClasses parameter.
   2. Define a name for the Protobuf schema that you generate and filesystem path with the schemaFileName and schemaFilePath parameters.

   3. Specify the package name for the Protobuf schema with the schemaPackageName parameter.

      RemoteQueryInitializer.java

      import org.infinispan.protostream.SerializationContextInitializer;
      import org.infinispan.protostream.annotations.ProtoSchema;
      
      @ProtoSchema(
            includeClasses = {
                  Book.class
            },
            schemaFileName = "book.proto",
            schemaFilePath = "proto/",
            schemaPackageName = "book_sample")
      public interface RemoteQueryInitializer extends SerializationContextInitializer {
      }

3. Compile your project.

   The code examples in this procedure generate a proto/book.proto schema and an RemoteQueryInitializerImpl.java implementation of the annotated Book class.

Procedure

1. Add indexing annotations to your class, as in the following example:

   @Indexed
   public class CalculusIndexed {
       @Basic
       @ProtoField(value = 1)
       public BigInteger getPurchases() {
         return purchases;
       }
   
       @Decimal // the scale is 2 by default
       @ProtoField(value = 2)
       public BigDecimal getProspect() {
         return prospect;
       }
   }

2. Set the dependsOn attribute to CommonTypes.class to indicate that the generated Protobuf schema can reference and use CommonTypes types such as BigInteger and BigDecimal:

   @ProtoSchema(includeClasses = CalculusIndexed.class, dependsOn = CommonTypes.class,
        schemaFilePath = "/protostream", schemaFileName = "calculus-indexed.proto",
        schemaPackageName = "lab.indexed")
   public interface CalculusIndexedSchema extends GeneratedSchema {
   }

3. Perform queries:

   Query<Product> query = cache.query("from lab.indexed.CalculusIndexed c where c.purchases > 9");
   QueryResult<Product> result = query.execute();
   // play with the result
   
   query = cache.query("from lab.indexed.CalculusIndexed c where c.prospect = 2.2");
   result = query.execute();
   // play with the result

Procedure

1. Add indexing annotations to your Protobuf schema, as in the following example:

   package org.infinispan.example;
   
   /* @Indexed */
   message Person {
   
       /* @Basic */
       optional int32 id = 1;
   
       /* @Keyword(projectable = true) */
       required string name = 2;
   
       /* @Keyword(projectable = true) */
       required string surname = 3;
   
       /* @Basic(projectable = true, sortable = true) */
       optional int32 age = 6;
   
   }

   From the Data Grid CLI, use the schema command with the --upload= argument as follows:

   schema --upload=person.proto person.proto

2. Create a cache named people that uses ProtoStream encoding and configures Data Grid to index entities declared in your Protobuf schema.

   The following cache indexes the Person entity from the previous step:

   <distributed-cache name="people">
     <encoding media-type="application/x-protostream"/>
     <indexing>
       <indexed-entities>
         <indexed-entity>org.infinispan.example.Person</indexed-entity>
       </indexed-entities>
     </indexing>
   </distributed-cache>

   From the CLI, use the create cache command with the --file= argument as follows:

   create cache --file=people.xml people

3. Add entries to the cache.

   To query a remote cache, it needs to contain some data. For this example procedure, create entries that use the following JSON values:

   PersonOne

   {
     "_type":"org.infinispan.example.Person",
     "id":1,
     "name":"Person",
     "surname":"One",
     "age":44
   }

   PersonTwo

   {
     "_type":"org.infinispan.example.Person",
     "id":2,
     "name":"Person",
     "surname":"Two",
     "age":27
   }

   PersonThree

   {
     "_type":"org.infinispan.example.Person",
     "id":3,
     "name":"Person",
     "surname":"Three",
     "age":35
   }

   From the CLI, use the put command with the --file= argument to add each entry, as follows:

   put --encoding=application/json --file=personone.json personone

   Tip

   From Data Grid Console, you must select Custom Type for the Value content type field when you add values in JSON format with custom types .

4. Query your remote cache.

   From the CLI, use the query command from the context of the remote cache.

   query "from org.infinispan.example.Person p WHERE p.name='Person' ORDER BY p.age ASC"

   The query returns all entries with a name that matches Person by age in ascending order.

Procedure

1. Annotate the property with the @Text annotation to indicate that its value is analyzed.
2. Use the analyzer attribute to specify the desired analyzer that you want to use for indexing and searching.