Supporting additional parameters on the client.query.get() endpoints

Author: andreibondarev

README.md

@@ -139,11 +139,17 @@ response.data
 ### Querying
 ```ruby
 near_text = { "concepts": ["biology"] }
+sort_obj = { path: ["category"] } # Not supporting the `order:` param currently
+where_obj = { path: ["id"], operator: :equal, valueString: "..." }
 
 client.query.get(
     class_name: 'Question',
     fields: ['question', 'answer', 'category'],
     limit: 1,
+    offset: 1,
+    after: 'id',
+    sort: sort_obj,
+    where_obj: where_obj,
 
     # To use this parameter you must have created your schema by setting the `vectorizer:` property to
     # either 'text2vec-transformers', 'text2vec-contextionary', 'text2vec-openai', 'multi2vec-clip', 'text2vec-huggingface' or 'text2vec-cohere'

lib/weaviate/query.rb

@@ -2,15 +2,65 @@
 
 module Weaviate
   class Query < Base
+    # Meta-programming hack to dynamically create appropriate Weaviate GraphQL query. Expected query:
+    #
+    # Article(where: {
+    #   ...
+    #   operator: GreaterThan,  # operator
+    #
+    # Since `operator:` parameter expects a literal value, the only way to pass it in Ruby is by defining a class and returning it
+    # inside of a lambda function when it's called. This is why we have the following code:
+    # standard:disable all
+    WHERE_OPERANDS = {
+      and: -> { class ::And; end; And },
+      or: -> { class ::Or; end; Or },
+      equal: -> { class ::Equal; end; Equal },
+      not_equal: -> { class ::NotEqual; end; NotEqual },
+      greater_than: -> { class ::GreaterThan; end; GreaterThan },
+      greater_than_equal: -> { class ::GreaterThanEqual; end; GreaterThanEqual },
+      less_than: -> { class ::LessThan; end; LessThan },
+      less_than_equal: -> { class ::LessThanEqual; end; LessThanEqual },
+      like: -> { class ::Like; end; Like },
+      within_geo_range: -> { class ::WithinGeoRange; end; WithinGeoRange },
+      is_null: -> { class ::IsNull; end; IsNull }
+    }.freeze
+    # standard:enable all
+
     def get(
       class_name:,
       fields:,
       limit: nil,
+      offset: nil,
+      after: nil,
+      sort: nil,
+      where: nil,
       near_text: nil
     )
       params = {}
       params["nearText"] = near_text unless near_text.nil?
       params["limit"] = limit unless limit.nil?
+      params["offset"] = offset unless offset.nil?
+      params["after"] = after unless after.nil?
+
+      if sort.present?
+        # TODO: Implement the `order:` param
+        # Unable to currently support the `order:` param. Weaviate GraphQL API expects a literal value, but we can't pass it in Ruby
+        # Article(sort: [{
+        #   order: asc # <--- this is the problem.
+        # https://weaviate.io/developers/weaviate/api/graphql/filters#sorting-api
+        #
+        sort.delete("order")
+        params["sort"] = sort
+      end
+
+      if where.present?
+        params["where"] = where
+        if where[:operator].present?
+          params["where"][:operator] = WHERE_OPERANDS[where[:operator].to_sym].call
+        end
+        # TODO: Transform the multiple operands: [{}] case
+      end
+
       # TODO implement the rest of the API params
 
       response = client.graphql.execute(get_query(class_name, params, fields), near_text: near_text)

spec/weaviate/query_spec.rb

@@ -54,8 +54,25 @@
         limit: 1
       )
 
+      expect(data.count).to eq(1)
       expect(data.first.category).to eq("SCIENCE")
       expect(data.first.question).to eq("In 1953 Watson & Crick built a model of the molecular structure of this, the gene-carrying substance")
     end
   end
+
+  describe "WHERE_OPERANDS" do
+    it "returns the correct class name" do
+      expect(Weaviate::Query::WHERE_OPERANDS[:and].call).to eq(And)
+      expect(Weaviate::Query::WHERE_OPERANDS[:or].call).to eq(Or)
+      expect(Weaviate::Query::WHERE_OPERANDS[:equal].call).to eq(Equal)
+      expect(Weaviate::Query::WHERE_OPERANDS[:not_equal].call).to eq(NotEqual)
+      expect(Weaviate::Query::WHERE_OPERANDS[:greater_than].call).to eq(GreaterThan)
+      expect(Weaviate::Query::WHERE_OPERANDS[:greater_than_equal].call).to eq(GreaterThanEqual)
+      expect(Weaviate::Query::WHERE_OPERANDS[:less_than].call).to eq(LessThan)
+      expect(Weaviate::Query::WHERE_OPERANDS[:less_than_equal].call).to eq(LessThanEqual)
+      expect(Weaviate::Query::WHERE_OPERANDS[:like].call).to eq(Like)
+      expect(Weaviate::Query::WHERE_OPERANDS[:within_geo_range].call).to eq(WithinGeoRange)
+      expect(Weaviate::Query::WHERE_OPERANDS[:is_null].call).to eq(IsNull)
+    end
+  end
 end