influxdb-arel 0.0.1 → 0.1.0

data/lib/influxdb/arel.rb

@@ -1,38 +1,47 @@
 require "influxdb/arel/version"
-
-require 'influxdb/arel/expressions'
-require 'influxdb/arel/predications'
-require 'influxdb/arel/math'
-require 'influxdb/arel/alias_predication'
-require 'influxdb/arel/table'
-require 'influxdb/arel/attributes'
+require 'influxdb/arel/core_extensions'
+require 'influxdb/arel/extensions'
+require 'influxdb/arel/clauses'
+require 'influxdb/arel/builder'
 
 require 'influxdb/arel/visitor'
+require 'influxdb/arel/visitor/where_statement'
+require 'influxdb/arel/visitor/select_statement'
+require 'influxdb/arel/visitor/delete_statement'
 
 require 'influxdb/arel/tree_manager'
 require 'influxdb/arel/select_manager'
-# require 'influxdb/arel/delete_manager'
+require 'influxdb/arel/delete_manager'
 require 'influxdb/arel/nodes'
+require 'influxdb/arel/quoter'
 
 module Influxdb
   module Arel
     extend self
 
+    STRING_OR_SYMBOL_CLASS = [Symbol, String]
+
     def sql(raw_sql)
-      Nodes::SqlLiteral.new(raw_sql)
+      Nodes::SqlLiteral.new(raw_sql.to_s)
     end
 
     def star
       sql('*')
     end
 
-    def now
-      Influxdb::Arel::Nodes::Now.new
-    end
-
-    def time(duration)
-      duration = sql(duration) if String === duration
-      Influxdb::Arel::Nodes::Time.new(duration)
+    def arelize(expr, &block)
+      block ||= ->(e){ Arel.sql(e.to_s) }
+
+      case expr
+      when Array
+        expr.map{|value| arelize(value, &block) }.compact
+      when Hash
+        # TODO: Needs to convert Hash into sql node
+      when *STRING_OR_SYMBOL_CLASS
+        block.call(expr)
+      else
+        expr
+      end
     end
   end
 end

data/lib/influxdb/arel/builder.rb

@@ -0,0 +1,209 @@
+module Influxdb
+  module Arel
+    class Builder
+      attr_accessor :default_table
+
+      def initialize(default_table = nil)
+        @default_table = default_table
+      end
+
+      # Specify tables for query
+      #
+      #   builder = Influxdb::Arel::Builder.new
+      #   builder.from(:table1).to_sql
+      #   => SELECT * FROM table1
+      #
+      #   builder = Influxdb::Arel::Builder.new
+      #   builder.from{ table1.as(:alias1).join(table2.as(:alias2)) }.to_sql
+      #   => SELECT * FROM table1 AS alias1 INNER JOIN table2 AS alias2
+      #
+      #   builder = Influxdb::Arel::Builder.new
+      #   builder.from(/.*/).to_sql
+      #   => SELECT * FROM /.*/
+      #
+      # See: <tt>Influxdb::Arel::SelectManager#from</tt>
+      #
+      def from(*tables, &block)
+        SelectManager.new(*tables, &block)
+      end
+
+      # Merging of two tables into one.
+      #
+      # Tt will merge default table from builder with given table if <tt>tables</tt> contains one table.
+      #
+      #   builder = Influxdb::Arel::Builder.new(:table1)
+      #   builder.merge(:table2).to_sql
+      #   => SELECT * FROM table1 MERGE table2
+      #
+      # It will merge tables if <tt>tables</tt> contains two tables.
+      #
+      #   builder = Influxdb::Arel::Builder.new
+      #   builder.merge(:table1, :table2).to_sql
+      #   => SELECT * FROM table1 MERGE table2
+      #
+      # It will raise exception if <tt>table</tt> is nil and tables list contains only one table.
+      #
+      #   builder.merge.to_sql
+      #   => IllegalSQLConstruct: Ambiguous merging clause
+      #
+      # See: <tt>Influxdb::Arel::SelectManager#merge</tt>
+      #
+      def merge(*tables)
+        from(default_table).merge(*tables)
+      end
+
+      # Joining of two tables into one.
+      #
+      # It will join default table from builder with given table if <tt>tables</tt> contains one table.
+      #
+      #   builder = Influxdb::Arel::Builder.new(:table1)
+      #   builder.join(:table2).to_sql
+      #   => SELECT * FROM table1 INNER JOIN table2
+      #
+      # It will join tables if <tt>tables</tt> contains two tables.
+      #
+      #   builder = Influxdb::Arel::Builder.new
+      #   builder.join(:table1, :table2).to_sql
+      #   => SELECT * FROM table1 INNER JOIN table2
+      #
+      # It will raise exception if <tt>table</tt> is nil and tables list contains only one table.
+      #
+      #   builder.join.to_sql
+      #   => IllegalSQLConstruct: Ambiguous merging clause
+      #
+      # See: <tt>Influxdb::Arel::SelectManager#join</tt>
+      #
+      def join(*tables)
+        from(default_table).join(*tables)
+      end
+
+      # Grouping results by specified attributes or expressions, such as <tt>time(10m)</tt>
+      #
+      #   builder = Influxdb::Arel::Builder.new(:table)
+      #   builder.group{ time(10.s), 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 grouping:
+      #
+      #   builder.group{ time(10.s), host }.fill(0).to_sql
+      #   => SELECT * FROM table GROUP BY time(10m), host fill(0)
+      #
+      # See: <tt>Influxdb::Arel::SelectManager#group</tt>
+      #
+      def group(*attributes, &block)
+        from(default_table).group(*attributes, &block)
+      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:
+      #
+      #   builder = Influxdb::Arel::Builder.new(:table)
+      #   builder.order(:desc).to_sql
+      #   builder.order('desc').to_sql
+      #   => SELECT * FROM table ORDER DESC
+      #
+      #   builder.order(:asc).to_sql
+      #   builder.order('asc').to_sql
+      #   => SELECT * FROM table ORDER ASC
+      #
+      # See: <tt>Influxdb::Arel::SelectManager#order</tt>
+      #
+      def order(expr)
+        from(default_table).order(expr)
+      end
+
+      # Results will be sorted by ascending order.
+      #
+      #   builder = Influxdb::Arel::Builder.new(:table)
+      #   builder.asc.to_sql
+      #   => SELECT * FROM table ORDER ASC
+      #
+      def asc
+        from(default_table).asc
+      end
+
+      # Results will be sorted by descending order.
+      #
+      #   builder = Influxdb::Arel::Builder.new(:table)
+      #   builder.desc.to_sql
+      #   => SELECT * FROM table ORDER DESC
+      #
+      def desc
+        from(default_table).desc
+      end
+
+      # Specify conditions for selection or deletion query
+      # Example:
+      #
+      #   builder = Influxdb::Arel::Builder.new(:table)
+      #   builder.where(name: 'Undr').to_sql
+      #   => SELECT * FROM table WHERE name = 'Undr'
+      #
+      #   builder.where(name: 'Undr'){ time.lt(10.h.ago) }.to_sql
+      #   => SELECT * FROM table WHERE name = 'Undr' AND time < (now() - 10h)
+      #
+      #   builder.where{ name.eq('Undr').or(name.eq('Andrei')) }.to_sql
+      #   => SELECT * FROM table WHERE name = 'Undr' OR name = 'Andrei'
+      #
+      # See: <tt>Influxdb::Arel::SelectManager#where</tt>
+      #
+      def where(conditions = nil, &block)
+        from(default_table).where(conditions, &block)
+      end
+
+      # Specify attributes or expressions for select.
+      # Example:
+      #
+      #   builder = Influxdb::Arel::Builder.new(:cpu_load)
+      #   builder.to_sql
+      #   => SELECT * FROM cpu_load
+      #
+      #   builder.select(:idle){ (system + user).as(:sum) }.to_sql
+      #   => SELECT idle, (system + user) AS sum FROM cpu_load
+      #
+      #   builder.select{ [mean(idle).as(:idle_mean), mean(user).as(:user_mean)] }.to_sql
+      #   => SELECT MEAN(idle) AS idle_mean, MEAN(user) AS user_mean FROM cpu_load
+      #
+      # See: <tt>Influxdb::Arel::SelectManager#select</tt>
+      #
+      def select(*attributes, &block)
+        from(default_table).select(*attributes, &block)
+      end
+
+      # Set limit for result's points
+      # Example:
+      #
+      #   builder = Influxdb::Arel::Builder.new(:table)
+      #   builder.limit(100).to_sql
+      #   => SELECT * FROM table LIMIT 100
+      #
+      def limit(amount)
+        from(default_table).limit(amount)
+      end
+
+      # Create <tt>Influxdb::Arel::SelectManager</tt>
+      #
+      def select_manager
+        SelectManager.new(default_table)
+      end
+
+      def hash
+        @default_table.hash
+      end
+
+      def eql?(other)
+        self.class == other.class && self.name == other.name
+      end
+
+      alias :== :eql?
+    end
+  end
+end

data/lib/influxdb/arel/clauses.rb

@@ -0,0 +1,6 @@
+require 'influxdb/arel/clauses/base'
+require 'influxdb/arel/clauses/expressions'
+require 'influxdb/arel/clauses/select_clause'
+require 'influxdb/arel/clauses/from_clause'
+require 'influxdb/arel/clauses/where_clause'
+require 'influxdb/arel/clauses/group_clause'

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

@@ -0,0 +1,34 @@
+module Influxdb
+  module Arel
+    module Clauses
+      class Base
+        def initialize(&block)
+          @block = block
+          @outer = eval('self', block.binding) if block
+        end
+
+        def o(&block)
+          @outer.instance_exec(&block)
+        end
+
+        def to_arel
+          result = nil
+          result = instance_eval(&@block) if @block
+          result = yield result if block_given?
+          arelize(result)
+        end
+
+        protected
+
+        def arelize_default_block
+          ->(expr){ Arel.sql(expr) }
+        end
+
+        def arelize(expr, &block)
+          block ||= arelize_default_block
+          Arel.arelize(expr, &block)
+        end
+      end
+    end
+  end
+end

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

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

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

@@ -0,0 +1,45 @@
+module Influxdb
+  module Arel
+    module Clauses
+      class FromClause < Base
+        def initialize(*tables, &block)
+          @tables = tables
+          super(&block)
+        end
+
+        def t(name)
+          Nodes::Table.new(name)
+        end
+
+        def join(*tables)
+          tables_union(Nodes::Join, tables, :merging)
+        end
+
+        def merge(*tables)
+          tables_union(Nodes::Merge, tables, :merging)
+        end
+
+        def method_missing(method, *args, &block)
+          t(method)
+        end
+
+        def to_arel
+          super{|result| result ? (@tables | Array(result)) : @tables }.uniq
+        end
+
+        protected
+
+        def tables_union(klass, tables, type)
+          _tables = @tables + tables
+          raise "IllegalSQLConstruct: The #{type} without first table" if _tables.size != 2
+          first, last = arelize(_tables)
+          klass.new(first, last)
+        end
+
+        def arelize_default_block
+          ->(expr){ t(expr) }
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,34 @@
+module Influxdb
+  module Arel
+    module Clauses
+      class GroupClause < Base
+        def initialize(*attributes, &block)
+          @attributes = attributes
+          super(&block)
+        end
+
+        def a(name)
+          Nodes::Attribute.new(name)
+        end
+
+        def time(duration)
+          Nodes::Time.new(Arel.arelize(duration))
+        end
+
+        def method_missing(method, *args, &block)
+          a(method)
+        end
+
+        def to_arel
+          super{|result| result ? (@attributes | Array(result)) : @attributes }
+        end
+
+        protected
+
+        def arelize_default_block
+          ->(expr){ a(expr) }
+        end
+      end
+    end
+  end
+end