dynamoid_advanced_where 1.5.1 → 1.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ca5af3b66602bc1a123044bd91797fefc1417d08e2ebf8c8103f0540aa68f0af
-  data.tar.gz: 167687a1a39ec4b088445dda5bbb15ad3463b03ee1cf9bf6d4ddff7359812185
+  metadata.gz: 239094fa5509e994cefa186a296b6f00bbc7a13913ea67803f82f173e6aea82a
+  data.tar.gz: cb46ded36d28fc09b54ea3b1598c34e2172232824056c9b6462f846f491e9673
 SHA512:
-  metadata.gz: 164d8e1236c19769ecdeb29370aa5d0c0305a0070eb00477e7871d573a364e1288d1be77a1cb1fd2fa2ed3eea2885e887cb20fab1a7846613dbd8eb64b426576
-  data.tar.gz: 735bc10d7925ae510f8154e0a3bffa0e6e77c76c5de700fa15b39b96fa6b2aebceb75607da860676ad5478cc34148a141ca8cf686457aed23b95de45247d9c42
+  metadata.gz: bce42bfde6205d3a63ea557b0624391170f586220247fc3c7ab17a1203eb6876d4356b6758a41df0756ea9de07ee06b29ce84ba4c40b516143a803d2d361a9cc
+  data.tar.gz: 633267b36adc9112e67aa8c541946d4ce9a56821d68aa339af211c5ffa400c6b6491b188e33f1dcda01ebd4ea32842fffcde432a783687d14080fc589beecb52

data/.rubocop-https---raw-githubusercontent-com-GetTerminus-ruby-shared-configs-master--rubocop-yml

@@ -3,7 +3,8 @@ AllCops:
     - Makefile
     - vendor/**/*
     - bin/**/*
-
+    - '**/*_pb.rb'
+    
 Layout/EndOfLine:
   Enabled: false
 
@@ -40,8 +41,6 @@ Layout/LineLength:
   Max: 280
   IgnoreCopDirectives: true
   AllowedPatterns: ['\A#', '\A\s*sig { .* }\Z']
-  Exclude:
-    - '**/*_pb.rb'
 
 Metrics/AbcSize:
   Enabled: true
@@ -76,7 +75,6 @@ Metrics/BlockLength:
   Max: 30
   Exclude:
     - spec/**/*.rb
-    - '**/*_pb.rb'
 
 Metrics/ParameterLists:
   Max: 6

data/Gemfile.lock

@@ -1,15 +1,15 @@
 PATH
   remote: .
   specs:
-    dynamoid_advanced_where (1.5.1)
+    dynamoid_advanced_where (1.6.0)
       dynamoid (>= 3.2, < 4)
 
 GEM
   remote: https://rubygems.org/
   specs:
-    activemodel (7.0.4.2)
-      activesupport (= 7.0.4.2)
-    activesupport (7.0.4.2)
+    activemodel (7.0.4.3)
+      activesupport (= 7.0.4.3)
+    activesupport (7.0.4.3)
       concurrent-ruby (~> 1.0, >= 1.0.2)
       i18n (>= 1.6, < 2)
       minitest (>= 5.1)
@@ -22,8 +22,8 @@ GEM
       thor (>= 0.14.0)
     ast (2.4.2)
     aws-eventstream (1.2.0)
-    aws-partitions (1.725.0)
-    aws-sdk-core (3.170.0)
+    aws-partitions (1.743.0)
+    aws-sdk-core (3.171.0)
       aws-eventstream (~> 1, >= 1.0.2)
       aws-partitions (~> 1, >= 1.651.0)
       aws-sigv4 (~> 1.5)

data/lib/dynamoid_advanced_where/filter_builder.rb

@@ -8,17 +8,18 @@ module DynamoidAdvancedWhere
       Nodes::GreaterThanNode,
     ].freeze
 
-    attr_accessor :expression_node, :klass
+    attr_accessor :expression_node, :query_filter_node, :range_key_node, :klass
 
     def initialize(root_node:, klass:)
-      self.expression_node = root_node.child_node
+      node = root_node.child_node
+      self.expression_node = node.is_a?(Nodes::AndNode) ? node : Nodes::AndNode.new(node)
       self.klass = klass
     end
 
     def index_nodes
       [
-        extract_query_filter_node,
-        extract_range_key_node,
+        query_filter_node,
+        range_key_node,
       ].compact
     end
 
@@ -32,16 +33,43 @@ module DynamoidAdvancedWhere
       expression_filters
     end
 
-    def must_scan?
-      !extract_query_filter_node.is_a?(Nodes::BaseNode)
+    def select_node_for_range_key(node)
+      raise 'node not found in expression' unless expression_node.child_nodes.include?(node)
+
+      self.range_key_node = node
+
+      self.expression_node = Nodes::AndNode.new(
+        *(expression_node.child_nodes - [node])
+      )
+    end
+
+    def select_node_for_query_filter(node)
+      raise 'node not found in expression' unless expression_node.child_nodes.include?(node)
+
+      self.query_filter_node = node
+
+      self.expression_node = Nodes::AndNode.new(
+        *(expression_node.child_nodes - [node])
+      )
+    end
+
+    # Returns a hash of the field name and the node that filters on it
+    def extractable_fields_for_hash_and_range
+      expression_node.child_nodes.each_with_object({}) do |node, hash|
+        next unless node.respond_to?(:lh_operation) &&
+                    node.lh_operation.is_a?(Nodes::FieldNode) &&
+                    node.lh_operation.field_path.length == 1
+
+        hash[node.lh_operation.field_path[0].to_s] = node
+      end
     end
 
     private
 
     def key_condition_expression
       @key_condition_expression ||= [
-        extract_query_filter_node,
-        extract_range_key_node,
+        query_filter_node,
+        range_key_node,
       ].compact.map(&:to_expression).join(' AND ')
     end
 
@@ -66,73 +94,5 @@ module DynamoidAdvancedWhere
         expression_attribute_values: expression_attribute_values,
       }.delete_if { |_, v| v.nil? || v.empty? }
     end
-
-    def extract_query_filter_node
-      @extract_query_filter_node ||=
-        case expression_node
-        when Nodes::EqualityNode
-          node = expression_node
-          if field_node_valid_for_key_filter(expression_node)
-            self.expression_node = Nodes::NullNode.new
-            node
-          end
-        when Nodes::AndNode
-          id_filters = expression_node.child_nodes.select do |i|
-            field_node_valid_for_key_filter(i)
-          end
-
-          if id_filters.length == 1
-            self.expression_node = Nodes::AndNode.new(
-              *(expression_node.child_nodes - id_filters)
-            )
-
-            id_filters.first
-          end
-        end
-    end
-
-    def field_node_valid_for_key_filter(node)
-      node.is_a?(Nodes::EqualityNode) &&
-        node.respond_to?(:lh_operation) &&
-        node.lh_operation.is_a?(Nodes::FieldNode) &&
-        node.lh_operation.field_path.length == 1 &&
-        node.lh_operation.field_path[0].to_s == hash_key
-    end
-
-    def extract_range_key_node
-      return unless extract_query_filter_node
-
-      @extract_range_key_node ||=
-        case expression_node
-        when Nodes::AndNode
-          id_filters = expression_node.child_nodes.select do |i|
-            field_node_valid_for_range_filter(i)
-          end
-
-          if id_filters.length == 1
-            self.expression_node = Nodes::AndNode.new(
-              *(expression_node.child_nodes - id_filters)
-            )
-
-            id_filters.first
-          end
-        end
-    end
-
-    def field_node_valid_for_range_filter(node)
-      node.respond_to?(:lh_operation) &&
-        node.lh_operation.is_a?(Nodes::FieldNode) &&
-        node.lh_operation.field_path.length == 1 &&
-        node.lh_operation.field_path[0].to_s == range_key &&
-        VALID_COMPARETORS_FOR_RANGE_FILTER.any? { |type| node.is_a?(type) }
-    end
-
-    def hash_key
-      @hash_key ||= klass.hash_key.to_s
-    end
-
-    def range_key
-      @range_key ||= klass.range_key.to_s
-    end
   end
 end

data/lib/dynamoid_advanced_where/nodes/root_node.rb

@@ -12,7 +12,7 @@ module DynamoidAdvancedWhere
       def initialize(klass:, &blk)
         self.klass = klass
         evaluate_block(blk) if blk
-        self.child_node ||= NullNode.new
+        self.child_node ||= AndNode.new
         freeze
       end
 

data/lib/dynamoid_advanced_where/query_builder.rb

@@ -6,15 +6,16 @@ require_relative './batched_updater'
 
 module DynamoidAdvancedWhere
   class QueryBuilder
-    attr_accessor :klass, :root_node, :start_hash, :record_limit
+    attr_accessor :klass, :root_node, :start_hash, :record_limit, :projected_fields
 
     delegate :all, :each_page, :each, to: :query_materializer
 
-    def initialize(klass:, record_limit: nil, start_hash: nil, root_node: nil, &blk)
+    def initialize(klass:, projected_fields: [], record_limit: nil, start_hash: nil, root_node: nil, &blk)
       self.klass = klass
       self.root_node = root_node || Nodes::RootNode.new(klass: klass, &blk)
       self.start_hash = start_hash
       self.record_limit = record_limit
+      self.projected_fields = projected_fields
 
       freeze
     end
@@ -49,6 +50,10 @@ module DynamoidAdvancedWhere
     end
     alias and where
 
+    def project(*fields)
+      dup_with_changes(projected_fields: projected_fields + fields)
+    end
+
     def limit(value)
       dup_with_changes(record_limit: value)
     end
@@ -68,6 +73,7 @@ module DynamoidAdvancedWhere
         klass: klass,
         start_hash: start_hash,
         root_node: root_node,
+        projected_fields: projected_fields,
       }.merge(changes))
     end
   end

data/lib/dynamoid_advanced_where/query_materializer.rb

@@ -11,8 +11,6 @@ module DynamoidAdvancedWhere
     delegate :table_name, to: :klass
     delegate :to_a, :first, to: :each
 
-    delegate :must_scan?, to: :filter_builder
-
     def initialize(query_builder:)
       self.query_builder = query_builder
     end
@@ -46,10 +44,13 @@ module DynamoidAdvancedWhere
       end
     end
 
-    def each_page_via_query
-      query = {
-        table_name: table_name,
-      }.merge(filter_builder.to_query_filter)
+    def enumerate_results(starting_query)
+      query = starting_query.dup
+
+      unless query_builder.projected_fields.empty?
+        query[:select] = 'SPECIFIC_ATTRIBUTES'
+        query[:projection_expression] = query_builder.projected_fields.map(&:to_s).join(',')
+      end
 
       query[:limit] = query_builder.record_limit if query_builder.record_limit
 
@@ -57,9 +58,10 @@ module DynamoidAdvancedWhere
 
       Enumerator.new do |yielder|
         loop do
-          results = client.query(query.merge(exclusive_start_key: page_start))
+          query[:exclusive_start_key] = page_start
+          results = yield(query)
 
-          items = (results.items || []).each do |item|
+          items = (results.items || []).map do |item|
             klass.from_database(item.symbolize_keys)
           end
 
@@ -74,39 +76,82 @@ module DynamoidAdvancedWhere
       end.lazy
     end
 
+    def each_page_via_query
+      query = {
+        table_name: table_name,
+        index_name: selected_index_for_query,
+      }.merge(filter_builder.to_query_filter)
+
+      enumerate_results(query) do |q|
+        client.query(q)
+      end
+    end
+
     def each_page_via_scan
       query = {
         table_name: table_name,
       }.merge(filter_builder.to_scan_filter)
 
-      query[:limit] = query_builder.record_limit if query_builder.record_limit
+      enumerate_results(query) do |q|
+        client.scan(q)
+      end
+    end
 
-      page_start = start_hash
+    def filter_builder
+      @filter_builder ||= FilterBuilder.new(
+        root_node: query_builder.root_node,
+        klass: klass,
+      )
+    end
 
-      Enumerator.new do |yielder|
-        loop do
-          results = client.scan(query.merge(exclusive_start_key: page_start))
+    # Pick the index to query.
+    #   1) The first index chosen should be one that has the range and hash key satisfied.
+    #   2) The second should be one that has the hash key
+    def selected_index_for_query
+      possible_fields = filter_builder.extractable_fields_for_hash_and_range
 
-          items = (results.items || []).map do |item|
-            klass.from_database(item.symbolize_keys)
-          end
+      satisfiable_indexes.each do |name, definition|
+        next unless possible_fields.key?(definition[:hash_key]) &&
+                    possible_fields.key?(definition[:range_key])
 
-          yielder.yield(items, results)
+        filter_builder.select_node_for_range_key(possible_fields[definition[:range_key]])
+        filter_builder.select_node_for_query_filter(possible_fields[definition[:hash_key]])
 
-          query[:limit] = query[:limit] - results.items.length if query[:limit]
+        return name
+      end
 
-          break if results.last_evaluated_key.nil? || query[:limit]&.zero?
+      # Just take the first matching query then
+      name, definition = satisfiable_indexes.first
+      filter_builder.select_node_for_query_filter(possible_fields[definition[:hash_key]])
+      filter_builder.select_node_for_range_key(possible_fields[definition[:range_key]]) unless possible_fields[definition[:range_key]].blank?
 
-          (page_start = results.last_evaluated_key)
-        end
-      end.lazy
+      name
     end
 
-    def filter_builder
-      @filter_builder ||= FilterBuilder.new(
-        root_node: query_builder.root_node,
-        klass: klass,
-      )
+    def must_scan?
+      satisfiable_indexes.empty?
+    end
+
+    # find all indexes where we have a predicate on the hash key
+    def satisfiable_indexes
+      possible_fields = filter_builder.extractable_fields_for_hash_and_range
+
+      all_possible_indexes.select do |_, definition|
+        possible_fields.key?(definition[:hash_key])
+      end
+    end
+
+    def all_possible_indexes
+      # The nil index name is the table itself
+      idx = { nil => { hash_key: klass.hash_key.to_s, range_key: klass.range_key.to_s } }
+
+      klass.indexes.each do |_, definition|
+        next unless definition.projected_attributes == :all
+
+        idx[definition.name] = { hash_key: definition.hash_key.to_s, range_key: definition.range_key.to_s }
+      end
+
+      idx
     end
 
     private

data/lib/dynamoid_advanced_where/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module DynamoidAdvancedWhere
-  VERSION = '1.5.1'
+  VERSION = '1.7.0'
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: dynamoid_advanced_where
 version: !ruby/object:Gem::Version
-  version: 1.5.1
+  version: 1.7.0
 platform: ruby
 authors:
 - Brian Malinconico
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2023-03-13 00:00:00.000000000 Z
+date: 2023-04-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: dynamoid