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
   }

   Copy to Clipboard Toggle word wrap

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 {
      }

      Copy to Clipboard Toggle word wrap

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;
       }
   }

   Copy to Clipboard Toggle word wrap

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 {
   }

   Copy to Clipboard Toggle word wrap

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

   Copy to Clipboard Toggle word wrap

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;
   
   }

   Copy to Clipboard Toggle word wrap

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

   schema --upload=person.proto person.proto

   Copy to Clipboard Toggle word wrap

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>

   Copy to Clipboard Toggle word wrap

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

   create cache --file=people.xml people

   Copy to Clipboard Toggle word wrap

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
   }

   Copy to Clipboard Toggle word wrap

   PersonTwo

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

   Copy to Clipboard Toggle word wrap

   PersonThree

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

   Copy to Clipboard Toggle word wrap

   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

   Copy to Clipboard Toggle word wrap
   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"

   Copy to Clipboard Toggle word wrap

   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.