skydb 0.2.2 → 0.2.3

data/lib/skydb/import/transforms/apache.yml

@@ -0,0 +1,4 @@
+translate: |
+  output[:object_id] = input[:ip_address]
+  output[:timestamp] = input[:timestamp]
+  output[:action][:name] = input[:url]

data/lib/skydb/import/transforms/sky.yml

@@ -1,20 +1,28 @@
 fields:
-  object_id: object_id:int
+  object_id: object_id
   timestamp: timestamp:date
 
 translate: |
-  input.each_pair do |k, v|
-    m, prefix, field, data_type  = *k.match(/^(?:(action|data)\.)?(\w+)(?:\:(\w+))?$/)
-    next unless ["object_id", "timestamp"].index(field).nil?
+  def process(_input, _output)
+    _input.each_pair do |k, v|
+      if v.is_a?(Hash)
+        _output[k] = {}
+        process(v, _output[k])
+      else
+        m, prefix, field, data_type  = *k.match(/^(?:(action|data)\.)?(\w+)(?:\:(\w+))?$/)
+        next unless ["object_id", "timestamp"].index(field).nil?
     
-    output[prefix] ||= {} unless prefix.nil?
-    target = prefix.nil? ? output : output[prefix]
+        _output[prefix] ||= {} unless prefix.nil?
+        target = prefix.nil? ? _output : _output[prefix]
 
-    target[field] = case data_type.to_s.downcase
-    when "int" then v.to_i
-    when "float" then v.to_f
-    when "boolean" then (v.downcase == "true" || v.downcase == "yes" || v.downcase == "y")
-    when "date" then Chronic.parse(v)
-    else v.to_s
+        target[field] = case data_type.to_s.downcase
+        when "int" then v.to_i
+        when "float" then v.to_f
+        when "boolean" then (v.downcase == "true" || v.downcase == "yes" || v.downcase == "y")
+        when "date" then Chronic.parse(v)
+        else v.to_s
+        end
+      end
     end
   end
+  process(input, output)

data/lib/skydb/message.rb

@@ -126,6 +126,7 @@ end
 require 'skydb/message/create_table'
 require 'skydb/message/delete_table'
 require 'skydb/message/get_table'
+require 'skydb/message/get_tables'
 
 require 'skydb/message/add_action'
 require 'skydb/message/get_action'

data/lib/skydb/message/add_event.rb

@@ -47,7 +47,7 @@ class SkyDB
       def validate!
         super
         
-        if !(event.object_id > 0)
+        if event.object_id.nil?
           raise SkyDB::ObjectIdRequiredError.new('Object ID required')
         end
         

data/lib/skydb/message/get_actions.rb

@@ -29,6 +29,10 @@ class SkyDB
       def encode_body(buffer)
         # Do nothing.
       end
+
+      def process_response(response)
+        return response['actions']
+      end
     end
   end
 end

data/lib/skydb/message/get_properties.rb

@@ -29,6 +29,10 @@ class SkyDB
       def encode_body(buffer)
         # Do nothing.
       end
+
+      def process_response(response)
+        return response['properties']
+      end
     end
   end
 end

data/lib/skydb/message/get_tables.rb

@@ -0,0 +1,43 @@
+class SkyDB
+  class Message
+    class GetTables < SkyDB::Message
+      ########################################################################
+      #
+      # Constructor
+      #
+      ########################################################################
+
+      # Initializes the 'get_tables' message.
+      def initialize(options={})
+        super('get_tables')
+      end
+
+
+      ##########################################################################
+      #
+      # Methods
+      #
+      ##########################################################################
+
+      ##################################
+      # Validation
+      ##################################
+
+      # A flag stating if the table is required for this type of message.
+      def require_table?
+        return false
+      end
+
+      ####################################
+      # Encoding
+      ####################################
+
+      def process_response(response)
+        tables = []
+        response['tables'].each do |hash|
+          tables << SkyDB::Table.new(hash['name'])
+        end
+      end
+    end
+  end
+end

data/lib/skydb/message/lua/aggregate.rb

@@ -53,6 +53,10 @@ class SkyDB
             :source => source
           }.to_msgpack
         end
+
+        def process_response(response)
+          return response['data']
+        end
       end
     end
   end

data/lib/skydb/property.rb

@@ -89,5 +89,15 @@ class SkyDB
         name:name
       }.to_msgpack
     end
+
+    # Encodes the property into JSON format.
+    def to_json(*a)
+      {
+        'id' => id,
+        'type' => type,
+        'dataType' => data_type,
+        'name' => name
+      }.to_json(*a)
+    end
   end
 end

data/lib/skydb/query.rb

@@ -1,5 +1,7 @@
 require 'skydb/query/selection'
-require 'skydb/query/after'
+require 'skydb/query/condition'
+require 'skydb/query/after_condition'
+require 'skydb/query/on_condition'
 require 'skydb/query/validation_error'
 
 class SkyDB
@@ -17,8 +19,7 @@ class SkyDB
 
     def initialize(options={})
       self.client = options[:client]
-      self.selection = options[:selection] || SkyDB::Query::Selection.new()
-      self.conditions = options[:conditions] || []
+      self.selection = options[:selection]
     end
     
 
@@ -32,10 +33,13 @@ class SkyDB
     attr_accessor :client
 
     # The properties that should be selected from the database.
-    attr_accessor :selection
-
-    # A list of conditions that must be fulfilled before selection can occur.
-    attr_accessor :conditions
+    attr_reader :selection
+    
+    def selection=(value)
+      @selection = value
+      value.query = self unless value.nil?
+      return value
+    end
 
     # The number of idle seconds that separates sessions. 
     attr_accessor :session_idle_time
@@ -51,34 +55,15 @@ class SkyDB
     # Helpers
     ####################################
 
-    # Adds a list of fields to the selection.
+    # Creates and appends a new selection to the query.
     #
     # @param [String] fields  A list of fields to add to the selection.
     #
-    # @return [Query]  The query object is returned.
+    # @return [Selection]  The newly created selection object is returned.
     def select(*fields)
+      self.selection = SkyDB::Query::Selection.new()
       selection.select(*fields)
-      return self
-    end
-
-    # Adds one or more grouping fields to the selection of the query.
-    #
-    # @param [String] groups  A list of groups to add to the selection.
-    #
-    # @return [Query]  The query object is returned.
-    def group_by(*groups)
-      selection.group_by(*groups)
-      return self
-    end
-
-    # Adds an 'after' condition to the query.
-    #
-    # @param [Hash] options  The options to pass to the 'after' condition.
-    #
-    # @return [Query]  The query object is returned.
-    def after(options={})
-      conditions << SkyDB::Query::After.new(options)
-      return self
+      return selection
     end
 
     # Sets the session idle seconds and returns the query object.
@@ -133,43 +118,47 @@ class SkyDB
 
       # Generate selection.
       code = []
-      code << selection.codegen_select()
-      
-      # Generate condition functions.
-      conditions.each_with_index do |condition, index|
-        condition.function_name ||= "__condition#{nextseq}"
-        code << condition.codegen
-      end
-
-      # Generate the invocation of the conditions.
-      conditionals = conditions.map {|condition| "#{condition.function_name}(cursor, data)"}.join(' and ')
-      conditionals = "true" if conditions.length == 0
+      code << selection.codegen()
       
       # Generate aggregate() function.
       code << "function aggregate(cursor, data)"
       code << "  cursor:set_session_idle(#{session_idle_time.to_i})" if session_idle_time.to_i > 0
-      code << "  while cursor:next_session() do"
-      code << "    while cursor:next() do"
-      code << "      if #{conditionals} then"
-      code << "        select(cursor, data)"
-      code << "      end"
-      code << "    end"
-      code << "  end"
+      code << "  select_all(cursor, data)"
       code << "end"
       code << ""
-
-      # Generate merge function.
-      code << selection.codegen_merge()
       
       return code.join("\n")
     end
 
 
     ####################################
-    # Utility
+    # Serialization
     ####################################
     
-    private
+    # Serializes the query object into a JSON string.
+    def to_json(*a); to_hash.to_json(*a); end
+
+    # Serializes the query object into a hash.
+    def to_hash(*a)
+      hash = {}
+      hash['selections'] = [selection.to_hash(*a)] unless selection.nil?
+      hash['sessionIdleTime'] = session_idle_time.to_i
+      hash
+    end
+
+    # Deserializes the query object into a hash.
+    def from_hash(hash, *a)
+      return if hash.nil?
+      selection_hash, x = *hash['selections']
+      self.selection = SkyDB::Query::Selection.new.from_hash(selection_hash)
+      self.session_idle_time = hash['sessionIdleTime'].to_i
+      return self
+    end
+    
+
+    ####################################
+    # Utility
+    ####################################
     
     # Generates a sequence number used for uniquely naming objects and
     # functions in the query.
@@ -179,13 +168,9 @@ class SkyDB
 
     # Looks up all actions and properties that are missing an identifier.
     def lookup_identifiers
-      # Find all the actions on conditions that are missing an id.
+      # Find all the actions on the selection that are missing an id.
       actions = []
-      conditions.each do |condition|
-        if condition.action.is_a?(SkyDB::Action) && condition.action.id.to_i == 0
-          actions << condition.action
-        end
-      end
+      actions.concat(selection.get_identifiers())
 
       # Lookup all the actions.
       if actions.length > 0

data/lib/skydb/query/after_condition.rb

@@ -0,0 +1,104 @@
+class SkyDB
+  class Query
+    # The 'after' condition filters out selection only after the condition
+    # has been fulfilled.
+    class AfterCondition < SkyDB::Query::Condition
+      ##########################################################################
+      #
+      # Constructor
+      #
+      ##########################################################################
+
+      def initialize(action=nil, options={})
+        options.merge!(action.is_a?(Hash) ? action : {:action => action})
+        super(options)
+        self.within = options[:within]
+      end
+    
+
+      ##########################################################################
+      #
+      # Attributes
+      #
+      ##########################################################################
+      
+      attr_accessor :within
+      
+
+      ##########################################################################
+      #
+      # Methods
+      #
+      ##########################################################################
+
+      ##################################
+      # Validation
+      ##################################
+
+      # Validates that the object is correct before executing a codegen.
+      def validate!
+        # Do not allow the :enter action. That is reserved for the 'On'
+        # condition.
+        if action == :enter
+          raise SkyDB::Query::ValidationError.new("Enter actions cannot be used with an 'after' condition. Please use an 'on' condition instead.")
+        end
+
+        super
+        
+        return nil
+      end
+
+
+      ##################################
+      # Codegen
+      ##################################
+
+      # Generates Lua code to match a given action.
+      def codegen(options={})
+        header, body, footer = "function #{function_name.to_s}(cursor, data)\n", [], "end\n"
+        within_unit = (within.nil? ? nil : within[:unit])
+        
+        # Find the matching event and then move to the next one for selection.
+        body << "if cursor:eos() or cursor:eof() then return false end"
+        body << "remaining = #{within[:quantity].to_i}" if within_unit == 'step'
+        body << "repeat"
+        body << "  if remaining <= 0 then return false end" if within_unit == 'step'
+        body << "  if cursor.event.action_id == #{action.id.to_i} then"
+        body << "    cursor:next()"
+        body << "    return true"
+        body << "  end"
+        body << "  remaining = remaining - 1" if within_unit == 'step'
+        body << "until not cursor:next()"
+        body << "return false"
+
+        # Indent body and return.
+        body.map! {|line| "  " + line}
+        return header + body.join("\n") + "\n" + footer
+      end
+
+
+      ####################################
+      # Serialization
+      ####################################
+    
+      # Serializes the condition into a hash.
+      def to_hash(*a)
+        json = super(*a)
+        json['within'] = within.to_hash(*a) unless within.nil?
+        json
+      end
+
+      # Deserializes the condition from a hash.
+      def from_hash(hash, *a)
+        super(hash, *a)
+        return nil if hash.nil?
+        
+        hash['within']._symbolize_keys! unless hash['within'].nil?
+        self.within = hash['within']
+
+        return self
+      end
+    end
+  end
+end
+

data/lib/skydb/query/{after.rb → condition.rb}

@@ -1,16 +1,15 @@
 class SkyDB
   class Query
-    # The 'after' condition filters out selection only after the condition
-    # has been fulfilled.
-    class After
+    # The Condition class is the base class for all query classes that limit
+    # the selection.
+    class Condition
       ##########################################################################
       #
       # Constructor
       #
       ##########################################################################
 
-      def initialize(action=nil, options={})
-        options.merge!(action.is_a?(Hash) ? action : {:action => action})
+      def initialize(options={})
         self.action = options[:action]
         self.function_name = options[:function_name]
       end
@@ -30,13 +29,11 @@ class SkyDB
       attr_reader :action
       
       def action=(value)
-        if value.is_a?(Symbol)
-          @action = :enter
-        elsif value.is_a?(String)
+        if value.is_a?(String)
           @action = SkyDB::Action.new(:name => value)
         elsif value.is_a?(Fixnum)
           @action = SkyDB::Action.new(:id => value)
-        elsif value.is_a?(SkyDB::Action)
+        elsif value.is_a?(SkyDB::Action) || value == :enter
           @action = value
         else
           @action = nil
@@ -57,7 +54,7 @@ class SkyDB
       # Validates that the object is correct before executing a codegen.
       def validate!
         # Require the action identifier.
-        if action.nil? || action.id.to_i == 0
+        if action.nil? || action == :enter || action.id.to_i == 0
           raise SkyDB::Query::ValidationError.new("Action with non-zero identifier required.")
         end
 
@@ -77,25 +74,38 @@ class SkyDB
 
       # Generates Lua code to match a given action.
       def codegen(options={})
-        header, body, footer = "function #{function_name.to_s}(cursor, data)\n", [], "end\n"
-      
-        # If the action is :enter then just check for the beginning of a session.
-        if action == :enter
-          body << "return (cursor.session_event_index == 0)"
-        else
-          # Only move to the next event if directed to by the options.
-          body << "repeat"
-          body << "  if cursor.event.action_id == #{action.id.to_i} then"
-          body << "    cursor:next()"
-          body << "    return true"
-          body << "  end"
-          body << "until not cursor:next()"
-          body << "return false"
+        return "function #{function_name.to_s}(cursor, data) return false end\n"
+      end
+
+
+      ####################################
+      # Serialization
+      ####################################
+    
+      # Serializes the condition into a JSON string.
+      def to_json(*a); to_hash.to_json(*a); end
+
+      # Serializes the condition into a hash.
+      def to_hash(*a)
+        json = {}
+        json['type'] = self.class.to_s.split("::").last.gsub('Condition', '').downcase
+        if action.is_a?(SkyDB::Action)
+          json['action'] = action.to_hash(*a)
+        elsif action.is_a?(Symbol)
+          json['action'] = action
         end
+        json
+      end
 
-        # Indent body and return.
-        body.map! {|line| "  " + line}
-        return header + body.join("\n") + "\n" + footer
+      # Deserializes the condition from a hash.
+      def from_hash(hash, *a)
+        return nil if hash.nil?
+        if hash['action'] == "enter"
+          self.action = hash['action'].to_sym
+        else
+          self.action = SkyDB::Action.new.from_hash(hash['action'], *a)
+        end
+        return self
       end
     end
   end