active_redis 0.0.7 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 045f4c85e0aeb767fd6391f797427c932771c9b7
-  data.tar.gz: 9e250673aa1a847c1bdd33a1f85550ea9cedc8e1
+  metadata.gz: 15b35e41e228279d6ebc16ce99d25115d786074f
+  data.tar.gz: 150c894dcd3e562549d4ee6a52a005020f262cc5
 SHA512:
-  metadata.gz: 3f54e5432066d8cd19c9844e84dc37b68d4a15bc02c2b13dc7ee618a9934c0edae3aa23685f835a45fdf69dd50b01ed64e20f6bbb41916da8f417a400c26961b
-  data.tar.gz: 91f1c901ff380025adc212ff0adb214d7f2c6577cffbd0017f3cf4f99752d4c4ded90efd9a74112cbad9350315f66421fd9a6b502b65b0df5faed39bbd7c3598
+  metadata.gz: 288bb1c18077d83a21a80d846d520f5a9f0539a31ce9dfeb24c76bf64d4b5c90a9adac9fcb69e601c2c9a2ca43724ad8c6266a9a714eb44301802bff56f7906d
+  data.tar.gz: fa32af2552935029c263779f957a592fe29763ac7d997ea10a5b2c5ec53e4c755d3f2753f4ea52452939381a9a2044d25d94a5107b15dccd0784de84c08e5827

data/README.md

@@ -140,6 +140,10 @@ Method chaining. Now you may calling __where__, __order__, __limit__ something l
 Article.where(title: "Article title").where(views: 1000).order(title: :asc).limit(per_page: 20, page: 3)
 ```
 
+## NEW IN VERSION 0.0.8
+
+Using aggregation functions with method chaining functional.
+
 ## Contributing
 
 1. Fork it

data/lib/active_redis/connection_ext/finders_layer.rb

@@ -22,7 +22,7 @@ module ActiveRedis::ConnectionExt
       run_eval :where, [model.key_name], params.flatten
     end
 
-    def run_query_analyzer(model, params = ["", "", ""])
+    def run_query_analyzer(model, params = ["", "", "", ""])
       run_eval :query_analyzer, [model.key_name, Time.now.to_i], params
     end
 

data/lib/active_redis/constants.rb

@@ -9,5 +9,9 @@ module ActiveRedis
 
     ASSOCIATIONS = [:has_one, :has_many, :belongs_to]
 
+    RELATION_METHODS = %w{where order limit first all}
+
+    QUERY_METHODS = CALCULATION_METHODS + RELATION_METHODS
+
   end
 end

data/lib/active_redis/lua_scripts/main.lua

@@ -131,11 +131,11 @@ local fetch_row = function(key, id)
   return redis.call("HGETALL", name)
 end
 
--- Query analyzer for searching
+-- Fetching objects collection by query params
 --
 -- key  - table name
--- argv - array with query parameters WHERE, ORDER, LIMIT
-local query_analyzer = function (keys, argv)
+-- argv - array with query params
+local fetch_collection = function(keys, argv)
   local temp_list = apply_where(keys[1], argv[1], tonumber(keys[2]))
   local sort_command = {"SORT", temp_list}
   sort_command = apply_order(keys[1], sort_command, argv[2])
@@ -147,3 +147,109 @@ local query_analyzer = function (keys, argv)
   end
   return result
 end
+
+-- Fetching value from record by field name
+--
+-- record - record array
+-- field  - field name
+local fetch_value_by_field = function(record, field)
+  for i = 1, #record, 2 do
+    if record[i] == field then
+      return record[i+1]
+    end
+  end
+  return ""
+end
+
+-- Fetching values from specified field to array
+--
+-- collection - array of objects
+-- param      - field name
+local fetch_field_values_array = function(collection, field)
+  local result = {}
+  for index, record in pairs(collection) do
+    table.insert(result, fetch_value_by_field(record, param))
+  end
+  return result
+end
+
+local aggregation_functions = {
+  -- Applying count aggregation function
+  --
+  -- collection - array of objects for processing
+  -- param      - particular param for aggregation function
+  aggregation_count = function(collection, param)
+    return #collection
+  end,
+
+  -- Applying sum aggregation function
+  --
+  -- collection - array of objects for processing
+  -- param      - particular param for aggregation function
+  aggregation_sum = function(collection, param)
+    local sum = 0
+    for index, record in pairs(collection) do
+      sum = sum + tonumber(fetch_value_by_field(record, param))
+    end
+    return sum
+  end,
+
+  -- Applying pluck aggregation function
+  --
+  -- collection - array of objects for processing
+  -- param      - particular param for aggregation function
+  aggregation_pluck = function(collection, param)
+    return fetch_field_values_array(collection, param)
+  end,
+
+  -- Applying min aggregation function
+  --
+  -- collection - array of objects for processing
+  -- param      - particular param for aggregation function
+  aggregation_min = function(collection, param)
+    local result = fetch_field_values_array(collection, param)
+    table.sort(result)
+    return result[1]
+  end,
+
+  -- Applying max aggregation function
+  --
+  -- collection - array of objects for processing
+  -- param      - particular param for aggregation function
+  aggregation_max = function(collection, param)
+    local result = fetch_field_values_array(collection, param)
+    table.sort(result)
+    return result[#result]
+  end
+}
+
+-- Applying aggregation functions to collection
+--
+-- collection   - array of objects for processing
+-- aggr_options - string with aggregation information
+local process_aggregation = function(collection, aggr_options)
+  local aggr_arr = split(aggr_options, "=")
+  local aggr_function_name = "aggregation_"..aggr_arr[1]
+  --return _G[aggr_function_name](collection, aggr_arr[2])
+  return aggregation_functions[aggr_function_name](collection, aggr_arr[2])
+end
+
+-- Checking if query is single value
+--
+-- argv - array with query parameters
+local is_single_value_query = function(argv)
+  return string.len(argv[4]) ~= 0
+end
+
+-- Query analyzer for searching
+--
+-- key  - table name
+-- argv - array with query parameters WHERE, ORDER, LIMIT, AGGREGATION
+local query_analyzer = function (keys, argv)
+  local collection = fetch_collection(keys, argv)
+  if is_single_value_query(argv) == true then
+    return process_aggregation(collection, argv[4])
+  else
+    return collection
+  end
+end

data/lib/active_redis/query_chainer.rb

@@ -1,5 +1,6 @@
 require 'active_redis/relation'
 require 'active_redis/query_iterator'
+require 'active_redis/constants'
 
 module ActiveRedis
   autoload :QueryExecutor, 'active_redis/query_executor'
@@ -8,10 +9,13 @@ module ActiveRedis
     include Relation
     include QueryIterator
 
+    attr_reader :where_options, :order_options, :limit_options, :aggregation_options, :target
+
     def initialize(target)
       @where_options = {}
       @order_options = {id: :asc}
-      @limit_options = {per_page: 10, page: 0}
+      @limit_options = {}
+      @aggregation_options = {}
       @target = target
     end
 
@@ -26,14 +30,24 @@ module ActiveRedis
     end
 
     def apply_limit(options)
-      @limit_options = options if options.any?
+      @limit_options = options
       self
     end
 
-    def apply_top(options)
+    def apply_first(options)
       apply_limit per_page: 1, page: 0
     end
 
+    def apply_all(options)
+      apply_limit Hash.new
+    end
+
+    ActiveRedis::Constants::CALCULATION_METHODS.each do |method|
+      define_method "apply_#{method}" do |field|
+        apply_aggregation(method, field)
+      end
+    end
+
     def reload
       @collection = nil
     end
@@ -44,16 +58,21 @@ module ActiveRedis
 
     private
 
+    def apply_aggregation(type, field)
+      @aggregation_options = {type => field}
+      execute_query
+    end
+
     def execute_query
-      QueryExecutor.execute(@target, @where_options, @order_options, @limit_options)
+      QueryExecutor.execute self
     end
 
     def objects_by_query
       res = execute_query.inject([]) { |arr, attrs| arr << @target.new(attrs) if attrs && attrs.any?; arr }
-      top_limit? ? res.first : res
+      first_limit? ? res.first : res
     end
 
-    def top_limit?
+    def first_limit?
       @limit_options[:per_page] == 1 && @limit_options[:page] == 0
     end
 

data/lib/active_redis/query_executor.rb

@@ -1,12 +1,16 @@
 module ActiveRedis
   class QueryExecutor
 
-    def self.execute(target, where, order, limit)
-      ActiveRedis.connection.run_query_analyzer target, [prepare_where(where), prepare_order(order), prepare_limit(limit)]
+    def self.execute(chainer)
+      ActiveRedis.connection.run_query_analyzer(chainer.target, prepare_params(chainer))
     end
 
     private
 
+    def self.prepare_params(chainer)
+      [prepare_where(chainer.where_options), prepare_order(chainer.order_options), prepare_limit(chainer.limit_options), prepare_aggregation(chainer.aggregation_options)]
+    end
+
     def self.prepare_where(where)
       where.keys.map{|key| "#{key}=#{where[key]}" }.join(",")
     end
@@ -20,5 +24,9 @@ module ActiveRedis
       limit.any? ? "#{limit[:page]}=#{limit[:per_page]}" : ""
     end
 
+    def self.prepare_aggregation(aggregation)
+      aggregation.inject("") {|str, (k, v)| str = "#{k}=#{v}" }
+    end
+
   end
 end

data/lib/active_redis/query_iterator.rb

@@ -1,6 +1,5 @@
 module ActiveRedis
   module QueryIterator
-    include Enumerable
 
     def method_missing(method, *args)
       unless linked_objects.is_a? Array

data/lib/active_redis/relation.rb

@@ -1,8 +1,10 @@
+require 'active_redis/constants'
+
 module ActiveRedis
   autoload :QueryChainer,   'active_redis/query_chainer'
   module Relation
 
-    %w{where order limit top}.each do |method|
+    ActiveRedis::Constants::QUERY_METHODS.each do |method|
       class_eval <<-CODE
         def #{method}(options = {})
           if self.class.name == "ActiveRedis::QueryChainer"

data/lib/active_redis/version.rb

@@ -1,3 +1,3 @@
 module ActiveRedis
-  VERSION = "0.0.7"
+  VERSION = "0.0.8"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: active_redis
 version: !ruby/object:Gem::Version
-  version: 0.0.7
+  version: 0.0.8
 platform: ruby
 authors:
 - Sergey Gernyak
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-11-16 00:00:00.000000000 Z
+date: 2013-11-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: redis