redlics 0.1.0

data/lib/redlics/query.rb

@@ -0,0 +1,234 @@
+module Redlics
+
+  # Query class
+  class Query
+
+
+    # Include Redlics operators.
+    include Redlics::Operators
+
+
+    # Gives read access to the listed instance variables.
+    attr_reader :namespaces
+
+
+    # Initialization of a query object
+    #
+    # @param event [String] event name with eventual Redis namespace separator
+    # @param time_object [Symbol] time object predefined in Redlics::TimeFrame.init_with_symbol
+    # @param time_object [Hash] time object with keys `from` and `to`
+    # @param time_object [Range] time object as range
+    # @param time_object [Time] time object
+    # @param options [Hash] configuration options
+    # @return [Redlics::Query] query object
+    def initialize(event, time_object, options = {})
+      @event = event.freeze
+      @time_object = time_object.freeze
+      @options = options
+      @namespaces = []
+      ObjectSpace.define_finalizer(self, self.class.finalize(namespaces)) if Redlics.config.auto_clean
+    end
+
+
+    # Get or process counts on Redis.
+    # @return [Integer] count result of given query
+    def counts
+      @counts ||= (
+        result = Redlics.script(Redlics::LUA_SCRIPT, [], ['counts'.to_msgpack, realize_counts!.to_msgpack,
+                                { bucketized: Redlics.config.bucket }.to_msgpack])
+        result.is_a?(Array) ? result.map(&:to_i).reduce(0, :+) : result.to_i
+      )
+    end
+
+
+    # Get or process tracks on Redis.
+    # @return [Integer] tracks result of given query
+    def tracks
+      @tracks ||= Redlics.redis.bitcount(track_bits)
+    end
+
+
+    # Get or process track bits on Redis.
+    # @return [String] key of track bits result
+    def track_bits
+      @track_bits ||= (
+        @track_bits_namespace = Key.unique_namespace
+        @namespaces << @track_bits_namespace
+        Redlics.script(Redlics::LUA_SCRIPT, [], ['operation'.to_msgpack, realize_tracks!.to_msgpack,
+                       { operator: 'OR', dest: Key.with_namespace(@track_bits_namespace) }.to_msgpack])
+        @track_bits_namespace
+      )
+    end
+
+
+    # Check if object id exists in track bits.
+    # @return [Boolean] true if exists, false if not
+    # @return [NilClass] nil if no object id is given
+    def exists?
+      @exists ||= @options[:id] ? Redlics.redis.getbit(track_bits, @options[:id]) == 1 : nil
+    end
+
+
+    # Get or process counts and plot.
+    #
+    # @return [Hash] with date times and counts
+    # @return [NilClass] nil if result has errors
+    def plot_counts
+      @plot_counts ||= (
+        result = JSON.parse(
+          Redlics.script(Redlics::LUA_SCRIPT, [], ['plot_counts'.to_msgpack, realize_counts!.to_msgpack,
+                         { bucketized: Redlics.config.bucket }.to_msgpack])
+        )
+        format_plot(Redlics::CONTEXTS[:counter], result)
+      )
+    rescue JSON::ParserError
+      nil
+    end
+
+
+    # Get or process tracks and plot.
+    #
+    # @return [Hash] with date times and counts
+    # @return [NilClass] nil if result has errors
+    def plot_tracks
+      @plot_tracks ||= (
+        result = JSON.parse(
+        Redlics.script(Redlics::LUA_SCRIPT, [], ['plot_tracks'.to_msgpack, realize_tracks!.to_msgpack,
+                       {}.to_msgpack])
+        )
+        format_plot(Redlics::CONTEXTS[:tracker], result)
+      )
+    rescue JSON::ParserError
+      nil
+    end
+
+
+    # Get or process counts and show keys to analyze.
+    # @return [Array] list of keys to analyze
+    def realize_counts!
+      @realize_counts ||= (
+        keys = Key.timeframed(Redlics::CONTEXTS[:counter], @event, @time_object, @options)
+        raise Exception::LuaRangeError if keys.length > 8000
+        keys
+      )
+    end
+
+
+    # Get or process tracks and show keys to analyze.
+    # @return [Array] list of keys to analyze
+    def realize_tracks!
+      @realize_tracks ||= (
+        keys = Key.timeframed(Redlics::CONTEXTS[:tracker], @event, @time_object, @options)
+        raise Exception::LuaRangeError if keys.length > 8000
+        keys
+      )
+    end
+
+
+    # Reset processed data (also operation keys on Redis).
+    #
+    # @param space [Symbol] define space to reset
+    # @param space [String] define space to reset
+    # @return [Boolean] true
+    def reset!(space = nil)
+      space = space.to_sym if space
+      case space
+      when :counts, :plot_counts, :plot_tracks, :realize_counts, :realize_tracks
+        instance_variable_set("@#{space}", nil)
+      when :tracks, :exists
+        instance_variable_set("@#{space}", nil)
+        reset_track_bits
+      when :counter
+        @counts, @plot_counts, @realize_counts = [nil] * 3
+      when :tracker
+        @tracks, @exists, @plot_tracks, @realize_tracks = [nil] * 4
+        reset_track_bits
+      else
+        @counts, @tracks, @exists, @plot_counts, @plot_tracks, @realize_counts, @realize_tracks = [nil] * 7
+        reset_track_bits
+        self.class.reset_redis_namespaces(@namespaces)
+        @namespaces = []
+      end
+      return true
+    end
+
+
+    # Check if query is a leaf. A query is always a leaf.
+    # This method is required for query operations.
+    # @return [Boolean] true
+    def is_leaf?
+      true
+    end
+
+
+    # Singleton class
+    class << self
+
+      # Short query access to analyze data.
+      #
+      # @param *args [Array] list of arguments of the query
+      # @return [Redlics::Query] instantiated query object
+      def analyze(*args)
+        options = args.last.instance_of?(Hash) ? args.pop : {}
+        query = case args.size
+                when 2
+                  Query.new(args[0], args[1], options)
+                when 3
+                  Query.new(args[0], args[1], options.merge!({ id: args[2].to_i }))
+                end
+        return yield query if block_given?
+        query
+      end
+
+
+      # Finalize query called from garbage collector.
+      #
+      # @param namespaces [Array] list of created operation keys in Redis
+      # @return [Integer] result of Redis delete keys
+      # @return [NilClass] nil if namespaces are empty
+      def finalize(namespaces)
+        proc { reset_redis_namespaces(namespaces); puts 'Redlics clean!' }
+      end
+
+
+      # Reset Redis created namespace keys.
+      #
+      # @param namespaces [Array] list of created operation keys in Redis
+      # @return [Integer] result of Redis delete keys
+      # @return [NilClass] nil if namespaces are empty
+      def reset_redis_namespaces(namespaces)
+        Redlics.redis.del(namespaces) if namespaces.any?
+      end
+
+    end
+
+
+    private
+
+      # Format plot result with time objects as keys.
+      #
+      # @param context [Hash] the hash of a context defined in Redlics::CONTEXTS
+      # @param result [Hash] the result hash with Redis keys as hash keys
+      # @return [Hash] the formatted result hash
+      def format_plot(context, result)
+        granularity = Granularity.validate(context, @options[:granularity]).first
+        pattern = Redlics.config.granularities[granularity][:pattern]
+        el = Key.bucketize?(context, @options) ? -2 : -1
+        result.keys.each { |k|
+          result[Time.strptime(k.split(Redlics.config.separator)[el], pattern)] = result.delete(k)
+        }
+        result
+      end
+
+
+      # Reset track bits (also operation key on Redis).
+      # @return [NilClass] nil
+      def reset_track_bits
+        self.class.reset_redis_namespaces([@track_bits_namespace])
+        @namespaces.delete(@track_bits_namespace)
+        @track_bits, @track_bits_namespace = nil, nil
+      end
+
+  end
+end
+

data/lib/redlics/query/operation.rb

@@ -0,0 +1,135 @@
+module Redlics
+  class Query
+
+    # Operation class
+    class Operation
+
+      # Include Redlics operators.
+      include Redlics::Operators
+
+
+      # Gives read access to the listed instance variables.
+      attr_reader :namespaces
+
+
+      # Initialization of a query operation object.
+      #
+      # @param operator [String] operator to calculate
+      # @param queries [Array] queries to calculate with the given operator
+      # @return [Redlics::Query::Operation] query operation object
+      def initialize(operator, queries)
+        @operator = operator.upcase.freeze
+        @queries = queries.freeze
+        @track_bits = nil
+        @namespaces = []
+        ObjectSpace.define_finalizer(self, self.class.finalize(namespaces)) if Redlics.config.auto_clean
+      end
+
+
+      # Get or process tracks on Redis.
+      # @return [Integer] tracks result of given query operation
+      def tracks
+        @tracks ||= (
+          Redlics.redis.bitcount(@track_bits || traverse)
+        )
+      end
+
+
+      # Get or process track bits on Redis.
+      # @return [String] key of track bits result
+      def track_bits
+        @track_bits ||= (
+          keys = []
+          track_bits_namespace = Key.unique_namespace
+          @namespaces << track_bits_namespace
+          if @operator == 'NOT'
+            keys << Key.with_namespace(@queries[0].track_bits)
+          else
+            @queries.each { |q| keys << Key.with_namespace(q.track_bits) }
+          end
+          Redlics.script(Redlics::LUA_SCRIPT, [], ['operation'.to_msgpack, keys.to_msgpack,
+                         { operator: @operator, dest: Key.with_namespace(track_bits_namespace) }.to_msgpack])
+          track_bits_namespace
+        )
+      end
+
+
+      # Check if object id exists in track bits.
+      #
+      # @param [Integer] the object id to check
+      # @return [Boolean] true if exists, false if not
+      def exists?(id)
+        Redlics.redis.getbit(@track_bits || traverse, id.to_i) == 1
+      end
+
+
+      # Reset processed data (also operation keys on Redis).
+      #
+      # @param space [Symbol] define space to reset
+      # @param space [String] define space to reset
+      # @return [Boolean] true
+      def reset!(space = nil)
+        space = space.to_sym if space
+        case space
+        when :tree
+          @queries.each { |q| q.reset!(:tree) }
+          reset!
+        else
+          @tracks, @track_bits = nil, nil
+          self.class.reset_redis_namespaces(@namespaces)
+          @namespaces = []
+        end
+        return true
+      end
+
+
+      # Check if query operation is a leaf in the binary tree.
+      # @return [Boolean] true if a leaf, false if not
+      def is_leaf?
+        is_a?(Redlics::Query::Operation) && @track_bits.nil?
+      end
+
+
+      # Singleton class
+      class << self
+
+        # Finalize query operation called from garbage collector.
+        #
+        # @param namespaces [Array] list of created operation keys in Redis
+        # @return [Integer] result of Redis delete keys
+        # @return [NilClass] nil if namespaces are empty
+        def finalize(namespaces)
+          proc { reset_redis_namespaces(namespaces) }
+        end
+
+
+        # Reset Redis created namespace keys.
+        #
+        # @param namespaces [Array] list of created operation keys in Redis
+        # @return [Integer] result of Redis delete keys
+        # @return [NilClass] nil if namespaces are empty
+        def reset_redis_namespaces(namespaces)
+          Redlics.redis.del(namespaces) if namespaces.any?
+        end
+
+      end
+
+
+      private
+
+
+        # Traverse query operation binary tree and calculate operation leafs.
+        # @return [String] result operation key in Redis
+        def traverse
+          if @operator == 'NOT'
+            @queries[0].traverse unless @queries[0].is_leaf?
+            track_bits
+          else
+            @queries.each { |q| q.traverse unless q.is_leaf? }
+            track_bits
+          end
+        end
+
+    end
+  end
+end

data/lib/redlics/time_frame.rb

@@ -0,0 +1,110 @@
+module Redlics
+
+  # Time Frame class
+  class TimeFrame
+
+    # Gives read access to the listed instance variables.
+    attr_reader :from, :to, :granularity
+
+
+    # Initialization of a time frame object.
+    #
+    # @param context [Hash] the hash of a context defined in Redlics::CONTEXTS
+    # @param time_object [Symbol] time object predefined in Redlics::TimeFrame.init_with_symbol
+    # @param time_object [Hash] time object with keys `from` and `to`
+    # @param time_object [Range] time object as range
+    # @param time_object [Time] time object
+    # @param options [Hash] configuration options
+    # @return [Redlics::TimeFrame] time frame object
+    def initialize(context, time_object, options = {})
+      raise ArgumentError, 'TimeFrame should be initialized with Symbol, Hash, Range or Time' unless [Symbol, Hash, Range, Time].include?(time_object.class)
+      @from, @to = self.send("init_with_#{time_object.class.name.demodulize.underscore}", time_object, context)
+      @granularity = Granularity.validate(context, options[:granularity]).first
+    end
+
+
+    # Construct keys by time frame steps.
+    # @return [Array] keys
+    def splat
+      [].tap do |keys|
+        (from.to_i .. to.to_i).step(Redlics.config.granularities[@granularity][:step]) do |t|
+          keys << (block_given? ? (yield Time.at(t)) : Time.at(t))
+        end
+      end
+    end
+
+
+    private
+
+      # Initialize time frames `from` and `to` by time.
+      #
+      # @param time [Time] a time
+      # @param context [Hash] the hash of a context defined in Redlics::CONTEXTS
+      # @return [Array] with `from` and `to` time
+      def init_with_time(time, context)
+        [time.beginning_of_day, time.end_of_day]
+      end
+
+
+      # Initialize time frames `from` and `to` by symbol.
+      #
+      # @param symbol [Symbol] a time span
+      # @param context [Hash] the hash of a context defined in Redlics::CONTEXTS
+      # @return [Array] with `from` and `to` time
+      def init_with_symbol(symbol, context)
+        case symbol
+        when :hour, :day, :week, :month, :year
+          return 1.send(symbol).ago, Time.now
+        when :today
+          return Time.now.beginning_of_day, Time.now
+        when :yesterday
+          return 1.day.ago.beginning_of_day, 1.day.ago.end_of_day
+        when :this_week
+          return Time.now.beginning_of_week, Time.now
+        when :last_week
+          return 1.week.ago.beginning_of_week, 1.week.ago.end_of_week
+        when :this_month
+          return Time.now.beginning_of_month, Time.now
+        when :last_month
+          return 1.month.ago.beginning_of_month, 1.month.ago.end_of_month
+        when :this_year
+          return Time.now.beginning_of_year, Time.now
+        when :last_year
+          return 1.year.ago.beginning_of_year, 1.year.ago.end_of_year
+        else
+          return default(context), Time.now
+        end
+      end
+
+
+      # Initialize time frames `from` and `to` by hash.
+      #
+      # @param hash [Hash] a time hash with keys `from` and `to`
+      # @param context [Hash] the hash of a context defined in Redlics::CONTEXTS
+      # @return [Array] with `from` and `to` time
+      def init_with_hash(hash, context)
+        [ hash[:from] && hash[:from].is_a?(String) && Time.parse(hash[:from]) || hash[:from] || default(context),
+          hash[:to]   && hash[:to].is_a?(String)   && Time.parse(hash[:to])   || hash[:to]   || Time.now ]
+      end
+
+
+      # Initialize time frames `from` and `to` by hash.
+      #
+      # @param range [Range] a time range
+      # @param context [Hash] the hash of a context defined in Redlics::CONTEXTS
+      # @return [Array] with `from` and `to` time
+      def init_with_range(range, context)
+        init_with_hash({ from: range.first, to: range.last }, context)
+      end
+
+
+      # Get default granularity by given context.
+      #
+      # @param context [Hash] the hash of a context defined in Redlics::CONTEXTS
+      # @return [ActiveSupport::TimeWithZone] a time
+      def default(context)
+        Redlics.config.granularities[Granularity.default(context).first][:step].ago
+      end
+
+  end
+end