redcord 0.0.1.alpha → 0.1.1

data/lib/redcord/relation.rb

@@ -1,95 +1,271 @@
+# frozen_string_literal: true
+
 # typed: strict
+
+require 'active_support/core_ext/array'
 require 'active_support/core_ext/module'
 
+module Redcord
+  class InvalidQuery < StandardError; end
+end
+
 class Redcord::Relation
   extend T::Sig
 
   sig { returns(T.class_of(Redcord::Base)) }
   attr_reader :model
-  
-  sig { returns(T::Hash[Symbol, T.untyped]) }
-  attr_reader :query_conditions
 
   sig { returns(T::Set[Symbol]) }
   attr_reader :select_attrs
 
-  # TODO: Add sig for []
-  delegate :[], to: :to_a
+  sig { returns(T.nilable(Symbol)) }
+  attr_reader :custom_index_name
 
-  sig do
-    type_parameters(:U).params(
-      blk: T.proc.params(arg0: Redcord::Base).returns(T.type_parameter(:U)),
-    ).returns(T::Array[T.type_parameter(:U)])
-  end
-  def map(&blk)
-    to_a.map(&blk)
-  end
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  attr_reader :regular_index_query_conditions
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  attr_reader :custom_index_query_conditions
 
   sig do
     params(
       model: T.class_of(Redcord::Base),
-      query_conditions: T::Hash[Symbol, T.untyped],
-      select_attrs: T::Set[Symbol]
+      regular_index_query_conditions: T::Hash[Symbol, T.untyped],
+      custom_index_query_conditions: T::Hash[Symbol, T.untyped],
+      select_attrs: T::Set[Symbol],
+      custom_index_name: T.nilable(Symbol)
     ).void
   end
-  def initialize(model, query_conditions={}, select_attrs=Set.new)
+  def initialize(
+    model,
+    regular_index_query_conditions = {},
+    custom_index_query_conditions = {},
+    select_attrs = Set.new,
+    custom_index_name: nil
+  )
     @model = model
-    @query_conditions = query_conditions
+    @regular_index_query_conditions = regular_index_query_conditions
+    @custom_index_query_conditions = custom_index_query_conditions
     @select_attrs = select_attrs
+    @custom_index_name = custom_index_name
   end
 
   sig { params(args: T::Hash[Symbol, T.untyped]).returns(Redcord::Relation) }
   def where(args)
     encoded_args = args.map do |attr_key, attr_val|
-      encoded_val = model.validate_and_encode_query(attr_key, attr_val)
+      encoded_val = model.validate_types_and_encode_query(attr_key, attr_val)
       [attr_key, encoded_val]
     end
-    query_conditions.merge!(encoded_args.to_h)
+
+    regular_index_query_conditions.merge!(encoded_args.to_h)
+    if custom_index_name
+      with_index(custom_index_name)
+    end
     self
   end
 
   sig do
     params(
-    args: Symbol,
+    args: T.untyped,
     blk: T.nilable(T.proc.params(arg0: T.untyped).void),
   ).returns(T.any(Redcord::Relation, T::Array[T.untyped]))
   end
   def select(*args, &blk)
-    if block_given?
-      return execute_query.select { |*item| blk.call(*item) }
+    Redcord::Base.trace(
+     'redcord_relation_select',
+     model_name: model.name,
+    ) do
+      if block_given?
+        return execute_query.select do |*item|
+          blk.call(*item)
+        end
+      end
+
+      select_attrs.merge(args)
+      self
     end
-    select_attrs.merge(args)
-    self
   end
 
   sig { returns(Integer) }
   def count
-    redis.find_by_attr_count(model.model_key, query_conditions)
+    Redcord::Base.trace(
+     'redcord_relation_count',
+     model_name: model.name,
+    ) do
+      model.validate_index_attributes(query_conditions.keys, custom_index_name: custom_index_name)
+      redis.find_by_attr_count(
+        model.model_key,
+        extract_query_conditions!,
+        index_attrs: model._script_arg_index_attrs,
+        range_index_attrs: model._script_arg_range_index_attrs,
+        custom_index_attrs: model._script_arg_custom_index_attrs[custom_index_name],
+        hash_tag: extract_hash_tag!,
+        custom_index_name: custom_index_name
+      )
+    end
   end
 
-  sig { returns(T::Array[T.untyped]) }
-  def to_a
-    execute_query
+  sig { params(index_name: T.nilable(Symbol)).returns(Redcord::Relation) }
+  def with_index(index_name)
+    @custom_index_name = index_name
+    adjusted_query_conditions = model.validate_and_adjust_custom_index_query_conditions(regular_index_query_conditions)
+    custom_index_query_conditions.merge!(adjusted_query_conditions)
+    self
   end
 
+  delegate(
+    :&,
+    :[],
+    :all?,
+    :any?,
+    :any?,
+    :at,
+    :collect!,
+    :collect,
+    :compact!,
+    :compact,
+    :each,
+    :each_index,
+    :empty?,
+    :eql?,
+    :exists?,
+    :fetch,
+    :fifth!,
+    :fifth,
+    :filter!,
+    :filter,
+    :first!,
+    :first,
+    :forty_two!,
+    :forty_two,
+    :fourth!,
+    :fourth,
+    :include?,
+    :inspect,
+    :last!,
+    :last,
+    :many?,
+    :map!,
+    :map,
+    :none?,
+    :one?,
+    :reject!,
+    :reject,
+    :reverse!,
+    :reverse,
+    :reverse_each,
+    :second!,
+    :second,
+    :second_to_last!,
+    :second_to_last,
+    :size,
+    :sort!,
+    :sort,
+    :sort_by!,
+    :take!,
+    :take,
+    :third!,
+    :third,
+    :third_to_last!,
+    :third_to_last,
+    :to_a,
+    :to_ary,
+    :to_h,
+    :to_s,
+    :zip,
+    :|,
+    to: :execute_query,
+  )
+
   private
+
+  sig { returns(T.nilable(String)) }
+  def extract_hash_tag!
+    attr = model.shard_by_attribute
+    return nil if attr.nil?
+
+    if !query_conditions.keys.include?(attr)
+      raise(
+        Redcord::InvalidQuery,
+        "Queries must contain attribute '#{attr}' since model #{model.name} is sharded by this attribute"
+      )
+    end
+
+    # Query conditions on custom index are always in form of range, even when query is by value condition is [value_x, value_x]
+    # When in fact query is by value, range is trasformed to a single value to pass the validation.
+    condition = query_conditions[attr]
+    if custom_index_name and condition.first == condition.last
+      condition = condition.first
+    end
+    case condition
+    when Integer, String
+      "{#{condition}}"
+    else
+      raise(
+        Redcord::InvalidQuery,
+        "Does not support query condition #{condition} on a Redis Cluster",
+      )
+    end
+  end
+
   sig { returns(T::Array[T.untyped]) }
   def execute_query
-    if !select_attrs.empty?
-      res_hash = redis.find_by_attr(model.model_key, query_conditions, select_attrs)
-      return res_hash.map do |id, args|
-        args = model.from_redis_hash(args)
-        args = args.map { |k, v| [k.to_sym, TypeCoerce[model.get_attr_type(k.to_sym)].new.from(v)] }.to_h
-        args.merge!(:id => id)
+    Redcord::Base.trace(
+     'redcord_relation_execute_query',
+     model_name: model.name,
+    ) do
+      model.validate_index_attributes(query_conditions.keys, custom_index_name: custom_index_name)
+      if !select_attrs.empty?
+        res_hash = redis.find_by_attr(
+          model.model_key,
+          extract_query_conditions!,
+          select_attrs: select_attrs,
+          index_attrs: model._script_arg_index_attrs,
+          range_index_attrs: model._script_arg_range_index_attrs,
+          custom_index_attrs: model._script_arg_custom_index_attrs[custom_index_name],
+          hash_tag: extract_hash_tag!,
+          custom_index_name: custom_index_name
+        )
+
+        res_hash.map do |id, args|
+          model.from_redis_hash(args).map do |k, v|
+            [k.to_sym, TypeCoerce[model.get_attr_type(k.to_sym)].new.from(v)]
+          end.to_h.merge(id: id)
+        end
+      else
+        res_hash = redis.find_by_attr(
+          model.model_key,
+          extract_query_conditions!,
+          index_attrs: model._script_arg_index_attrs,
+          range_index_attrs: model._script_arg_range_index_attrs,
+          custom_index_attrs: model._script_arg_custom_index_attrs[custom_index_name],
+          hash_tag: extract_hash_tag!,
+          custom_index_name: custom_index_name
+        )
+
+        res_hash.map { |id, args| model.coerce_and_set_id(args, id) }
       end
-    else
-      res_hash = redis.find_by_attr(model.model_key, query_conditions)
-      return res_hash.map { |id, args| model.coerce_and_set_id(args, id) }
     end
   end
 
-  sig { returns(Redcord::PreparedRedis) }
+  sig { returns(Redcord::Redis) }
   def redis
     model.redis
   end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def query_conditions
+    custom_index_name ? custom_index_query_conditions : regular_index_query_conditions
+  end
+
+  sig { returns(T::Hash[Symbol, T.untyped]) }
+  def extract_query_conditions!
+    attr = model.shard_by_attribute
+    return query_conditions if attr.nil?
+
+    cond = query_conditions.reject { |key| key == attr }
+    raise Redcord::InvalidQuery, "Cannot query only by shard_by_attribute: #{attr}" if cond.empty?
+
+    cond
+  end
 end

data/lib/redcord/serializer.rb

@@ -1,14 +1,19 @@
-require 'redcord/range_interval'
+# frozen_string_literal: true
+
 # typed: strict
-#
-# This module defines various helper methods on Redcord for serialization between the 
-# Ruby client and Redis server.
+
+require 'redcord/range_interval'
+
 module Redcord
   # Raised by Model.where
   class AttributeNotIndexed < StandardError; end
   class WrongAttributeType < TypeError; end
+  class CustomIndexInvalidQuery < StandardError; end
+  class CustomIndexInvalidDesign < StandardError; end
 end
 
+# This module defines various helper methods on Redcord for serialization
+# between the  Ruby client and Redis server.
 module Redcord::Serializer
   extend T::Sig
 
@@ -16,84 +21,160 @@ module Redcord::Serializer
   def self.included(klass)
     klass.extend(ClassMethods)
   end
-  
+
   module ClassMethods
     extend T::Sig
 
-    # Redis only allows range queries on floats. To allow range queries on the Ruby Time
-    # type, encode_attr_value and decode_attr_value will implicitly encode and decode
-    # Time attributes to a float.
+    # Redis only allows range queries on floats. To allow range queries on the
+    # Ruby Time type, encode_attr_value and decode_attr_value will implicitly
+    # encode and decode Time attributes to a float.
     TIME_TYPES = T.let(Set[Time, T.nilable(Time)], T::Set[T.untyped])
+
     sig { params(attribute: Symbol, val: T.untyped).returns(T.untyped) }
     def encode_attr_value(attribute, val)
-      if val && TIME_TYPES.include?(props[attribute][:type])
-        val = val.to_f
+      if !val.blank? && TIME_TYPES.include?(props[attribute][:type])
+        time_in_nano_sec = val.to_i * 1_000_000_000
+        time_in_nano_sec >= 0 ? time_in_nano_sec + val.nsec : time_in_nano_sec - val.nsec
+      elsif val.is_a?(Float)
+        # Encode as round-trippable float64
+        '%1.16e' % [val]
+      else
+        val
       end
-      val
     end
 
     sig { params(attribute: Symbol, val: T.untyped).returns(T.untyped) }
     def decode_attr_value(attribute, val)
-      if val && TIME_TYPES.include?(props[attribute][:type])
-        val = Time.zone.at(val.to_f)
+      if !val.blank? && TIME_TYPES.include?(props[attribute][:type])
+        val = val.to_i
+        nsec = val >= 0 ? val % 1_000_000_000 : -val % 1_000_000_000
+
+        Time.zone.at(val / 1_000_000_000).change(nsec: nsec)
+      else
+        val
       end
-      val
     end
 
     sig { params(attr_key: Symbol, attr_val: T.untyped).returns(T.untyped)}
-    def validate_and_encode_query(attr_key, attr_val)
-      # Validate that attributes queried for are index attributes
-      if !class_variable_get(:@@index_attributes).include?(attr_key) &&
-        !class_variable_get(:@@range_index_attributes).include?(attr_key)
-        raise Redcord::AttributeNotIndexed.new(
-        "#{attr_key} is not an indexed attribute."
-        )
-      end
-      # Validate attribute types for normal index attributes
+    def validate_types_and_encode_query(attr_key, attr_val)
+      # Validate attribute types for index attributes
       attr_type = get_attr_type(attr_key)
-      if class_variable_get(:@@index_attributes).include?(attr_key)
+      if class_variable_get(:@@index_attributes).include?(attr_key) || attr_key == shard_by_attribute
         validate_attr_type(attr_val, attr_type)
       else
-        # Validate attribute types for range index attributes
-        if attr_val.is_a?(Redcord::RangeInterval)
-          validate_attr_type(attr_val.min, T.cast(T.nilable(attr_type), T::Types::Base))
-          validate_attr_type(attr_val.max, T.cast(T.nilable(attr_type), T::Types::Base))
-        else
-          validate_attr_type(attr_val, attr_type)
-        end
-        # Range index attributes need to be further encoded into a format understood by the Lua script.
-        if attr_val != nil
+        validate_range_attr_types(attr_val, attr_type)
+
+        # Range index attributes need to be further encoded into a format
+        # understood by the Lua script.
+        unless attr_val.nil?
           attr_val = encode_range_index_attr_val(attr_key, attr_val)
         end
       end
       attr_val
     end
 
-    sig { params(attr_val: T.untyped, attr_type: T.any(Class, T::Types::Base)).void }
+    # Validate that attributes queried for are index attributes
+    # For custom index: validate that attributes are present in specified index
+    sig { params(attr_keys: T::Array[Symbol], custom_index_name: T.nilable(Symbol)).void}
+    def validate_index_attributes(attr_keys, custom_index_name: nil)
+      custom_index_attributes = class_variable_get(:@@custom_index_attributes)[custom_index_name]
+      attr_keys.each do |attr_key|
+        next if attr_key == shard_by_attribute
+
+        if !custom_index_attributes.empty?
+          if !custom_index_attributes.include?(attr_key)
+            raise(
+              Redcord::AttributeNotIndexed,
+              "#{attr_key} is not a part of #{custom_index_name} index.",
+            )
+          end
+        else
+          if !class_variable_get(:@@index_attributes).include?(attr_key) &&
+            !class_variable_get(:@@range_index_attributes).include?(attr_key)
+            raise(
+              Redcord::AttributeNotIndexed,
+              "#{attr_key} is not an indexed attribute.",
+            )
+          end
+        end
+      end
+    end
+
+    # Validate exclusive ranges not used; Change all query conditions to range form;
+    # The position of the attribute and type of query is validated on Lua side
+    sig { params(query_conditions: T::Hash[Symbol, T.untyped]).returns(T::Hash[Symbol, T.untyped])}
+    def validate_and_adjust_custom_index_query_conditions(query_conditions)
+      adjusted_query_conditions = query_conditions.clone
+      query_conditions.each do |attr_key, condition|
+        if !condition.is_a?(Array)
+          adjusted_query_conditions[attr_key] = [condition, condition]
+        elsif condition[0].to_s[0] == '(' or condition[1].to_s[0] == '('
+          raise(Redcord::CustomIndexInvalidQuery, "Custom index doesn't support exclusive ranges")
+        end
+      end
+      adjusted_query_conditions
+    end
+
+    sig {
+      params(
+        attr_val: T.untyped,
+        attr_type: T.any(Class, T::Types::Base),
+      ).void
+    }
+    def validate_range_attr_types(attr_val, attr_type)
+      # Validate attribute types for range index attributes
+      if attr_val.is_a?(Redcord::RangeInterval)
+        validate_attr_type(
+          attr_val.min,
+          T.cast(T.nilable(attr_type), T::Types::Base),
+        )
+        validate_attr_type(
+          attr_val.max,
+          T.cast(T.nilable(attr_type), T::Types::Base),
+        )
+      else
+        validate_attr_type(attr_val, attr_type)
+      end
+    end
+
+    sig {
+      params(
+        attr_val: T.untyped,
+        attr_type: T.any(Class, T::Types::Base),
+      ).void
+    }
     def validate_attr_type(attr_val, attr_type)
       if (attr_type.is_a?(Class) && !attr_val.is_a?(attr_type)) ||
-        (attr_type.is_a?(T::Types::Base) && !attr_type.valid?(attr_val))
-        raise Redcord::WrongAttributeType.new(
-          "Expected type #{attr_type}, got #{attr_val.class}"
+         (attr_type.is_a?(T::Types::Base) && !attr_type.valid?(attr_val))
+        raise(
+          Redcord::WrongAttributeType,
+          "Expected type #{attr_type}, got #{attr_val.class.name}",
         )
       end
     end
 
-    sig { params(attribute: Symbol, val: T.untyped).returns([T.untyped, T.untyped]) }
+    sig {
+      params(
+        attribute: Symbol,
+        val: T.untyped,
+      ).returns([T.untyped, T.untyped])
+    }
     def encode_range_index_attr_val(attribute, val)
       if val.is_a?(Redcord::RangeInterval)
-        # nil is treated as -inf and +inf. This is supported in Redis sorted sets
-        # so clients aren't required to know the highest and lowest scores in a range
+        # nil is treated as -inf and +inf. This is supported in Redis sorted
+        # sets so clients aren't required to know the highest and lowest scores
+        # in a range
         min_val = !val.min ? '-inf' : encode_attr_value(attribute, val.min)
         max_val = !val.max ? '+inf' : encode_attr_value(attribute, val.max)
 
-        # In Redis, by default min and max is closed. You can prefix the score with '(' to
-        # specify an open interval.
+        # In Redis, by default min and max is closed. You can prefix the score
+        # with '(' to specify an open interval.
         min_val = val.min_exclusive ? '(' + min_val.to_s : min_val.to_s
         max_val = val.max_exclusive ? '(' + max_val.to_s : max_val.to_s
-        return [min_val, max_val]
+        [min_val, max_val]
       else
-        # Equality queries for range indices are be passed to redis as a range [val, val].
+        # Equality queries for range indices are be passed to redis as a range
+        # [val, val].
         encoded_val = encode_attr_value(attribute, val)
         [encoded_val, encoded_val]
       end
@@ -104,24 +185,41 @@ module Redcord::Serializer
       props[attr_key][:type_object]
     end
 
-    sig { params(redis_hash: T::Hash[T.untyped, T.untyped], id: Integer).returns(T.untyped) }
+    sig {
+      params(
+        redis_hash: T::Hash[T.untyped, T.untyped],
+        id: String,
+      ).returns(T.untyped)
+    }
     def coerce_and_set_id(redis_hash, id)
-      # Coerce each serialized result returned from Redis back into Model instance
+      # Coerce each serialized result returned from Redis back into Model
+      # instance
       instance = TypeCoerce.send(:[], self).new.from(from_redis_hash(redis_hash))
       instance.send(:id=, id)
       instance
     end
+
     sig { returns(String) }
     def model_key
       "Redcord:#{name}"
     end
 
-    sig { params(args: T::Hash[T.any(String, Symbol), T.untyped]).returns(T::Hash[Symbol, T.untyped]) }
+    sig {
+      params(
+        args: T::Hash[T.any(String, Symbol), T.untyped],
+      ).returns(T::Hash[Symbol, T.untyped])
+    }
     def to_redis_hash(args)
-      args.map { |key, val| [key.to_sym, encode_attr_value(key.to_sym, val)] }.to_h
+      args.map do |key, val|
+        [key.to_sym, encode_attr_value(key.to_sym, val)]
+      end.to_h
     end
 
-    sig { params(args: T::Hash[T.untyped, T.untyped]).returns(T::Hash[T.untyped, T.untyped]) }
+    sig {
+      params(
+        args: T::Hash[T.untyped, T.untyped],
+      ).returns(T::Hash[T.untyped, T.untyped])
+    }
     def from_redis_hash(args)
       args.map { |key, val| [key, decode_attr_value(key.to_sym, val)] }.to_h
     end