influxdb-arel 0.0.1

data/lib/influxdb/arel/table.rb

@@ -0,0 +1,219 @@
+module Influxdb
+  module Arel
+    class Table
+      class << self
+        def comparable_classes
+          [Influxdb::Arel::Table, Influxdb::Arel::Nodes::SqlLiteral]
+        end
+      end
+
+      attr_accessor :name
+
+      alias :table_name :name
+
+      def initialize(name)
+        @name = name.to_s
+      end
+
+      # Specify alias for table
+      # Example:
+      #
+      #   Influxdb::Arel::Table.new('table').as('alias_table').to_sql
+      #   => table AS alias_table
+      #
+      def alias(name)
+        Nodes::TableAlias.new(self, name)
+      end
+
+      alias :as :alias
+
+      def from(*tables)
+        SelectManager.new(*tables)
+      end
+
+      # Merging of two series into one.
+      #
+      # If <tt>table</tt> is nil it will merge two first tables from tables list.
+      #
+      #   table = Influxdb::Arel::Table.new('table')
+      #   table.from('table1', 'table2').merge.to_sql
+      #   => SELECT * FROM table1 MERGE table2
+      #
+      # If <tt>table</tt> is nil and tables list contains only one table it will change nothing.
+      #
+      #   table.merge.to_sql
+      #   => SELECT * FROM table
+      #
+      # If <tt>table</tt> exists it will merge first table from tables list with given table.
+      #
+      #   table.merge('table2').to_sql
+      #   => SELECT * FROM table MERGE table2
+      #
+      #   table.from('table1', 'table2').merge('table3').to_sql
+      #   => SELECT * FROM table1 MERGE table3
+      #
+      def merge(table = nil)
+        from(self).merge(table)
+      end
+
+      # Joining of two series.
+      #
+      # If <tt>table</tt> is nil it will join two first tables from tables list.
+      #
+      #   table = Influxdb::Arel::Table.new('table')
+      #   table.from('table1', 'table2').join.to_sql
+      #   => SELECT * FROM table1 INNER JOIN table2
+      #
+      # If <tt>table</tt> is nil and tables list contains only one table it will change nothing.
+      #
+      #   table.join.to_sql
+      #   => SELECT * FROM table
+      #
+      # If <tt>table</tt> exists it will join first table from tables list with given table.
+      #
+      #   table.join('table2').to_sql
+      #   => SELECT * FROM table INNER JOIN table2
+      #
+      #   table.from('table1', 'table2').join('table3').to_sql
+      #   => SELECT * FROM table1 INNER JOIN table3
+      #
+      # Aliases.
+      # You can define alias for each joined table. It would be usefull for self joining table.
+      #
+      #   table.from(table.as(:table_one)).join(table.as(:table_two)).to_sql
+      #   => SELECT * FROM table AS table_one INNER JOIN table AS table_two
+      #
+      def join(table = nil)
+        from(self).join(table)
+      end
+
+      # Grouping results by specified columns or expressions, such as <tt>time(10m)</tt>
+      #
+      #   table = Influxdb::Arel::Table.new('table')
+      #   table.group(table.time(10.m), table[:host]).to_sql
+      #   => SELECT * FROM table GROUP BY time(10m), host
+      #
+      # If you want to fill intervals with no data you shoult call <tt>fill</tt> method after:
+      #
+      #   table.group(10.m.time, table[:host]).fill(0).to_sql
+      #   => SELECT * FROM table GROUP BY time(10m), host fill(0)
+      #
+      def group(*columns)
+        from(self).group(*columns)
+      end
+
+      # Set the ordering of results
+      # Possible values:
+      #
+      # * <tt>:asc</tt>
+      #   Default value. Results will be sorted by ascending order.
+      #
+      # * <tt>:desc</tt>
+      #   Default value. Results will be sorted by descending order.
+      #
+      # Example:
+      #
+      #   table = Influxdb::Arel::Table.new('table')
+      #   table.order(:desc).to_sql
+      #   table.order('desc').to_sql
+      #   => SELECT * FROM table ORDER DESC
+      #
+      #   table.order(:asc).to_sql
+      #   table.order('asc').to_sql
+      #   => SELECT * FROM table ORDER ASC
+      #
+      def order(expr)
+        from(self).order(expr)
+      end
+
+      # Specify conditions for selection or deletion query
+      # Example:
+      #
+      #   table = Influxdb::Arel::Table.new('table')
+      #   table.where(table[:name].eq('Undr')).to_sql
+      #   => SELECT * FROM table WHERE name = 'Undr'
+      #
+      #   table.where(table[:name].eq('Undr')).where(table[:time].lt(10.h.ago).to_sql
+      #   => SELECT * FROM table WHERE name = 'Undr' AND time < (now() - 10h)
+      #
+      #   table.where(table[:name].eq('Undr').or(table[:name].eq('Andrei'))).to_sql
+      #   => SELECT * FROM table WHERE name = 'Undr' OR name = 'Andrei'
+      #
+      def where(condition)
+        from(self).where(condition)
+      end
+
+      # Specify columns or expressions for select.
+      # Example:
+      #
+      #   table = Influxdb::Arel::Table.new('cpu_load')
+      #   table.to_sql
+      #   => SELECT * FROM cpu_load
+      #
+      #   table.column((table[:system] + table[:user]).as(:sum)).to_sql
+      #   => SELECT (system + user) AS sum FROM cpu_load
+      #
+      #   table.column(table[:idle].mean.as(:idle_mean), table[:user].mean.as(:user_mean)).to_sql
+      #   => SELECT MEAN(idle) AS idle_mean, MEAN(user) AS user_mean FROM cpu_load
+      #
+      def column(*things)
+        from(self).column(*things)
+      end
+
+      # Set limit for result's points
+      # Example:
+      #
+      #   table = Influxdb::Arel::Table.new('cpu_load')
+      #   table.take(100).to_sql
+      #   => SELECT * FROM table LIMIT 100
+      #
+      def take(amount)
+        from(self).take(amount)
+      end
+
+      # Get attribute
+      #
+      def [](name)
+        Attribute.new(self, name)
+      end
+
+      def select_manager
+        SelectManager.new
+      end
+
+      def hash
+        @name.hash
+      end
+
+      def eql?(other)
+        self.class.comparable_classes.include?(self.class) && self.name == other.name
+      end
+
+      alias :== :eql?
+
+      def table_alias
+        nil
+      end
+
+      def unalias
+        self
+      end
+
+      def sql(raw_sql)
+        Arel.sql(raw_sql)
+      end
+
+      def star
+        Arel.star
+      end
+
+      def now
+        Arel.now
+      end
+
+      def time(duration)
+        Arel.time(duration)
+      end
+    end
+  end
+end

data/lib/influxdb/arel/tree_manager.rb

@@ -0,0 +1,30 @@
+module Influxdb
+  module Arel
+    class TreeManager
+      STRING_OR_SYMBOL_CLASS = [Symbol, String]
+
+      attr_reader :ast
+
+      def visitor
+        Visitor.new
+      end
+
+      def to_sql
+        visitor.accept(ast)
+      end
+
+      def initialize_copy(other)
+        super
+        @ast = @ast.clone
+      end
+
+      def where(expr)
+        expr = expr.ast if TreeManager === expr
+        expr = Arel.sql(expr) if String === expr
+
+        ast.wheres << expr
+        self
+      end
+    end
+  end
+end

data/lib/influxdb/arel/version.rb

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

data/lib/influxdb/arel/visitor.rb

@@ -0,0 +1,287 @@
+module Influxdb
+  module Arel
+    class Visitor
+      WHERE = ' WHERE '
+      SPACE = ' '
+      COMMA = ', '
+      GROUP_BY = ' GROUP BY '
+      AND = ' AND '
+      OR = ' OR '
+
+      def accept(object)
+        visit(object)
+      end
+
+      private
+
+      DISPATCH = Hash.new do |method_hash, node_class|
+        method_hash[node_class] = "visit_#{(node_class.name || '').gsub('::', '_')}"
+      end
+
+      def visit(object, attribute = nil)
+        send DISPATCH[object.class], object, attribute
+      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]
+        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
+
+        result.strip!
+        result
+      end
+
+      def visit_Influxdb_Arel_Table(object, attribute)
+        quote_table_name(object.name)
+      end
+
+      def visit_Influxdb_Arel_Nodes_Join(object, attribute)
+        "#{visit(object.left, attribute)} INNER JOIN #{visit(object.right, attribute)}"
+      end
+
+      def visit_Influxdb_Arel_Nodes_Merge(object, attribute)
+        "#{visit(object.left, attribute)} MERGE #{visit(object.right, attribute)}"
+      end
+
+      def visit_Influxdb_Arel_Nodes_Limit(object, attribute)
+        "LIMIT #{visit(object.expr, attribute)}"
+      end
+
+      def visit_Influxdb_Arel_Nodes_Ordering(object, attribute)
+        "ORDER #{object.value.upcase}"
+      end
+
+      def visit_Influxdb_Arel_Nodes_Into(object, attribute)
+        "INTO #{visit(object.expr, attribute)}"
+      end
+
+      def visit_Influxdb_Arel_Nodes_Grouping(object, attribute)
+        "(#{visit(object.expr, attribute)})"
+      end
+
+      def visit_Influxdb_Arel_Nodes_Group(object, attribute)
+        visit(object.expr, attribute)
+      end
+
+      def visit_Influxdb_Arel_Nodes_TableAlias(object, attribute)
+        "#{visit(object.relation, attribute)} AS #{quote_table_name(object.name)}"
+      end
+
+      def function(object, attribute)
+        expressions = object.expressions.map{|exp| visit(exp, attribute) }.join(COMMA)
+        function_clause = object.class.name.split('::').last.upcase
+        "#{function_clause}(#{expressions})"
+      end
+
+      alias :visit_Influxdb_Arel_Nodes_Count :function
+      alias :visit_Influxdb_Arel_Nodes_Sum :function
+      alias :visit_Influxdb_Arel_Nodes_Max :function
+      alias :visit_Influxdb_Arel_Nodes_Min :function
+      alias :visit_Influxdb_Arel_Nodes_Mean :function
+      alias :visit_Influxdb_Arel_Nodes_Mode :function
+      alias :visit_Influxdb_Arel_Nodes_Median :function
+      alias :visit_Influxdb_Arel_Nodes_Distinct :function
+      alias :visit_Influxdb_Arel_Nodes_Percentile :function
+      alias :visit_Influxdb_Arel_Nodes_Histogram :function
+      alias :visit_Influxdb_Arel_Nodes_Derivative :function
+      alias :visit_Influxdb_Arel_Nodes_Stddev :function
+      alias :visit_Influxdb_Arel_Nodes_First :function
+      alias :visit_Influxdb_Arel_Nodes_Last :function
+      alias :visit_Influxdb_Arel_Nodes_Difference :function
+      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)})"
+      end
+
+      def visit_Influxdb_Arel_Nodes_Time(object, attribute)
+        "time(#{visit(object.expr, attribute)})"
+      end
+
+      def visit_Influxdb_Arel_Nodes_Duration(object, attribute)
+        "#{object.value}#{object.suffix}"
+      end
+
+      def visit_Influxdb_Arel_Nodes_Now(object, attribute)
+        "now()"
+      end
+
+      def visit_Influxdb_Arel_Nodes_In(object, attribute)
+        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)})"
+        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)}"
+      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)}"
+      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)}"
+      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)}"
+      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
+      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
+      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}"
+      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)}"
+      end
+
+      def visit_Influxdb_Arel_Nodes_And(object, attribute)
+        object.children.map{|node| visit(node, attribute) }.join(AND)
+      end
+
+      def visit_Influxdb_Arel_Nodes_Or(object, attribute)
+        [visit(object.left, attribute), visit(object.right, attribute)].join(OR)
+      end
+
+      def visit_Influxdb_Arel_Nodes_As(object, attribute)
+        "#{visit(object.left, attribute)} AS #{visit(object.right, attribute)}"
+      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
+      end
+
+      def literal(object, attribute)
+        object
+      end
+
+      alias :visit_Influxdb_Arel_Nodes_SqlLiteral :literal
+      alias :visit_Bignum :literal
+      alias :visit_Fixnum :literal
+
+      def quoted(object, attribute)
+        quote(object)
+      end
+
+      alias :visit_ActiveSupport_Multibyte_Chars :quoted
+      alias :visit_ActiveSupport_StringInquirer :quoted
+      alias :visit_BigDecimal :quoted
+      alias :visit_Class :quoted
+      alias :visit_Date :quoted
+      alias :visit_DateTime :quoted
+      alias :visit_FalseClass :quoted
+      alias :visit_Float :quoted
+      alias :visit_Hash :quoted
+      alias :visit_NilClass :quoted
+      alias :visit_String :quoted
+      alias :visit_Symbol :quoted
+      alias :visit_Time :quoted
+      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)}"
+      end
+
+      alias :visit_Influxdb_Arel_Nodes_Addition :visit_Influxdb_Arel_Nodes_InfixOperation
+      alias :visit_Influxdb_Arel_Nodes_Subtraction :visit_Influxdb_Arel_Nodes_InfixOperation
+      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)
+      end
+
+      def quote(value)
+        return value if Arel::Nodes::SqlLiteral === value
+        attribute_for(value).encode(value)
+      end
+
+      def quote_table_name(name)
+        return name if Arel::Nodes::SqlLiteral === name
+        return name.inspect if Regexp === name
+        /(?!\.)[\W\s]+/.match(name.to_s) ? "\"#{name}\"" : name
+      end
+
+      def quote_column_name(name)
+        name
+      end
+
+      def attribute_for(value)
+        Influxdb::Arel::Attributes.const_get(value.class.name, false)
+      rescue
+        Influxdb::Arel::Attributes::Attribute
+      end
+    end
+  end
+end