influxdb-arel 0.0.1 → 0.1.0

data/lib/influxdb/arel/clauses/select_clause.rb

@@ -0,0 +1,37 @@
+module Influxdb
+  module Arel
+    module Clauses
+      class SelectClause < Base
+        include Expressions
+
+        def initialize(*attributes, &block)
+          @attributes = attributes
+          super(&block)
+        end
+
+        def a(name)
+          Nodes::Attribute.new(name)
+        end
+
+        def method_missing(method, *args, &block)
+          a(method)
+        end
+
+        def to_arel
+          super{|result| result ? (@attributes | Array(result)) : @attributes }
+        end
+
+        protected
+
+        def function_node(name, *args)
+          args[0] = arelize(args[0])
+          Nodes.const_get(name).new(args)
+        end
+
+        def arelize_default_block
+          ->(expr){ a(expr) }
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/arel/clauses/where_clause.rb

@@ -0,0 +1,102 @@
+module Influxdb
+  module Arel
+    module Clauses
+      class WhereClause < Base
+        include Expressions
+
+        def initialize(conditions, &block)
+          @conditions = build_where_expression(conditions)
+          super(&block)
+        end
+
+        def a(name)
+          Nodes::Attribute.new(name) #.extend(:math, :predications)
+        end
+
+        def now
+          Nodes::Now.new
+        end
+
+        def method_missing(method, *args, &block)
+          a(method)
+        end
+
+        def to_arel
+          super{|result| [@conditions, result].flatten.compact.inject(&:and) }
+        end
+
+        protected
+
+        def function_node(name, *args)
+          args[0] = arelize(args[0]){|expr| a(expr) }
+          Nodes.const_get(name).new(args)
+        end
+
+        def build_where_expression(conditions)
+          case conditions
+          when Hash
+            build_from_hash(conditions)
+          when Array
+            conditions.map{|expr| build_where_expression(expr) }.flatten.compact.inject(&:and)
+          when TreeManager
+            conditions.ast.wheres
+          when String
+            Arel.sql(conditions)
+          else
+            conditions
+          end
+        end
+
+        def build_from_hash(conditions)
+          conditions.each_with_object([]) do |(attribute, value), result|
+            check_attribute!(attribute)
+            attribute = a(attribute) unless Nodes::Attribute === attribute
+            result << build_attribute_expression(attribute, value)
+          end
+        end
+
+        def build_attribute_expression(attribute, value)
+          case value
+          when Array
+            build_array_expression(attribute, value)
+          when Regexp
+            attribute.matches(value)
+          when Range
+            attribute.in(value)
+          else
+            attribute.eq(value)
+          end
+        end
+
+        def build_array_expression(attribute, value)
+          ranges, values = value.to_a.partition{|v| v.is_a?(Range) }
+
+          values_predicate = if values.include?(nil)
+            values = values.compact
+
+            case values.length
+            when 0
+              attribute.eq(nil)
+            when 1
+              attribute.eq(values.first).or(attribute.eq(nil))
+            else
+              attribute.in(values).or(attribute.eq(nil))
+            end
+          else
+            attribute.in(values)
+          end
+
+          array_predicates = ranges.map{|range| attribute.in(range) }
+          array_predicates << values_predicate
+          array_predicates.inject{|composite, predicate| composite.or(predicate) }
+        end
+
+        def check_attribute!(attribute)
+          unless [Nodes::Attribute, String, Symbol].include?(attribute.class)
+            raise 'IllegalSQLConstruct: Illegal attribute name'
+          end
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/arel/core_extensions.rb

@@ -24,26 +24,10 @@ class Integer
   end
 end
 
-class String
-  def to_influxdb_arel
-    Influxdb::Arel::Nodes::SqlLiteral.new(self)
-  end
-
-  alias :to_arel :to_influxdb_arel unless method_defined?(:to_arel)
-
-  def as(other)
-    Influxdb::Arel::Nodes::As.new(to_influxdb_arel, other.to_influxdb_arel)
-  end
-end
-
-class Symbol
-  def to_influxdb_arel
-    Influxdb::Arel::Table.new(self.to_s)
-  end
-
-  alias :to_arel :to_influxdb_arel unless method_defined?(:to_arel)
-
-  def as(other)
-    to_influxdb_arel.as(other)
+class Object
+  def safe_clone
+    self.clone
+  rescue SecurityError, TypeError => e
+    self
   end
 end

data/lib/influxdb/arel/delete_manager.rb

@@ -0,0 +1,50 @@
+module Influxdb
+  module Arel
+    class DeleteManager < TreeManager
+      def initialize
+        @ast = Nodes::DeleteStatement.new
+      end
+
+      def from(*new_tables, &block)
+        expr = Clauses::FromClause.new(*new_tables, &block).to_arel
+
+        case expr
+        when Array
+          regexps, others = separate_tables(expr.to_a)
+          ast.regexp = regexps.first if regexps
+          ast.tables = others
+        when Regexp
+          ast.regexp = expr
+        else
+          ast.tables = Array(expr)
+        end
+
+        self
+      end
+
+      def tables=(value)
+        ast.tables = value
+      end
+
+      def regexp=(value)
+        ast.regexp = value
+      end
+
+      private
+
+      def separate_tables(expr)
+        grouped_tables = expr.group_by do |value|
+          case value
+          when Nodes::Join, Nodes::Merge
+            :filtered
+          when Regexp
+            :regexp
+          else
+            :others
+          end
+        end
+        grouped_tables.values_at(:regexp, :others)
+      end
+    end
+  end
+end

data/lib/influxdb/arel/extensions.rb

@@ -0,0 +1,6 @@
+require 'influxdb/arel/extensions/expressions'
+require 'influxdb/arel/extensions/boolean_predications'
+require 'influxdb/arel/extensions/alias_predication'
+require 'influxdb/arel/extensions/joining_merging'
+require 'influxdb/arel/extensions/predications'
+require 'influxdb/arel/extensions/math'

data/lib/influxdb/arel/extensions/alias_predication.rb

@@ -0,0 +1,11 @@
+module Influxdb
+  module Arel
+    module Extensions
+      module AliasPredication
+        def as(other)
+          Nodes::As.new(self, Arel.sql(other.to_s))
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/arel/extensions/boolean_predications.rb

@@ -0,0 +1,15 @@
+module Influxdb
+  module Arel
+    module Extensions
+      module BooleanPredications
+        def or(right)
+          Nodes::Grouping.new(Nodes::Or.new(self, right))
+        end
+
+        def and(right)
+          Nodes::And.new([self, right])
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/arel/extensions/expressions.rb

@@ -0,0 +1,75 @@
+module Influxdb
+  module Arel
+    module Extensions
+      module Expressions
+        def count
+          Nodes::Count.new([self])
+        end
+
+        def sum
+          Nodes::Sum.new([self])
+        end
+
+        def max
+          Nodes::Max.new([self])
+        end
+
+        def min
+          Nodes::Min.new([self])
+        end
+
+        def mean
+          Nodes::Mean.new([self])
+        end
+
+        def mode
+          Nodes::Mode.new([self])
+        end
+
+        def median
+          Nodes::Median.new([self])
+        end
+
+        def distinct
+          Nodes::Distinct.new([self])
+        end
+
+        def percentile(nth)
+          Nodes::Percentile.new([self, nth])
+        end
+
+        def histogram(bucket_size = nil)
+          Nodes::Histogram.new([self, bucket_size || 1.0])
+        end
+
+        def derivative
+          Nodes::Derivative.new([self])
+        end
+
+        def stddev
+          Nodes::Stddev.new([self])
+        end
+
+        def first
+          Nodes::First.new([self])
+        end
+
+        def last
+          Nodes::Last.new([self])
+        end
+
+        def difference
+          Nodes::Difference.new([self])
+        end
+
+        def top(size)
+          Nodes::Top.new([self, size])
+        end
+
+        def bottom(size)
+          Nodes::Bottom.new([self, size])
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/arel/extensions/joining_merging.rb

@@ -0,0 +1,21 @@
+module Influxdb
+  module Arel
+    module Extensions
+      module JoiningMerging
+        def join(table)
+          Nodes::Join.new(self, table_arelize(table))
+        end
+
+        def merge(table)
+          Nodes::Merge.new(self, table_arelize(table))
+        end
+
+        private
+
+        def table_arelize(table)
+          Arel.arelize(table){|expr| Nodes::Table.new(expr) }
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/arel/extensions/math.rb

@@ -0,0 +1,23 @@
+module Influxdb
+  module Arel
+    module Extensions
+      module Math
+        def *(other)
+          Nodes::Multiplication.new(self, other)
+        end
+
+        def +(other)
+          Nodes::Grouping.new(Nodes::Addition.new(self, other))
+        end
+
+        def -(other)
+          Nodes::Grouping.new(Nodes::Subtraction.new(self, other))
+        end
+
+        def /(other)
+          Nodes::Division.new(self, other)
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/arel/extensions/predications.rb

@@ -0,0 +1,144 @@
+module Influxdb
+  module Arel
+    module Extensions
+      module Predications
+        def not_eq(other)
+          Nodes::NotEqual.new(self, other)
+        end
+
+        def not_eq_any(others)
+          grouping_any(:not_eq, others)
+        end
+
+        def not_eq_all(others)
+          grouping_all(:not_eq, others)
+        end
+
+        def eq(other)
+          Nodes::Equality.new(self, other)
+        end
+
+        def eq_any(others)
+          grouping_any(:eq, others)
+        end
+
+        def eq_all(others)
+          grouping_all(:eq, others)
+        end
+
+        def in(other)
+          case other
+          when Range
+            in_range(other)
+          else
+            Nodes::In.new(self, other)
+          end
+        end
+
+        def matches(other)
+          Nodes::Matches.new(self, other)
+        end
+
+        def matches_any(others)
+          grouping_any(:matches, others)
+        end
+
+        def matches_all(others)
+          grouping_all(:matches, others)
+        end
+
+        def does_not_match(other)
+          Nodes::DoesNotMatch.new(self, other)
+        end
+
+        def does_not_match_any(others)
+          grouping_any(:does_not_match, others)
+        end
+
+        def does_not_match_all(others)
+          grouping_all(:does_not_match, others)
+        end
+
+        def gteq(right)
+          Nodes::GreaterThanOrEqual.new(self, right)
+        end
+
+        def gteq_any(others)
+          grouping_any(:gteq, others)
+        end
+
+        def gteq_all(others)
+          grouping_all(:gteq, others)
+        end
+
+        def gt(right)
+          Nodes::GreaterThan.new(self, right)
+        end
+
+        def gt_any(others)
+          grouping_any(:gt, others)
+        end
+
+        def gt_all(others)
+          grouping_all(:gt, others)
+        end
+
+        def lt(right)
+          Nodes::LessThan.new(self, right)
+        end
+
+        def lt_any(others)
+          grouping_any(:lt, others)
+        end
+
+        def lt_all(others)
+          grouping_all(:lt, others)
+        end
+
+        def lteq(right)
+          Nodes::LessThanOrEqual.new(self, right)
+        end
+
+        def lteq_any(others)
+          grouping_any(:lteq, others)
+        end
+
+        def lteq_all(others)
+          grouping_all(:lteq, others)
+        end
+
+        private
+
+        def in_range(other)
+          case
+          when other.begin == -Float::INFINITY && other.end == Float::INFINITY
+            Nodes::Equality.new(1, 1)
+          when other.end == Float::INFINITY
+            Nodes::GreaterThanOrEqual.new(self, other.begin)
+          when other.begin == -Float::INFINITY && other.exclude_end?
+            Nodes::LessThan.new(self, other.end)
+          when other.begin == -Float::INFINITY
+            Nodes::LessThanOrEqual.new(self, other.end)
+          else
+            in_regular_range(other)
+          end
+        end
+
+        def in_regular_range(other)
+          left = Nodes::GreaterThanOrEqual.new(self, other.begin)
+          right = (other.exclude_end? ? Nodes::LessThan : Nodes::LessThanOrEqual).new(self, other.end)
+          Nodes::And.new([left, right])
+        end
+
+        def grouping_any(method_id, others)
+          nodes = others.map{|expr| send(method_id, expr) }
+          Nodes::Grouping.new(nodes.inject{|result, node| Nodes::Or.new(result, node) })
+        end
+
+        def grouping_all(method_id, others)
+          Nodes::Grouping.new(Nodes::And.new(others.map{|expr| send(method_id, expr) }))
+        end
+      end
+    end
+  end
+end