influxdb-arel 0.0.1 → 0.1.0

data/lib/influxdb/arel/select_manager.rb

@@ -1,96 +1,98 @@
 module Influxdb
   module Arel
     class SelectManager < Arel::TreeManager
-      def initialize(*tables)
+      DIRECTIONS = [:asc, :desc].freeze
+
+      def initialize(*tables, &block)
         super()
         @ast = Nodes::SelectStatement.new
-        from(*tables)
+        from(*tables, &block)
       end
 
-      def initialize_copy(other)
-        super
+      def group(*attributes, &block)
+        ast.groups |= Clauses::GroupClause.new(*attributes, &block).to_arel
+        self
       end
 
-      def limit
-        ast.limit
+      def group!(*attributes, &block)
+        ast.groups = process_value_with_bang(Clauses::GroupClause, attributes, &block)
+        self
       end
 
-      alias :taken :limit
-
-      def wheres
-        ast.wheres
+      def group_values
+        ast.groups
       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
-
+      def select(*attributes, &block)
+        ast.attributes |= Clauses::SelectClause.new(*attributes, &block).to_arel
         self
       end
 
-      def fill(value)
-        ast.fill = Nodes::Fill.new(value)
+      def select!(*attributes, &block)
+        ast.attributes = process_value_with_bang(Clauses::SelectClause, attributes, &block)
         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
+      def select_values
+        ast.attributes
       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
+      def fill(value)
+        ast.fill = Nodes::Fill.new(value)
         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
+      def fill_value
+        ast.fill
       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)
+      def from(*new_tables, &block)
+        new_tables = new_tables.compact
+        return self if new_tables.empty? && !block_given?
+
+        expr = Clauses::FromClause.new(*new_tables, &block).to_arel
+
+        case expr
+        when Array
+          regexps, merges, joins, others = separate_tables(expr.to_a)
+          ast.regexp = Nodes::Table.new(regexps.first) if regexps
+          ast.join = joins.first if joins
+          ast.merge = merges.first if merges
+          ast.tables = others if others
+        when Nodes::Join
+          ast.join = expr
+        when Nodes::Merge
+          ast.merge = expr
+        when Regexp
+          ast.regexp = expr
+        else
+          ast.tables = Array(expr)
         end
 
         self
       end
 
-      def columns
-        ast.columns
+      def tables
+        [ast.regexp] || ast.tables
       end
 
-      def columns=(columns)
-        self.column(*columns)
+      def join(*joining_tables)
+        ast.join = process_value_for_tables_union(Nodes::Join, joining_tables, :joining)
+        self
+      end
+
+      def merge(*merging_tables)
+        ast.merge = process_value_for_tables_union(Nodes::Merge, merging_tables, :merging)
+        self
       end
 
       def order(expr)
-        expr = STRING_OR_SYMBOL_CLASS.include?(expr.class) ? Nodes::Ordering.new(expr.to_s) : expr
-        ast.order = expr
+        case
+        when Nodes::Ordering === expr
+          ast.order = expr
+        when DIRECTIONS.include?(expr.to_sym)
+          send(expr)
+        end
         self
       end
 
@@ -104,25 +106,70 @@ module Influxdb
         self
       end
 
-      def ordering
+      def invert_order
+        ast.order = (ast.order && ast.order.invert) || Nodes::Ordering.new('asc')
+        self
+      end
+
+      def order_value
         ast.order
       end
 
-      def take(limit)
+      def limit(limit)
         ast.limit = limit ? Nodes::Limit.new(limit) : nil
         self
       end
 
-      alias :limit= :take
+      def limit_value
+        ast.limit
+      end
 
       def into(table)
-        table = STRING_OR_SYMBOL_CLASS.include?(table.class) ? Arel.sql(table.to_s) : table
-        ast.into = Nodes::Into.new(table)
+        ast.into = Nodes::Into.new(Arel.arelize(table))
         self
       end
 
-      def series
-        ast.series
+      def into_value
+        ast.into
+      end
+
+      def delete
+        raise 'IllegalSQLConstruct: Ambiguous deletion operation' if ast.tables.size != 1
+        DeleteManager.new.tap do |manager|
+          manager.tables = ast.tables
+          manager.regexp = ast.regexp
+          manager.where_values = where_values
+        end
+      end
+
+      private
+
+      def process_value_with_bang(klass, attributes, &block)
+        return nil if attributes.empty? && !block_given?
+        klass.new(*attributes, &block).to_arel
+      end
+
+      def process_value_for_tables_union(klass, tables, type)
+        _tables = (ast.tables + tables).compact
+        raise "IllegalSQLConstruct: Ambiguous #{type} clause" if _tables.size != 2
+        _tables = Arel.arelize(_tables){|expr| Nodes::Table.new(expr) }
+        klass.new(*_tables)
+      end
+
+      def separate_tables(expr)
+        grouped_tables = expr.group_by do |value|
+          case value
+          when Nodes::Join
+            :joins
+          when Nodes::Merge
+            :merges
+          when Regexp
+            :regexp
+          else
+            :others
+          end
+        end
+        grouped_tables.values_at(:regexp, :merges, :joins, :others)
       end
     end
   end

data/lib/influxdb/arel/tree_manager.rb

@@ -15,16 +15,26 @@ module Influxdb
 
       def initialize_copy(other)
         super
-        @ast = @ast.clone
+        @ast = ast.clone
       end
 
-      def where(expr)
-        expr = expr.ast if TreeManager === expr
-        expr = Arel.sql(expr) if String === expr
+      def where(expr = nil, &block)
+        ast.wheres << Clauses::WhereClause.new(expr, &block).to_arel
+        self
+      end
 
-        ast.wheres << expr
+      def where!(expr = nil, &block)
+        ast.wheres = [Clauses::WhereClause.new(expr, &block).to_arel].compact
         self
       end
+
+      def where_values
+        ast.wheres
+      end
+
+      def where_values=(value)
+        ast.wheres = value
+      end
     end
   end
 end

data/lib/influxdb/arel/version.rb

@@ -1,5 +1,5 @@
 module Influxdb
   module Arel
-    VERSION = "0.0.1"
+    VERSION = '0.1.0'
   end
 end

data/lib/influxdb/arel/visitor.rb

@@ -18,90 +18,60 @@ module Influxdb
         method_hash[node_class] = "visit_#{(node_class.name || '').gsub('::', '_')}"
       end
 
-      def visit(object, attribute = nil)
-        send DISPATCH[object.class], object, attribute
+      def visit(object)
+        send(DISPATCH[object.class], object)
       rescue NoMethodError => e
         raise e if respond_to?(DISPATCH[object.class], true)
-
-        superklass = object.class.ancestors.find{|klass|
-          respond_to?(DISPATCH[klass], true)
-        }
-        raise(TypeError, "Cannot visit #{object.class}") unless superklass
-
-        DISPATCH[object.class] = DISPATCH[superklass]
+        DISPATCH[object.class] = DISPATCH[find_visitable_superclass(object)]
         retry
       end
 
-      def visit_Influxdb_Arel_Nodes_SelectStatement(object, attribute)
-        result = 'SELECT'
-
-        unless object.columns.empty?
-          result << SPACE
-          result << object.columns.map{|column| visit(column, attribute) }.join(COMMA)
-        else
-          result << SPACE
-          result << Arel.star
-        end
-
-        result << " FROM #{visit(object.table, attribute)}"
-
-        unless object.wheres.empty?
-          result << WHERE
-          result << object.wheres.map{|where| visit(where, attribute) }.join(AND)
-        end
-
-        unless object.groups.empty?
-          result << GROUP_BY
-          result << object.groups.map{|group| visit(group, attribute) }.join(COMMA)
-          result << " #{visit(object.fill, attribute)}" if object.fill
-        end
-
-        result << " #{visit(object.order, attribute)}" if object.order
-        result << " #{visit(object.limit, attribute)}" if object.limit
-        result << " #{visit(object.into, attribute)}" if object.into
+      def visit_Influxdb_Arel_Nodes_SelectStatement(object)
+        SelectStatement.new(self).visit(object)
+      end
 
-        result.strip!
-        result
+      def visit_Influxdb_Arel_Nodes_DeleteStatement(object)
+        DeleteStatement.new(self).visit(object)
       end
 
-      def visit_Influxdb_Arel_Table(object, attribute)
+      def visit_Influxdb_Arel_Nodes_Table(object)
         quote_table_name(object.name)
       end
 
-      def visit_Influxdb_Arel_Nodes_Join(object, attribute)
-        "#{visit(object.left, attribute)} INNER JOIN #{visit(object.right, attribute)}"
+      def visit_Influxdb_Arel_Nodes_Join(object)
+        visit_predication(object, 'INNER JOIN')
       end
 
-      def visit_Influxdb_Arel_Nodes_Merge(object, attribute)
-        "#{visit(object.left, attribute)} MERGE #{visit(object.right, attribute)}"
+      def visit_Influxdb_Arel_Nodes_Merge(object)
+        visit_predication(object, 'MERGE')
       end
 
-      def visit_Influxdb_Arel_Nodes_Limit(object, attribute)
-        "LIMIT #{visit(object.expr, attribute)}"
+      def visit_Influxdb_Arel_Nodes_Limit(object)
+        "LIMIT #{visit(object.expr)}"
       end
 
-      def visit_Influxdb_Arel_Nodes_Ordering(object, attribute)
+      def visit_Influxdb_Arel_Nodes_Ordering(object)
         "ORDER #{object.value.upcase}"
       end
 
-      def visit_Influxdb_Arel_Nodes_Into(object, attribute)
-        "INTO #{visit(object.expr, attribute)}"
+      def visit_Influxdb_Arel_Nodes_Into(object)
+        "INTO #{visit(object.expr)}"
       end
 
-      def visit_Influxdb_Arel_Nodes_Grouping(object, attribute)
-        "(#{visit(object.expr, attribute)})"
+      def visit_Influxdb_Arel_Nodes_Grouping(object)
+        "(#{visit(object.expr)})"
       end
 
-      def visit_Influxdb_Arel_Nodes_Group(object, attribute)
-        visit(object.expr, attribute)
+      def visit_Influxdb_Arel_Nodes_Group(object)
+        visit(object.expr)
       end
 
-      def visit_Influxdb_Arel_Nodes_TableAlias(object, attribute)
-        "#{visit(object.relation, attribute)} AS #{quote_table_name(object.name)}"
+      def visit_Influxdb_Arel_Nodes_TableAlias(object)
+        "#{visit(object.relation)} AS #{quote_table_name(object.name)}"
       end
 
-      def function(object, attribute)
-        expressions = object.expressions.map{|exp| visit(exp, attribute) }.join(COMMA)
+      def function(object)
+        expressions = object.expressions.map{|exp| visit(exp) }.join(COMMA)
         function_clause = object.class.name.split('::').last.upcase
         "#{function_clause}(#{expressions})"
       end
@@ -124,104 +94,99 @@ module Influxdb
       alias :visit_Influxdb_Arel_Nodes_Top :function
       alias :visit_Influxdb_Arel_Nodes_Bottom :function
 
-      def visit_Influxdb_Arel_Nodes_Fill(object, attribute)
-        "fill(#{visit(object.expr, attribute)})"
+      def visit_Influxdb_Arel_Nodes_Fill(object)
+        "fill(#{visit(object.expr)})"
       end
 
-      def visit_Influxdb_Arel_Nodes_Time(object, attribute)
-        "time(#{visit(object.expr, attribute)})"
+      def visit_Influxdb_Arel_Nodes_Time(object)
+        "time(#{visit(object.expr)})"
       end
 
-      def visit_Influxdb_Arel_Nodes_Duration(object, attribute)
+      def visit_Influxdb_Arel_Nodes_Duration(object)
         "#{object.value}#{object.suffix}"
       end
 
-      def visit_Influxdb_Arel_Nodes_Now(object, attribute)
+      def visit_Influxdb_Arel_Nodes_Now(object)
         "now()"
       end
 
-      def visit_Influxdb_Arel_Nodes_In(object, attribute)
+      def visit_Influxdb_Arel_Nodes_In(object)
         if Array === object.right && object.right.empty?
           '1 = 0'
         else
-          attribute = object.left if Arel::Attributes::Attribute === object.left
-          "#{visit(object.left, attribute)} IN (#{visit(object.right, attribute)})"
+          "#{visit(object.left)} IN (#{visit(object.right)})"
         end
       end
 
-      def visit_Influxdb_Arel_Nodes_GreaterThanOrEqual(object, attribute)
-        attribute = object.left if Attributes::Attribute === object.left
-        "#{visit(object.left, attribute)} >= #{visit(object.right, attribute)}"
+      def visit_Influxdb_Arel_Nodes_GreaterThanOrEqual(object)
+        if object.left.is_a?(Nodes::Attribute) && object.left.time?
+          right = object.right - 1
+          operator = '>'
+        else
+          right = object.right
+          operator = '>='
+        end
+        visit_predication(object, operator, right)
       end
 
-      def visit_Influxdb_Arel_Nodes_GreaterThan(object, attribute)
-        attribute = object.left if Attributes::Attribute === object.left
-        "#{visit(object.left, attribute)} > #{visit(object.right, attribute)}"
+      def visit_Influxdb_Arel_Nodes_GreaterThan(object)
+        visit_predication(object, '>')
       end
 
-      def visit_Influxdb_Arel_Nodes_LessThanOrEqual(object, attribute)
-        attribute = object.left if Attributes::Attribute === object.left
-        "#{visit(object.left, attribute)} <= #{visit(object.right, attribute)}"
+      def visit_Influxdb_Arel_Nodes_LessThanOrEqual(object)
+        if object.left.is_a?(Nodes::Attribute) && object.left.time?
+          right = object.right + 1
+          operator = '<'
+        else
+          right = object.right
+          operator = '<='
+        end
+        visit_predication(object, operator, right)
       end
 
-      def visit_Influxdb_Arel_Nodes_LessThan(object, attribute)
-        attribute = object.left if Attributes::Attribute === object.left
-        "#{visit(object.left, attribute)} < #{visit(object.right, attribute)}"
+      def visit_Influxdb_Arel_Nodes_LessThan(object)
+        visit_predication(object, '<')
       end
 
-      def visit_Influxdb_Arel_Nodes_NotEqual(object, attribute)
-        right = object.right
-        attribute = object.left if Attributes::Attribute === object.left
-
-        if right.nil?
-          "#{visit(object.left, attribute)} <> null"
-        else
-          "#{visit(object.left, attribute)} <> #{visit(right, attribute)}"
-        end
+      def visit_Influxdb_Arel_Nodes_NotEqual(object)
+        visit_predication(object, '<>')
       end
 
-      def visit_Influxdb_Arel_Nodes_Equality(object, attribute)
-        right = object.right
-        attribute = object.left if Attributes::Attribute === object.left
-
-        if right.nil?
-          "#{visit(object.left, attribute)} = null"
-        else
-          "#{visit(object.left, attribute)} = #{visit(right, attribute)}"
-        end
+      def visit_Influxdb_Arel_Nodes_Equality(object)
+        visit_predication(object, '=')
       end
 
-      def visit_Influxdb_Arel_Nodes_Matches(object, attribute)
-        attribute = object.left if Attributes::Attribute === object.left
-        "#{visit object.left, attribute} =~ #{visit object.right, attribute}"
+      def visit_Influxdb_Arel_Nodes_Matches(object)
+        visit_predication(object, '=~')
       end
 
-      def visit_Influxdb_Arel_Nodes_DoesNotMatch(object, attribute)
-        attribute = object.left if Attributes::Attribute === object.left
-        "#{visit(object.left, attribute)} !~ #{visit(object.right, attribute)}"
+      def visit_Influxdb_Arel_Nodes_DoesNotMatch(object)
+        visit_predication(object, '!~')
       end
 
-      def visit_Influxdb_Arel_Nodes_And(object, attribute)
-        object.children.map{|node| visit(node, attribute) }.join(AND)
+      def visit_Influxdb_Arel_Nodes_And(object)
+        object.children.map{|node| visit(node) }.join(AND)
       end
 
-      def visit_Influxdb_Arel_Nodes_Or(object, attribute)
-        [visit(object.left, attribute), visit(object.right, attribute)].join(OR)
+      def visit_Influxdb_Arel_Nodes_Or(object)
+        [visit(object.left), visit(object.right)].join(OR)
       end
 
-      def visit_Influxdb_Arel_Nodes_As(object, attribute)
-        "#{visit(object.left, attribute)} AS #{visit(object.right, attribute)}"
+      def visit_Influxdb_Arel_Nodes_As(object)
+        visit_predication(object, 'AS')
       end
 
-      def visit_Influxdb_Arel_Attributes_Attribute(object, attribute)
-        if object.relation.table_alias
-          "#{quote_table_name(object.relation.table_alias)}.#{quote_column_name(object.name)}"
-        else
-          quote_column_name(object.name)
-        end
+      def visit_Influxdb_Arel_Nodes_Attribute(object)
+        # if object.relation.table_alias
+        #   "#{quote_table_name(object.relation.table_alias)}.#{quote_column_name(object.name)}"
+        # else
+        #   quote_column_name(object.name)
+        # end
+
+        quote_column_name(object.value)
       end
 
-      def literal(object, attribute)
+      def literal(object)
         object
       end
 
@@ -229,7 +194,7 @@ module Influxdb
       alias :visit_Bignum :literal
       alias :visit_Fixnum :literal
 
-      def quoted(object, attribute)
+      def quoted(object)
         quote(object)
       end
 
@@ -249,8 +214,8 @@ module Influxdb
       alias :visit_TrueClass :quoted
       alias :visit_Regexp :quoted
 
-      def visit_Influxdb_Arel_Nodes_InfixOperation(object, attribute)
-        "#{visit(object.left, attribute)} #{object.operator} #{visit(object.right, attribute)}"
+      def visit_Influxdb_Arel_Nodes_InfixOperation(object)
+        visit_predication(object, object.operator)
       end
 
       alias :visit_Influxdb_Arel_Nodes_Addition :visit_Influxdb_Arel_Nodes_InfixOperation
@@ -258,17 +223,20 @@ module Influxdb
       alias :visit_Influxdb_Arel_Nodes_Multiplication :visit_Influxdb_Arel_Nodes_InfixOperation
       alias :visit_Influxdb_Arel_Nodes_Division :visit_Influxdb_Arel_Nodes_InfixOperation
 
-      def visit_Array(object, attribute)
-        object.map{|node| visit(node, attribute) }.join(COMMA)
+      def visit_Array(object)
+        object.map{|node| visit(node) }.join(COMMA)
+      end
+
+      def visit_predication(object, expression, right = nil)
+        "#{visit(object.left)} #{expression} #{visit(right || object.right)}"
       end
 
       def quote(value)
-        return value if Arel::Nodes::SqlLiteral === value
-        attribute_for(value).encode(value)
+        Quoter.quote(value)
       end
 
       def quote_table_name(name)
-        return name if Arel::Nodes::SqlLiteral === name
+        return name if Nodes::SqlLiteral === name
         return name.inspect if Regexp === name
         /(?!\.)[\W\s]+/.match(name.to_s) ? "\"#{name}\"" : name
       end
@@ -277,10 +245,12 @@ module Influxdb
         name
       end
 
-      def attribute_for(value)
-        Influxdb::Arel::Attributes.const_get(value.class.name, false)
-      rescue
-        Influxdb::Arel::Attributes::Attribute
+      def find_visitable_superclass(object)
+        object.class.ancestors.find{|klass|
+          respond_to?(DISPATCH[klass], true)
+        }.tap do |superklass|
+          raise(TypeError, "Cannot visit #{object.class}") unless superklass
+        end
       end
     end
   end