influxdb-arel 0.0.1

data/spec/lib/influxdb/arel/table_spec.rb

@@ -0,0 +1,193 @@
+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

data/spec/lib/influxdb/arel_spec.rb

@@ -0,0 +1,11 @@
+require 'spec_helper'
+
+describe Influxdb::Arel do
+  describe '.sql' do
+    specify{ expect(subject.sql('time(1s)')).to eq(sql('time(1s)')) }
+  end
+
+  describe '.star' do
+    specify{ expect(subject.star).to eq(sql('*')) }
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,20 @@
+require 'bundler'
+Bundler.require(:default, :test)
+
+Dir["./spec/support/**/*.rb"].each { |f| require f }
+
+RSpec.configure do |config|
+  config.mock_with :rspec
+
+  config.include Influxdb::Arel::RspecHelper
+
+  config.around :each, time_freeze: ->(v){ v.is_a?(Date) || v.is_a?(Time) || v.is_a?(String) } do |example|
+    datetime = if example.metadata[:time_freeze].is_a?(String)
+      DateTime.parse(example.metadata[:time_freeze])
+    else
+      example.metadata[:time_freeze]
+    end
+
+    Timecop.freeze(datetime){ example.run }
+  end
+end

data/spec/support/examples/binary_node.rb

@@ -0,0 +1,10 @@
+shared_examples_for :binary_node do |klass, node_sql = nil|
+  let(:described_node){ node(klass, sql('left'), sql('right')) }
+
+  it_should_behave_like :node_to_sql, node_sql if node_sql
+
+  describe '#eql?' do
+    specify{ expect(described_node.eql?(node(klass, sql('left'), sql('right')))).to be_truthy }
+    specify{ expect(described_node.eql?(node(klass, sql('right'), sql('left')))).to be_falsy }
+  end
+end

data/spec/support/examples/function_node.rb

@@ -0,0 +1,14 @@
+shared_examples_for :function_node do |klass, node_sql, args = []|
+  let(:expressions){ args.dup.unshift(sql('expression')) }
+  let(:other_expressions){ args.dup.unshift(sql('another_expression')) }
+  let(:described_node){ node(klass, expressions) }
+
+  it_should_behave_like :node_to_sql, node_sql
+  it_should_behave_like :node_as, node_sql
+  it_should_behave_like :node_math, node_sql
+
+  describe '#eql?' do
+    specify{ expect(described_node.eql?(node(klass, expressions))).to be_truthy }
+    specify{ expect(described_node.eql?(node(klass, other_expressions))).to be_falsy }
+  end
+end

data/spec/support/examples/node_as.rb

@@ -0,0 +1,8 @@
+shared_examples_for :node_as do |node_sql|
+  describe '#as' do
+    subject{ described_node.as('alias') }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::As) }
+    specify{ expect(subject.to_sql).to eq("#{node_sql} AS alias") }
+  end
+end

data/spec/support/examples/node_expressions.rb

@@ -0,0 +1,145 @@
+shared_examples_for :node_expressions do |node_sql|
+  describe '#count' do
+    subject{ described_node.count }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Count) }
+    specify{ expect(subject.expressions).to eq([described_node]) }
+    specify{ expect(subject.to_sql).to eq("COUNT(#{node_sql})") }
+  end
+
+  describe '#sun' do
+    subject{ described_node.sum }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Sum) }
+    specify{ expect(subject.expressions).to eq([described_node]) }
+    specify{ expect(subject.to_sql).to eq("SUM(#{node_sql})") }
+  end
+
+  describe '#max' do
+    subject{ described_node.max }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Max) }
+    specify{ expect(subject.expressions).to eq([described_node]) }
+    specify{ expect(subject.to_sql).to eq("MAX(#{node_sql})") }
+  end
+
+  describe '#min' do
+    subject{ described_node.min }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Min) }
+    specify{ expect(subject.expressions).to eq([described_node]) }
+    specify{ expect(subject.to_sql).to eq("MIN(#{node_sql})") }
+  end
+
+  describe '#mean' do
+    subject{ described_node.mean }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Mean) }
+    specify{ expect(subject.expressions).to eq([described_node]) }
+    specify{ expect(subject.to_sql).to eq("MEAN(#{node_sql})") }
+  end
+
+  describe '#mode' do
+    subject{ described_node.mode }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Mode) }
+    specify{ expect(subject.expressions).to eq([described_node]) }
+    specify{ expect(subject.to_sql).to eq("MODE(#{node_sql})") }
+  end
+
+  describe '#median' do
+    subject{ described_node.median }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Median) }
+    specify{ expect(subject.expressions).to eq([described_node]) }
+    specify{ expect(subject.to_sql).to eq("MEDIAN(#{node_sql})") }
+  end
+
+  describe '#mode' do
+    subject{ described_node.mode }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Mode) }
+    specify{ expect(subject.expressions).to eq([described_node]) }
+    specify{ expect(subject.to_sql).to eq("MODE(#{node_sql})") }
+  end
+
+  describe '#distinct' do
+    subject{ described_node.distinct }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Distinct) }
+    specify{ expect(subject.expressions).to eq([described_node]) }
+    specify{ expect(subject.to_sql).to eq("DISTINCT(#{node_sql})") }
+  end
+
+  describe '#percentile' do
+    subject{ described_node.percentile(95) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Percentile) }
+    specify{ expect(subject.expressions).to eq([described_node, 95]) }
+    specify{ expect(subject.to_sql).to eq("PERCENTILE(#{node_sql}, 95)") }
+  end
+
+  describe '#histogram' do
+    subject{ described_node.histogram(2) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Histogram) }
+    specify{ expect(subject.expressions).to eq([described_node, 2]) }
+    specify{ expect(subject.to_sql).to eq("HISTOGRAM(#{node_sql}, 2)") }
+  end
+
+  describe '#derivative' do
+    subject{ described_node.derivative }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Derivative) }
+    specify{ expect(subject.expressions).to eq([described_node]) }
+    specify{ expect(subject.to_sql).to eq("DERIVATIVE(#{node_sql})") }
+  end
+
+  describe '#stddev' do
+    subject{ described_node.stddev }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Stddev) }
+    specify{ expect(subject.expressions).to eq([described_node]) }
+    specify{ expect(subject.to_sql).to eq("STDDEV(#{node_sql})") }
+  end
+
+  describe '#first' do
+    subject{ described_node.first }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::First) }
+    specify{ expect(subject.expressions).to eq([described_node]) }
+    specify{ expect(subject.to_sql).to eq("FIRST(#{node_sql})") }
+  end
+
+  describe '#last' do
+    subject{ described_node.last }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Last) }
+    specify{ expect(subject.expressions).to eq([described_node]) }
+    specify{ expect(subject.to_sql).to eq("LAST(#{node_sql})") }
+  end
+
+  describe '#difference' do
+    subject{ described_node.difference }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Difference) }
+    specify{ expect(subject.expressions).to eq([described_node]) }
+    specify{ expect(subject.to_sql).to eq("DIFFERENCE(#{node_sql})") }
+  end
+
+  describe '#top' do
+    subject{ described_node.top(10) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Top) }
+    specify{ expect(subject.expressions).to eq([described_node, 10]) }
+    specify{ expect(subject.to_sql).to eq("TOP(#{node_sql}, 10)") }
+  end
+
+  describe '#bottom' do
+    subject{ described_node.bottom(10) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Bottom) }
+    specify{ expect(subject.expressions).to eq([described_node, 10]) }
+    specify{ expect(subject.to_sql).to eq("BOTTOM(#{node_sql}, 10)") }
+  end
+end

data/spec/support/examples/node_math.rb

@@ -0,0 +1,29 @@
+shared_examples_for :node_math do |node_sql|
+  describe '#+' do
+    subject{ described_node + 10 }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} + 10)") }
+  end
+
+  describe '#-' do
+    subject{ described_node - 10 }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} - 10)") }
+  end
+
+  describe '#/' do
+    subject{ described_node / 10 }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Division) }
+    specify{ expect(subject.to_sql).to eq("#{node_sql} / 10") }
+  end
+
+  describe '#*' do
+    subject{ described_node * 10 }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Multiplication) }
+    specify{ expect(subject.to_sql).to eq("#{node_sql} * 10") }
+  end
+end

data/spec/support/examples/node_predications.rb

@@ -0,0 +1,248 @@
+shared_examples_for :node_predications do |node_sql|
+  describe '#not_eq' do
+    subject{ described_node.not_eq(1) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::NotEqual) }
+    specify{ expect(subject.left).to eq(described_node) }
+    specify{ expect(subject.right).to eq(1) }
+    specify{ expect(subject.to_sql).to eq("#{node_sql} <> 1") }
+  end
+
+  describe '#not_eq_any' do
+    subject{ described_node.not_eq_any([1, 2]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} <> 1 OR #{node_sql} <> 2)") }
+  end
+
+  describe '#not_eq_all' do
+    subject{ described_node.not_eq_all([1, 2]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} <> 1 AND #{node_sql} <> 2)") }
+  end
+
+  describe '#eq' do
+    subject{ described_node.eq(1) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Equality) }
+    specify{ expect(subject.left).to eq(described_node) }
+    specify{ expect(subject.right).to eq(1) }
+    specify{ expect(subject.to_sql).to eq("#{node_sql} = 1") }
+  end
+
+  describe '#eq_any' do
+    subject{ described_node.eq_any([1, 2]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} = 1 OR #{node_sql} = 2)") }
+  end
+
+  describe '#eq_all' do
+    subject{ described_node.eq_all([1, 2]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} = 1 AND #{node_sql} = 2)") }
+  end
+
+  describe '#matches' do
+    subject{ described_node.matches(/.*/) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Matches) }
+    specify{ expect(subject.left).to eq(described_node) }
+    specify{ expect(subject.right).to eq(/.*/) }
+    specify{ expect(subject.to_sql).to eq("#{node_sql} =~ /.*/") }
+  end
+
+  describe '#matches_any' do
+    subject{ described_node.matches_any([/\w*/, /\d*/]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} =~ /\\w*/ OR #{node_sql} =~ /\\d*/)") }
+  end
+
+  describe '#matches_all' do
+    subject{ described_node.matches_all([/\w*/, /\d*/]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} =~ /\\w*/ AND #{node_sql} =~ /\\d*/)") }
+  end
+
+  describe '#does_not_match' do
+    subject{ described_node.does_not_match(/.*/) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::DoesNotMatch) }
+    specify{ expect(subject.left).to eq(described_node) }
+    specify{ expect(subject.right).to eq(/.*/) }
+    specify{ expect(subject.to_sql).to eq("#{node_sql} !~ /.*/") }
+  end
+
+  describe '#does_not_match_any' do
+    subject{ described_node.does_not_match_any([/\w*/, /\d*/]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} !~ /\\w*/ OR #{node_sql} !~ /\\d*/)") }
+  end
+
+  describe '#does_not_match_all' do
+    subject{ described_node.does_not_match_all([/\w*/, /\d*/]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} !~ /\\w*/ AND #{node_sql} !~ /\\d*/)") }
+  end
+
+  describe '#gteq' do
+    subject{ described_node.gteq(1) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::GreaterThanOrEqual) }
+    specify{ expect(subject.left).to eq(described_node) }
+    specify{ expect(subject.right).to eq(1) }
+    specify{ expect(subject.to_sql).to eq("#{node_sql} >= 1") }
+  end
+
+  describe '#gteq_any' do
+    subject{ described_node.gteq_any([1, 2]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} >= 1 OR #{node_sql} >= 2)") }
+  end
+
+  describe '#gteq_all' do
+    subject{ described_node.gteq_all([1, 2]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} >= 1 AND #{node_sql} >= 2)") }
+  end
+
+  describe '#gt' do
+    subject{ described_node.gt(1) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::GreaterThan) }
+    specify{ expect(subject.left).to eq(described_node) }
+    specify{ expect(subject.right).to eq(1) }
+    specify{ expect(subject.to_sql).to eq("#{node_sql} > 1") }
+  end
+
+  describe '#gt_any' do
+    subject{ described_node.gt_any([1, 2]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} > 1 OR #{node_sql} > 2)") }
+  end
+
+  describe '#gt_all' do
+    subject{ described_node.gt_all([1, 2]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} > 1 AND #{node_sql} > 2)") }
+  end
+
+  describe '#lt' do
+    subject{ described_node.lt(1) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::LessThan) }
+    specify{ expect(subject.left).to eq(described_node) }
+    specify{ expect(subject.right).to eq(1) }
+    specify{ expect(subject.to_sql).to eq("#{node_sql} < 1") }
+  end
+
+  describe '#lt_any' do
+    subject{ described_node.lt_any([1, 2]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} < 1 OR #{node_sql} < 2)") }
+  end
+
+  describe '#lt_all' do
+    subject{ described_node.lt_all([1, 2]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} < 1 AND #{node_sql} < 2)") }
+  end
+
+  describe '#lteq' do
+    subject{ described_node.lteq(1) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::LessThanOrEqual) }
+    specify{ expect(subject.left).to eq(described_node) }
+    specify{ expect(subject.right).to eq(1) }
+    specify{ expect(subject.to_sql).to eq("#{node_sql} <= 1") }
+  end
+
+  describe '#lteq_any' do
+    subject{ described_node.lteq_any([1, 2]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} <= 1 OR #{node_sql} <= 2)") }
+  end
+
+  describe '#lteq_all' do
+    subject{ described_node.lteq_all([1, 2]) }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Grouping) }
+    specify{ expect(subject.to_sql).to eq("(#{node_sql} <= 1 AND #{node_sql} <= 2)") }
+  end
+
+  describe '#in' do
+    subject{ described_node.in(expr) }
+
+    context 'with infinity range' do
+      let(:expr){ -Float::INFINITY..Float::INFINITY }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::Equality) }
+      specify{ expect(subject.left).to eq(1) }
+      specify{ expect(subject.right).to eq(1) }
+      specify{ expect(subject.to_sql).to eq("1 = 1") }
+    end
+
+    context 'with endless range' do
+      let(:expr){ 1..Float::INFINITY }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::GreaterThanOrEqual) }
+      specify{ expect(subject.left).to eq(described_node) }
+      specify{ expect(subject.right).to eq(1) }
+      specify{ expect(subject.to_sql).to eq("#{node_sql} >= 1") }
+    end
+
+    context 'with startless range' do
+      let(:expr){ -Float::INFINITY..1 }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::LessThanOrEqual) }
+      specify{ expect(subject.left).to eq(described_node) }
+      specify{ expect(subject.right).to eq(1) }
+      specify{ expect(subject.to_sql).to eq("#{node_sql} <= 1") }
+    end
+
+    context 'with startless range with exclided end' do
+      let(:expr){ -Float::INFINITY...1 }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::LessThan) }
+      specify{ expect(subject.left).to eq(described_node) }
+      specify{ expect(subject.right).to eq(1) }
+      specify{ expect(subject.to_sql).to eq("#{node_sql} < 1") }
+    end
+
+    context 'with range' do
+      let(:expr){ -1..1 }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::And) }
+      specify{ expect(subject.to_sql).to eq("#{node_sql} >= -1 AND #{node_sql} <= 1") }
+    end
+
+    context 'with range with exclided end' do
+      let(:expr){ -1...1 }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::And) }
+      specify{ expect(subject.to_sql).to eq("#{node_sql} >= -1 AND #{node_sql} < 1") }
+    end
+
+    context 'with array' do
+      subject{ described_node.in([1, 2]) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::Nodes::In) }
+      specify{ expect(subject.left).to eq(described_node) }
+      specify{ expect(subject.right).to eq([1, 2]) }
+      specify{ expect(subject.to_sql).to eq("#{node_sql} IN (1, 2)") }
+    end
+  end
+end