zermelo 1.0.1 → 1.1.0

data/lib/zermelo/filters/influxdb_filter.rb

@@ -10,7 +10,7 @@ module Zermelo
 
       def _exists?(id)
         return if id.nil?
-        @steps << Zermelo::Filters::Steps::IntersectStep.new({}, {:id => id})
+        @steps << Zermelo::Filters::Steps::SetStep.new({:op => :intersect}, {:id => id})
         resolve_steps(:count) > 0
       end
 
@@ -27,46 +27,6 @@ module Zermelo
         resolve_steps(:count)
       end
 
-      def resolve_step(step)
-        query = ''
-
-        options   = step.options || {}
-        values    = step.attributes
-
-        case step
-        when Zermelo::Filters::Steps::IntersectStep,
-             Zermelo::Filters::Steps::UnionStep
-
-          query += values.collect {|k, v|
-            op, value = case v
-            when String
-              ["=~", "/^#{Regexp.escape(v).gsub(/\\\\/, "\\")}$/"]
-            else
-              ["=",  "'#{v}'"]
-            end
-
-           "#{k} #{op} #{value}"
-          }.join(' AND ')
-
-        when Zermelo::Filters::Steps::DiffStep
-
-          query += values.collect {|k, v|
-            op, value = case v
-            when String
-              ["!~", "/^#{Regexp.escape(v).gsub(/\\\\/, "\\")}$/"]
-            else
-              ["!=",  "'#{v}'"]
-            end
-
-            "#{k} #{op} #{value}"
-          }.join(' AND ')
-        else
-          raise "Unhandled filter operation '#{step_type}'"
-        end
-
-        query
-      end
-
       def escaped_id(id)
         if id.is_a?(Numeric)
           id
@@ -76,64 +36,56 @@ module Zermelo
       end
 
       def resolve_steps(result_type)
+        class_key = @associated_class.send(:class_key)
+
         query = case result_type
         when :ids
-          "SELECT id FROM /#{@associated_class.send(:class_key)}\\/.*/"
+          "SELECT id FROM /#{class_key}\\/.*/"
         when :count
-          "SELECT COUNT(id) FROM /#{@associated_class.send(:class_key)}\\/.*/"
+          "SELECT COUNT(id) FROM /#{class_key}\\/.*/"
         end
 
-        unless @initial_set.id.nil?
+        unless @initial_key.id.nil?
           query += ' WHERE '
 
-          ii_query = "SELECT #{@initial_set.name} FROM \"#{@initial_set.klass}/#{@initial_set.id}\" " +
+          initial_class_key = @initial_key.klass.send(:class_key)
+
+          ii_query = "SELECT #{@initial_key.name} FROM \"#{initial_class_key}/#{@initial_key.id}\" " +
             "LIMIT 1"
 
           begin
             initial_id_data =
-              Zermelo.influxdb.query(ii_query)["#{@initial_set.klass}/#{@initial_set.id}"]
+              Zermelo.influxdb.query(ii_query)["#{initial_class_key}/#{@initial_key.id}"]
           rescue InfluxDB::Error => ide
             raise unless
-              /^Field #{@initial_set.name} doesn't exist in series #{@initial_set.klass}\/#{@initial_set.id}$/ === ide.message
+              /^Field #{@initial_key.name} doesn't exist in series #{initial_class_key}\/#{@initial_key.id}$/ === ide.message
 
             initial_id_data = nil
           end
 
           return [] if initial_id_data.nil?
 
-          inital_ids = initial_id_data.first[@initial_set.name]
+          initial_ids = initial_id_data.first[@initial_key.name]
 
-          if inital_ids.nil? || inital_ids.empty?
+          if initial_ids.nil? || initial_ids.empty?
             # make it impossible for the query to return anything
             query += '(1 = 0)'
           else
-            query += '((' + inital_ids.collect {|id|
+            query += '((' + initial_ids.collect {|id|
               "id = #{escaped_id(id)}"
             }.join(') OR (') + '))'
           end
         end
 
         unless @steps.empty?
-          query += (@initial_set.id.nil? ? ' WHERE ' : ' AND ') +
+          query += (@initial_key.id.nil? ? ' WHERE ' : ' AND ') +
                    ('(' * @steps.size)
 
-          @steps.each_with_index do |step, idx|
-            if idx > 0
-              case step
-              when Zermelo::Filters::Steps::IntersectStep,
-                   Zermelo::Filters::Steps::DiffStep
-                query += ' AND '
-              when Zermelo::Filters::Steps::UnionStep
-                query += ' OR '
-              else
-                raise "Unhandled filter operation '#{step.class.name}'"
-              end
-            end
-
-            query += resolve_step(step)
-
-            query += ")"
-          end
+          first_step = steps.first
+
+          query += @steps.collect {|step|
+            step.resolve(backend, @associated_class, :first => (step == first_step))
+          }.join("")
         end
 
         query += " LIMIT 1"
@@ -145,11 +97,11 @@ module Zermelo
           result = {}
         end
 
-        data_keys = result.keys.select {|k| k =~ /^#{@associated_class.send(:class_key)}\// }
+        data_keys = result.keys.select {|k| k =~ /^#{class_key}\// }
 
         case result_type
         when :ids
-          data_keys.empty? ? [] : data_keys.collect {|k| k =~ /^#{@associated_class.send(:class_key)}\/(.+)$/; $1 }
+          data_keys.empty? ? [] : data_keys.collect {|k| k =~ /^#{class_key}\/(.+)$/; $1 }
         when :count
           data_keys.empty? ?  0 : data_keys.inject(0) do |memo, k|
             memo += result[k].first['count']