influxdb-arel 0.0.1

data/lib/influxdb/arel/nodes/grouping.rb

@@ -0,0 +1,11 @@
+module Influxdb
+  module Arel
+    module Nodes
+      class Grouping < Unary
+        include Predications
+        include AliasPredication
+        include Expressions
+      end
+    end
+  end
+end

data/lib/influxdb/arel/nodes/in.rb

@@ -0,0 +1,8 @@
+module Influxdb
+  module Arel
+    module Nodes
+      class In < Equality
+      end
+    end
+  end
+end

data/lib/influxdb/arel/nodes/infix_operation.rb

@@ -0,0 +1,51 @@
+module Influxdb
+  module Arel
+    module Nodes
+      class InfixOperation < Binary
+        include Expressions
+        include Predications
+        include AliasPredication
+        include Math
+
+        attr_reader :operator
+
+        def initialize(operator, left, right)
+          super(left, right)
+          @operator = operator
+        end
+      end
+
+      class Multiplication < InfixOperation
+        def initialize(left, right)
+          super(:*, left, right)
+        end
+
+        def as(name)
+          Grouping.new(self).as(name)
+        end
+      end
+
+      class Division < InfixOperation
+        def initialize(left, right)
+          super(:/, left, right)
+        end
+
+        def as(name)
+          Grouping.new(self).as(name)
+        end
+      end
+
+      class Addition < InfixOperation
+        def initialize(left, right)
+          super(:+, left, right)
+        end
+      end
+
+      class Subtraction < InfixOperation
+        def initialize(left, right)
+          super(:-, left, right)
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/arel/nodes/node.rb

@@ -0,0 +1,19 @@
+module Influxdb
+  module Arel
+    module Nodes
+      class Node
+        def or(right)
+          Nodes::Grouping.new(Nodes::Or.new(self, right))
+        end
+
+        def and(right)
+          Nodes::And.new([self, right])
+        end
+
+        def to_sql
+          Visitor.new.accept(self)
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/arel/nodes/now.rb

@@ -0,0 +1,15 @@
+module Influxdb
+  module Arel
+    module Nodes
+      class Now < Node
+        include Math
+
+        def eql?(other)
+          self.class == other.class
+        end
+
+        alias :== :eql?
+      end
+    end
+  end
+end

data/lib/influxdb/arel/nodes/select_statement.rb

@@ -0,0 +1,59 @@
+module Influxdb
+  module Arel
+    module Nodes
+      class SelectStatement < Node
+        attr_accessor :limit, :order, :wheres, :groups, :columns, :series, :join, :merge, :fill, :into
+
+        def initialize
+          super
+          self.wheres = []
+          self.groups = []
+          self.columns = []
+          self.series = []
+          self.merge = nil
+          self.join = nil
+          self.order = nil
+          self.limit = nil
+          self.fill = nil
+          self.into = nil
+        end
+
+        def initialize_copy(other)
+          super
+          self.wheres = wheres.map{|where| where.clone }
+          self.groups = groups.map{|group| group.clone }
+          self.columns = columns.map{|column| column.clone }
+          self.series = series.map{|series| series.clone }
+          self.join = join.clone if join
+          self.merge = merge.clone if merge
+          self.order = order.clone if order
+          self.limit = limit.clone if limit
+          self.fill = fill.clone if fill
+          self.into = into.clone if into
+        end
+
+        def table
+          join || merge || series.map(&:unalias).uniq
+        end
+
+        def hash
+          [limit, order, wheres, groups, columns, table, fill, into].hash
+        end
+
+        def eql?(other)
+          self.class == other.class &&
+            columns == other.columns &&
+            wheres == other.wheres &&
+            groups == other.groups &&
+            table == other.table &&
+            order == other.order &&
+            limit == other.limit &&
+            fill == other.fill &&
+            into == other.into
+        end
+
+        alias :== :eql?
+      end
+    end
+  end
+end

data/lib/influxdb/arel/nodes/sql_literal.rb

@@ -0,0 +1,23 @@
+module Influxdb
+  module Arel
+    module Nodes
+      class SqlLiteral < String
+        include Expressions
+        include Predications
+        include AliasPredication
+
+        def name
+          self
+        end
+
+        def unalias
+          self
+        end
+
+        def eql?(other)
+          Table.comparable_classes.include?(other.class) && name == other.name
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/arel/nodes/table_alias.rb

@@ -0,0 +1,23 @@
+module Influxdb
+  module Arel
+    module Nodes
+      class TableAlias < Binary
+        alias :name :right
+        alias :relation :left
+        alias :table_alias :name
+
+        def [](name)
+          Attribute.new(self, name)
+        end
+
+        def table_name
+          relation.respond_to?(:name) ? relation.name : name
+        end
+
+        def unalias
+          relation
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/arel/nodes/time.rb

@@ -0,0 +1,13 @@
+module Influxdb
+  module Arel
+    module Nodes
+      class Time < Unary
+        def initialize(expr)
+          expr = SqlLiteral.new(expr) if String === expr
+          expr = SqlLiteral.new(expr.to_s) if Symbol === expr
+          super(expr)
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/arel/nodes/unary.rb

@@ -0,0 +1,35 @@
+module Influxdb
+  module Arel
+    module Nodes
+      class Unary < Node
+        attr_accessor :expr
+        alias :value :expr
+
+        def initialize(expr)
+          super()
+          self.expr = expr
+        end
+
+        def hash
+          self.expr.hash
+        end
+
+        def eql?(other)
+          self.class == other.class && expr == other.expr
+        end
+
+        alias :== :eql?
+      end
+
+      %w{
+        Group
+        Limit
+        Fill
+        Ordering
+        Into
+      }.each do |name|
+        const_set(name, Class.new(Unary))
+      end
+    end
+  end
+end

data/lib/influxdb/arel/predications.rb

@@ -0,0 +1,137 @@
+module Influxdb
+  module Arel
+    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
+          if other.begin == -Float::INFINITY && other.end == Float::INFINITY
+            Nodes::Equality.new(1, 1)
+          elsif other.end == Float::INFINITY
+            Nodes::GreaterThanOrEqual.new(self, other.begin)
+          elsif other.begin == -Float::INFINITY && other.exclude_end?
+            Nodes::LessThan.new(self, other.end)
+          elsif other.begin == -Float::INFINITY
+            Nodes::LessThanOrEqual.new(self, other.end)
+          elsif other.exclude_end?
+            left = Nodes::GreaterThanOrEqual.new(self, other.begin)
+            right = Nodes::LessThan.new(self, other.end)
+            Nodes::And.new([left, right])
+          else
+            left = Nodes::GreaterThanOrEqual.new(self, other.begin)
+            right = Nodes::LessThanOrEqual.new(self, other.end)
+            Nodes::And.new([left, right])
+          end
+        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 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

data/lib/influxdb/arel/select_manager.rb

@@ -0,0 +1,129 @@
+module Influxdb
+  module Arel
+    class SelectManager < Arel::TreeManager
+      def initialize(*tables)
+        super()
+        @ast = Nodes::SelectStatement.new
+        from(*tables)
+      end
+
+      def initialize_copy(other)
+        super
+      end
+
+      def limit
+        ast.limit
+      end
+
+      alias :taken :limit
+
+      def wheres
+        ast.wheres
+      end
+
+      def group(*columns)
+        columns.each do |column|
+          column = STRING_OR_SYMBOL_CLASS.include?(column.class) ? Arel.sql(column.to_s) : column
+          ast.groups.push(Nodes::Group.new(column))
+        end
+
+        self
+      end
+
+      def fill(value)
+        ast.fill = Nodes::Fill.new(value)
+        self
+      end
+
+      def from(*series)
+        series = series.map do |table|
+          case table
+          when String, Symbol
+            Arel.sql(table.to_s)
+          when Regexp
+            Arel.sql(table.inspect)
+          else
+            table
+          end
+        end.compact
+
+        ast.series = series unless series.empty?
+        self
+      end
+
+      def join(table = nil)
+        if table && !series.empty?
+          table = STRING_OR_SYMBOL_CLASS.include?(table.class) ? Arel.sql(table.to_s) : table
+          ast.join = Nodes::Join.new(series[0], table)
+        elsif series.size > 1
+          ast.join = Nodes::Join.new(series[0], series[1])
+        end
+        self
+      end
+
+      def merge(table = nil)
+        if table && !series.empty?
+          table = STRING_OR_SYMBOL_CLASS.include?(table.class) ? Arel.sql(table.to_s) : table
+          ast.merge = Nodes::Merge.new(series[0].unalias, table.unalias)
+        elsif series.size > 1
+          ast.merge = Nodes::Merge.new(series[0].unalias, series[1].unalias)
+        end
+        self
+      end
+
+      def column(*columns)
+        columns.each do |column|
+          column = STRING_OR_SYMBOL_CLASS.include?(column.class) ? Arel.sql(column.to_s) : column
+          ast.columns.push(column)
+        end
+
+        self
+      end
+
+      def columns
+        ast.columns
+      end
+
+      def columns=(columns)
+        self.column(*columns)
+      end
+
+      def order(expr)
+        expr = STRING_OR_SYMBOL_CLASS.include?(expr.class) ? Nodes::Ordering.new(expr.to_s) : expr
+        ast.order = expr
+        self
+      end
+
+      def desc
+        ast.order = Nodes::Ordering.new('desc')
+        self
+      end
+
+      def asc
+        ast.order = Nodes::Ordering.new('asc')
+        self
+      end
+
+      def ordering
+        ast.order
+      end
+
+      def take(limit)
+        ast.limit = limit ? Nodes::Limit.new(limit) : nil
+        self
+      end
+
+      alias :limit= :take
+
+      def into(table)
+        table = STRING_OR_SYMBOL_CLASS.include?(table.class) ? Arel.sql(table.to_s) : table
+        ast.into = Nodes::Into.new(table)
+        self
+      end
+
+      def series
+        ast.series
+      end
+    end
+  end
+end