influxdb-arel 0.0.1 → 0.1.0

data/lib/influxdb/arel/math.rb

@@ -1,21 +0,0 @@
-module Influxdb
-  module Arel
-    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

data/lib/influxdb/arel/predications.rb

@@ -1,137 +0,0 @@
-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/table.rb

@@ -1,219 +0,0 @@
-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/spec/lib/influxdb/arel/table_spec.rb

@@ -1,193 +0,0 @@
-require 'spec_helper'
-
-describe Influxdb::Arel::Table do
-  describe '#sql' do
-    specify{ expect(table('events').sql('time(1s)')).to eq(sql('time(1s)')) }
-  end
-
-  describe '#star' do
-    specify{ expect(table('events').star).to eq(sql('*')) }
-  end
-
-  describe '#alias' do
-    subject{ table('events').alias('events1') }
-    specify{ expect(subject).to eq(node(:TableAlias, table('events'), 'events1')) }
-    specify{ expect(subject.to_sql).to eq('events AS events1') }
-  end
-
-  describe '#from' do
-    subject{ table('events').from('table') }
-    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-    specify{ expect(subject.ast.series).to eq([sql('table')]) }
-    specify{ expect(subject.to_sql).to eq('SELECT * FROM table') }
-  end
-
-  describe '#merge' do
-    subject{ table('events').merge('errors') }
-    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-    specify{ expect(subject.ast.merge).to eq(node(:Merge, table('events'), sql('errors'))) }
-    specify{ expect(subject.to_sql).to eq('SELECT * FROM events MERGE errors') }
-
-    context 'when table as argument' do
-      subject{ table('events').merge(table('errors')) }
-
-      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ast.merge).to eq(node(:Merge, table('events'), table('errors'))) }
-      specify{ expect(subject.to_sql).to eq('SELECT * FROM events MERGE errors') }
-    end
-
-    context 'when alias as argument' do
-      let(:table_alias){ table('errors').as('fatal_errors') }
-
-      subject{ table('events').merge(table_alias) }
-
-      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ast.merge).to eq(node(:Merge, table('events'), table('errors'))) }
-      specify{ expect(subject.to_sql).to eq('SELECT * FROM events MERGE errors') }
-    end
-
-    context 'without argument' do
-      subject{ table('events').merge }
-      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ast.merge).to be_nil }
-      specify{ expect(subject.to_sql).to eq('SELECT * FROM events') }
-    end
-
-    context 'without argument with many series' do
-      subject{ table('events').from('user_events', 'errors').merge }
-      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ast.merge).to eq(node(:Merge, sql('user_events'), sql('errors'))) }
-      specify{ expect(subject.to_sql).to eq('SELECT * FROM user_events MERGE errors') }
-    end
-  end
-
-  describe '#join' do
-    subject{ table('events').join('errors') }
-    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-    specify{ expect(subject.ast.join).to eq(node(:Join, table('events'), sql('errors'))) }
-    specify{ expect(subject.to_sql).to eq('SELECT * FROM events INNER JOIN errors') }
-
-    context 'when table as argument' do
-      subject{ table('events').join(table('errors')) }
-
-      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ast.join).to eq(node(:Join, table('events'), table('errors'))) }
-      specify{ expect(subject.to_sql).to eq('SELECT * FROM events INNER JOIN errors') }
-    end
-
-    context 'when alias as argument' do
-      let(:table_alias){ table('errors').as('fatal_errors') }
-
-      subject{ table('events').join(table_alias) }
-
-      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ast.join).to eq(node(:Join, table('events'), table_alias)) }
-      specify{ expect(subject.to_sql).to eq('SELECT * FROM events INNER JOIN errors AS fatal_errors') }
-    end
-
-    context 'without argument' do
-      subject{ table('events').join }
-      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ast.join).to be_nil }
-      specify{ expect(subject.to_sql).to eq('SELECT * FROM events') }
-    end
-
-    context 'without argument with many series' do
-      subject{ table('events').from('user_events', 'errors').join }
-      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ast.join).to eq(node(:Join, sql('user_events'), sql('errors'))) }
-      specify{ expect(subject.to_sql).to eq('SELECT * FROM user_events INNER JOIN errors') }
-    end
-  end
-
-  describe '#order' do
-    context 'when sort by ascending order' do
-      subject{ table('events').order(:asc) }
-      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ordering).to eq(node(:Ordering, 'asc')) }
-      specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER ASC') }
-    end
-
-    context 'when sort by ascending order' do
-      subject{ table('events').order('asc') }
-      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ordering).to eq(node(:Ordering, 'asc')) }
-      specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER ASC') }
-    end
-
-    context 'when sort by descending order' do
-      subject{ table('events').order(:desc) }
-      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ordering).to eq(node(:Ordering, 'desc')) }
-      specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER DESC') }
-    end
-
-    context 'when sort by descending order' do
-      subject{ table('events').order('desc') }
-      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ordering).to eq(node(:Ordering, 'desc')) }
-      specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER DESC') }
-    end
-  end
-
-  describe '#take' do
-    subject{ table('events').take(100) }
-    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-    specify{ expect(subject.taken).to eq(node(:Limit, 100)) }
-    specify{ expect(subject.to_sql).to eq('SELECT * FROM events LIMIT 100') }
-  end
-
-  describe '#group' do
-    subject{ table('events').group('time(1s)', 'name', :type) }
-    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-    specify{ expect(subject.ast.groups).to eq([
-      node(:Group, sql('time(1s)')), node(:Group, sql('name')), node(:Group, sql('type'))
-    ]) }
-    specify{ expect(subject.to_sql).to eq('SELECT * FROM events GROUP BY time(1s), name, type') }
-
-    context 'chaining' do
-      subject{ table('events').group('time(1s)').group('name', :type) }
-      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ast.groups).to eq([
-        node(:Group, sql('time(1s)')), node(:Group, sql('name')), node(:Group, sql('type'))
-      ]) }
-      specify{ expect(subject.to_sql).to eq('SELECT * FROM events GROUP BY time(1s), name, type') }
-    end
-  end
-
-  describe '#where' do
-    subject{ table('events').where(sql("name = 'Undr'")) }
-    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-    specify{ expect(subject.wheres).to eq([sql("name = 'Undr'")]) }
-    specify{ expect(subject.to_sql).to eq("SELECT * FROM events WHERE name = 'Undr'") }
-
-    context 'chaining' do
-      subject{ table('events').where(sql("name = 'Undr'")).where(sql("email = 'undr@gmail.com'")) }
-      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.wheres).to eq([sql("name = 'Undr'"), sql("email = 'undr@gmail.com'")]) }
-      specify{ expect(subject.to_sql).to eq("SELECT * FROM events WHERE name = 'Undr' AND email = 'undr@gmail.com'") }
-    end
-  end
-
-  describe '#column' do
-    subject{ table('events').column(table('events')[:time], 'name', :type) }
-    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-    specify{ expect(subject.ast.columns).to eq([table('events')[:time], sql('name'), sql('type')]) }
-    specify{ expect(subject.to_sql).to eq('SELECT time, name, type FROM events') }
-
-    context 'chaining' do
-      subject{ table('events').column(table('events')[:time]).column('name', :type) }
-      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ast.columns).to eq([table('events')[:time], sql('name'), sql('type')]) }
-      specify{ expect(subject.to_sql).to eq('SELECT time, name, type FROM events') }
-    end
-  end
-
-  describe '#table_alias' do
-    specify{ expect(table('events').table_alias).to be_nil }
-  end
-
-  describe '#unalias' do
-    specify{ expect(table('events').unalias).to eq(table('events')) }
-  end
-end