influxdb-arel 0.0.1

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

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require './lib/influxdb/arel/core_extensions'
+
+describe Integer do
+  describe '#u' do
+    specify{ expect(1.u).to eq(node(:Duration, 1, sql('u'))) }
+  end
+
+  describe '#s' do
+    specify{ expect(1.s).to eq(node(:Duration, 1, sql('s'))) }
+  end
+
+  describe '#m' do
+    specify{ expect(1.m).to eq(node(:Duration, 1, sql('m'))) }
+  end
+
+  describe '#h' do
+    specify{ expect(1.h).to eq(node(:Duration, 1, sql('h'))) }
+  end
+
+  describe '#d' do
+    specify{ expect(1.d).to eq(node(:Duration, 1, sql('d'))) }
+  end
+
+  describe '#w' do
+    specify{ expect(1.w).to eq(node(:Duration, 1, sql('w'))) }
+  end
+end
+
+
+describe String do
+  describe '#as' do
+    specify{ expect('MEAN(value)'.as('mean')).to eq(node(:As, sql('MEAN(value)'), 'mean')) }
+  end
+
+  describe '#to_arel' do
+    specify{ expect('events'.to_arel).to eq(sql('events')) }
+  end
+end
+
+describe Symbol do
+  describe '#as' do
+    specify{ expect(:events.as('alias')).to eq(node(:TableAlias, table(:events), 'alias')) }
+  end
+
+  describe '#to_arel' do
+    specify{ expect(:events.to_arel).to eq(table(:events)) }
+  end
+end

data/spec/lib/influxdb/arel/nodes/and_spec.rb

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::And do
+  describe '#to_sql' do
+    subject{ node(:And, ['first', sql('second'), 'third']).to_sql }
+
+    specify{ expect(subject).to eq("'first' AND second AND 'third'") }
+  end
+
+  describe '#eql?' do
+    subject{ node(:And, ['first', sql('second'), 'third']) }
+
+    specify{ expect(subject.eql?(node(:And, ['first', sql('second'), 'third']))).to be_truthy }
+    specify{ expect(subject.eql?(node(:And, ['first', 'second', 'third']))).to be_truthy }
+    specify{ expect(subject.eql?(node(:And, ['first', 'second', 'third', 'fourth']))).to be_falsy }
+  end
+end

data/spec/lib/influxdb/arel/nodes/binary_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::Binary do
+  it_should_behave_like :binary_node, :Binary
+end
+
+describe Influxdb::Arel::Nodes::As do
+  it_should_behave_like :binary_node, :As, 'left AS right'
+end
+
+describe Influxdb::Arel::Nodes::DoesNotMatch do
+  it_should_behave_like :binary_node, :DoesNotMatch, 'left !~ right'
+end
+
+describe Influxdb::Arel::Nodes::GreaterThan do
+  it_should_behave_like :binary_node, :GreaterThan, 'left > right'
+end
+
+describe Influxdb::Arel::Nodes::GreaterThanOrEqual do
+  it_should_behave_like :binary_node, :GreaterThanOrEqual, 'left >= right'
+end
+
+describe Influxdb::Arel::Nodes::Join do
+  it_should_behave_like :binary_node, :Join, 'left INNER JOIN right'
+end
+
+describe Influxdb::Arel::Nodes::LessThan do
+  it_should_behave_like :binary_node, :LessThan, 'left < right'
+end
+
+describe Influxdb::Arel::Nodes::LessThanOrEqual do
+  it_should_behave_like :binary_node, :LessThanOrEqual, 'left <= right'
+end
+
+describe Influxdb::Arel::Nodes::Matches do
+  it_should_behave_like :binary_node, :Matches, 'left =~ right'
+end
+
+describe Influxdb::Arel::Nodes::Merge do
+  it_should_behave_like :binary_node, :Merge, 'left MERGE right'
+end
+
+describe Influxdb::Arel::Nodes::NotEqual do
+  it_should_behave_like :binary_node, :NotEqual, 'left <> right'
+end
+
+describe Influxdb::Arel::Nodes::Or do
+  it_should_behave_like :binary_node, :Or, 'left OR right'
+end

data/spec/lib/influxdb/arel/nodes/duration_spec.rb

@@ -0,0 +1,72 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::Duration do
+  let(:described_node){ node(:Duration, 10, 'h') }
+
+  it_should_behave_like :node_to_sql, '10h'
+
+  describe '#eql?' do
+    specify{ expect(described_node.eql?(node(:Duration, 10, 'h'))).to be_truthy }
+    specify{ expect(described_node.eql?(node(:Duration, 10, 's'))).to be_falsy }
+    specify{ expect(described_node.eql?(node(:Duration, 11, 'h'))).to be_falsy }
+  end
+
+  describe 'initialization' do
+    context 'with invalid suffix' do
+      subject{ node(:Duration, 10, 'hours') }
+
+      specify{ expect(subject).to eq(node(:Duration, 10, 'u')) }
+    end
+
+    context 'with nulled suffix' do
+      subject{ node(:Duration, 10, nil) }
+
+      specify{ expect(subject).to eq(node(:Duration, 10, 'u')) }
+    end
+
+    context 'with value as string' do
+      subject{ node(:Duration, '10', 'h') }
+
+      specify{ expect(subject).to eq(node(:Duration, 10, 'h')) }
+    end
+
+    context 'with value as float' do
+      subject{ node(:Duration, 10.34, 'h') }
+
+      specify{ expect(subject).to eq(node(:Duration, 10, 'h')) }
+    end
+
+    context 'with invalid value' do
+      subject{ node(:Duration, 'one', 'h') }
+
+      specify{ expect(subject).to eq(node(:Duration, 0, 'h')) }
+    end
+
+    context 'with nulled value' do
+      subject{ node(:Duration, nil, 'h') }
+
+      specify{ expect(subject).to eq(node(:Duration, 0, 'h')) }
+    end
+  end
+
+  describe '#time' do
+    subject{ node(:Duration, 10, 'h').time }
+
+    specify{ expect(subject).to eq(node(:Time, node(:Duration, 10, 'h'))) }
+    specify{ expect(subject.to_sql).to eq('time(10h)') }
+  end
+
+  describe '#ago' do
+    subject{ node(:Duration, 10, 'h').ago }
+
+    specify{ expect(subject).to eq(node(:Grouping, node(:Subtraction, node(:Now), node(:Duration, 10, 'h')))) }
+    specify{ expect(subject.to_sql).to eq('(now() - 10h)') }
+  end
+
+  describe '#since' do
+    subject{ node(:Duration, 10, 'h').since }
+
+    specify{ expect(subject).to eq(node(:Grouping, node(:Addition, node(:Now), node(:Duration, 10, 'h')))) }
+    specify{ expect(subject.to_sql).to eq('(now() + 10h)') }
+  end
+end

data/spec/lib/influxdb/arel/nodes/equality_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::Equality do
+  it_should_behave_like :binary_node, :Equality, 'left = right'
+end

data/spec/lib/influxdb/arel/nodes/function_spec.rb

@@ -0,0 +1,69 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::Count do
+  it_should_behave_like :function_node, :Count, 'COUNT(expression)'
+end
+
+describe Influxdb::Arel::Nodes::Sum do
+  it_should_behave_like :function_node, :Sum, 'SUM(expression)'
+end
+
+describe Influxdb::Arel::Nodes::Max do
+  it_should_behave_like :function_node, :Max, 'MAX(expression)'
+end
+
+describe Influxdb::Arel::Nodes::Min do
+  it_should_behave_like :function_node, :Min, 'MIN(expression)'
+end
+
+describe Influxdb::Arel::Nodes::Mean do
+  it_should_behave_like :function_node, :Mean, 'MEAN(expression)'
+end
+
+describe Influxdb::Arel::Nodes::Mode do
+  it_should_behave_like :function_node, :Mode, 'MODE(expression)'
+end
+
+describe Influxdb::Arel::Nodes::Median do
+  it_should_behave_like :function_node, :Median, 'MEDIAN(expression)'
+end
+
+describe Influxdb::Arel::Nodes::Distinct do
+  it_should_behave_like :function_node, :Distinct, 'DISTINCT(expression)'
+end
+
+describe Influxdb::Arel::Nodes::Percentile do
+  it_should_behave_like :function_node, :Percentile, 'PERCENTILE(expression, 99)', [99]
+end
+
+describe Influxdb::Arel::Nodes::Histogram do
+  it_should_behave_like :function_node, :Histogram, 'HISTOGRAM(expression, 50)', [50]
+end
+
+describe Influxdb::Arel::Nodes::Derivative do
+  it_should_behave_like :function_node, :Derivative, 'DERIVATIVE(expression)'
+end
+
+describe Influxdb::Arel::Nodes::Stddev do
+  it_should_behave_like :function_node, :Stddev, 'STDDEV(expression)'
+end
+
+describe Influxdb::Arel::Nodes::First do
+  it_should_behave_like :function_node, :First, 'FIRST(expression)'
+end
+
+describe Influxdb::Arel::Nodes::Last do
+  it_should_behave_like :function_node, :Last, 'LAST(expression)'
+end
+
+describe Influxdb::Arel::Nodes::Difference do
+  it_should_behave_like :function_node, :Difference, 'DIFFERENCE(expression)'
+end
+
+describe Influxdb::Arel::Nodes::Top do
+  it_should_behave_like :function_node, :Top, 'TOP(expression, 10)', [10]
+end
+
+describe Influxdb::Arel::Nodes::Bottom do
+  it_should_behave_like :function_node, :Bottom, 'BOTTOM(expression, 10)', [10]
+end

data/spec/lib/influxdb/arel/nodes/grouping_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::Grouping do
+  let(:described_node){ node(:Grouping, sql('value')) }
+
+  it_should_behave_like :unary_node, :Grouping, '(value)'
+  it_should_behave_like :node_as, '(value)'
+  it_should_behave_like :node_expressions, '(value)'
+  it_should_behave_like :node_predications, '(value)'
+end

data/spec/lib/influxdb/arel/nodes/in_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::In do
+  let(:described_node){ node(:In, sql('left'), [1, 2, 3]) }
+
+  it_should_behave_like :node_to_sql, 'left IN (1, 2, 3)'
+
+  describe '#eql?' do
+    specify{ expect(described_node.eql?(node(:In, sql('left'), [1, 2, 3]))).to be_truthy }
+    specify{ expect(described_node.eql?(node(:In, sql('left'), [1, 2]))).to be_falsy }
+    specify{ expect(described_node.eql?(node(:In, sql('left1'), [1, 2, 3]))).to be_falsy }
+  end
+end

data/spec/lib/influxdb/arel/nodes/now_spec.rb

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::Now do
+  let(:described_node){ node(:Now) }
+
+  it_should_behave_like :node_to_sql, 'now()'
+  it_should_behave_like :node_math, 'now()'
+end

data/spec/lib/influxdb/arel/nodes/sql_literal_spec.rb

@@ -0,0 +1,28 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::SqlLiteral do
+  let(:described_node){ node(:SqlLiteral, 'expressions') }
+
+  describe '#to_sql' do
+    specify{ expect(visitor.accept(described_node)).to eq('expressions') }
+  end
+
+  it_should_behave_like :node_as, 'expressions'
+  it_should_behave_like :node_expressions, 'expressions'
+  it_should_behave_like :node_predications, 'expressions'
+
+  describe '#name' do
+    specify{ expect(described_node.name).to eq(described_node) }
+  end
+
+  describe '#unalias' do
+    specify{ expect(described_node.unalias).to eq(described_node) }
+  end
+
+  describe '#eql?' do
+    specify{ expect(described_node.eql?(node(:SqlLiteral, 'expressions'))).to be_truthy }
+    specify{ expect(described_node.eql?(table('expressions'))).to be_truthy }
+    specify{ expect(described_node.eql?(node(:SqlLiteral, 'expressions1'))).to be_falsy }
+    specify{ expect(described_node.eql?(node(:Fill, 'expressions'))).to be_falsy }
+  end
+end

data/spec/lib/influxdb/arel/nodes/table_alias_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::TableAlias do
+  let(:described_node){ node(:TableAlias, table('events'), 'alias') }
+
+  subject{ described_node }
+
+  it_should_behave_like :binary_node, :TableAlias, 'left AS right'
+
+  describe '#relation' do
+    specify{ expect(subject.relation).to eq(table('events')) }
+  end
+
+  describe '#table_alias' do
+    specify{ expect(subject.table_alias).to eq('alias') }
+  end
+
+  describe '#name' do
+    specify{ expect(subject.name).to eq('alias') }
+  end
+
+  describe '#[]' do
+    subject{ described_node[:name] }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::Attribute) }
+    specify{ expect(visitor.accept(subject)).to eq('alias.name') }
+  end
+
+  describe '#unalias' do
+    specify{ expect(subject.unalias).to eq(table('events')) }
+  end
+
+  describe '#table_name' do
+    specify{ expect(subject.table_name).to eq('events') }
+  end
+end

data/spec/lib/influxdb/arel/nodes/time_spec.rb

@@ -0,0 +1,5 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::Time do
+  it_should_behave_like :unary_node, :Time, 'time(value)'
+end

data/spec/lib/influxdb/arel/nodes/unary_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::Unary do
+  it_should_behave_like :unary_node, :Unary
+end
+
+describe Influxdb::Arel::Nodes::Group do
+  it_should_behave_like :unary_node, :Group, 'value'
+end
+
+describe Influxdb::Arel::Nodes::Limit do
+  it_should_behave_like :unary_node, :Limit, 'LIMIT value'
+end
+
+describe Influxdb::Arel::Nodes::Fill do
+  it_should_behave_like :unary_node, :Fill, 'fill(value)'
+end
+
+describe Influxdb::Arel::Nodes::Ordering do
+  it_should_behave_like :unary_node, :Ordering, 'ORDER VALUE'
+end
+
+describe Influxdb::Arel::Nodes::Into do
+  it_should_behave_like :unary_node, :Into, 'INTO value'
+end

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

@@ -0,0 +1,459 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::SelectManager do
+  let(:manager){ Influxdb::Arel::SelectManager.new(table('events')) }
+
+  describe '#group' do
+    subject{ manager.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 '#fill' do
+    context 'with empty groups' do
+      subject{ manager.fill(0) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.fill).to eq(node(:Fill, 0)) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events') }
+    end
+
+    context 'filling empty values with integer' do
+      subject{ manager.group('time(1s)').fill(0) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.fill).to eq(node(:Fill, 0)) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events GROUP BY time(1s) fill(0)') }
+    end
+
+    context 'filling empty values with string' do
+      subject{ manager.group('time(1s)').fill('empty') }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.fill).to eq(node(:Fill, 'empty')) }
+      specify{ expect(subject.to_sql).to eq("SELECT * FROM events GROUP BY time(1s) fill('empty')") }
+    end
+
+    context 'filling empty values with sql node' do
+      subject{ manager.group('time(1s)').fill(sql('name')) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.fill).to eq(node(:Fill, sql('name'))) }
+      specify{ expect(subject.to_sql).to eq("SELECT * FROM events GROUP BY time(1s) fill(name)") }
+    end
+  end
+
+  describe '#from' do
+    context 'with table' do
+      subject{ manager.from(table('table')) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.series).to eq([table('table')]) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM table') }
+    end
+
+    context 'with symbol' do
+      subject{ manager.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
+
+    context 'with string' do
+      subject{ manager.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
+
+    context 'with sql node' do
+      subject{ manager.from(sql('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
+
+    context 'with table alias' do
+      subject{ manager.from(table('table').as('alias')) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.series).to eq([table('table').as('alias')]) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM table') }
+    end
+
+    context 'with regexp' do
+      subject{ manager.from(/events\..*/) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.series).to eq([sql('/events\..*/')]) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM /events\..*/') }
+    end
+
+    context 'with nil' do
+      subject{ manager.from(nil) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.series).to eq([table('events')]) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events') }
+    end
+
+    context 'with several tables' do
+      subject{ manager.from('table1', table('table2'), table('table2').as('alias')) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.series).to eq([sql('table1'), table('table2'), table('table2').as('alias')]) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM table1, table2') }
+    end
+
+    context 'with several non unique tables' do
+      subject{ manager.from('table1', table('table1'), 'table1') }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.series).to eq([sql('table1'), table('table1'), sql('table1')]) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM table1') }
+    end
+
+    context 'chaining' do
+      subject{ manager.from('table1').from('table2') }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.series).to eq([sql('table2')]) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM table2') }
+    end
+  end
+
+  describe '#join' do
+    let(:table_alias1){ table('events').as('events1') }
+    let(:table_alias2){ table('events').as('events2') }
+
+    subject{ manager.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{ manager.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{ manager.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 'with two aliases' do
+      subject{ manager.from(table_alias1).join(table_alias2) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.join).to eq(node(:Join, table_alias1, table_alias2)) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events AS events1 INNER JOIN events AS events2') }
+    end
+
+    context 'without argument' do
+      subject{ manager.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{ manager.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
+
+    context 'without argument with many aliases' do
+      subject{ manager.from(table_alias1, table_alias2).join }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.join).to eq(node(:Join, table_alias1, table_alias2)) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events AS events1 INNER JOIN events AS events2') }
+    end
+
+    context 'with merging' do
+      subject{ manager.from(table_alias1, table_alias2).merge.join }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.merge).to eq(node(:Merge, table('events'), table('events'))) }
+      specify{ expect(subject.ast.join).to eq(node(:Join, table_alias1, table_alias2)) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events AS events1 INNER JOIN events AS events2') }
+    end
+  end
+
+  describe '#merge' do
+    let(:table_alias1){ table('events').as('events1') }
+    let(:table_alias2){ table('errors').as('errors1') }
+
+    subject{ manager.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{ manager.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{ manager.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 'when alias as argument' do
+      let(:table_alias){ table('errors').as('fatal_errors') }
+
+      subject{ manager.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 'with two aliases' do
+      subject{ manager.from(table_alias1).merge(table_alias2) }
+
+      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{ manager.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{ manager.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 '#column' do
+    subject{ manager.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{ manager.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 '#order' do
+    let(:asc){ node(:Ordering, 'asc') }
+    let(:desc){ node(:Ordering, 'desc') }
+
+    context 'when sort by ascending order' do
+      subject{ manager.order(:asc) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ordering).to eq(asc) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER ASC') }
+    end
+
+    context 'when sort by ascending order' do
+      subject{ manager.order('asc') }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ordering).to eq(asc) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER ASC') }
+    end
+
+    context 'when sort by ascending order' do
+      subject{ manager.order(asc) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ordering).to eq(asc) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER ASC') }
+    end
+
+    context 'when sort by ascending order' do
+      subject{ manager.asc }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ordering).to eq(asc) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER ASC') }
+    end
+
+    context 'when sort by descending order' do
+      subject{ manager.order(:desc) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ordering).to eq(desc) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER DESC') }
+    end
+
+    context 'when sort by descending order' do
+      subject{ manager.order('desc') }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ordering).to eq(desc) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER DESC') }
+    end
+
+    context 'when sort by descending order' do
+      subject{ manager.order(desc) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ordering).to eq(desc) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER DESC') }
+    end
+
+    context 'when sort by descending order' do
+      subject{ manager.desc }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ordering).to eq(desc) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER DESC') }
+    end
+
+    describe 'chaining' do
+      subject{ manager.order(desc).order(asc) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ordering).to eq(asc) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER ASC') }
+    end
+  end
+
+  describe '#take' do
+    subject{ manager.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') }
+
+    context 'chaining' do
+      subject{ manager.take(100).take(1) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.taken).to eq(node(:Limit, 1)) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events LIMIT 1') }
+    end
+  end
+
+  describe '#where' do
+    context 'with conditions as string' do
+      subject{ manager.where("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'") }
+    end
+
+    context 'with conditions as sql leteral' do
+      subject{ manager.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'") }
+    end
+
+    context 'with conditions as sql node' do
+      subject{ manager.where(table('events')[:name].eq('Undr')) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.wheres).to eq([node(:Equality, table('events')[:name], 'Undr')]) }
+      specify{ expect(subject.to_sql).to eq("SELECT * FROM events WHERE name = 'Undr'") }
+    end
+
+    context 'chaining' do
+      subject{ manager.where("name = 'Undr'").where("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 '#into' do
+    context 'with string as argument' do
+      subject{ manager.into('events.all') }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.into).to eq(node(:Into, sql('events.all'))) }
+      specify{ expect(subject.to_sql).to eq("SELECT * FROM events INTO events.all") }
+    end
+
+    context 'with symbol as argument' do
+      subject{ manager.into(:'events.all') }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.into).to eq(node(:Into, sql('events.all'))) }
+      specify{ expect(subject.to_sql).to eq("SELECT * FROM events INTO events.all") }
+    end
+
+    context 'with sql node as argument' do
+      subject{ manager.into(sql('events.all')) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.into).to eq(node(:Into, sql('events.all'))) }
+      specify{ expect(subject.to_sql).to eq("SELECT * FROM events INTO events.all") }
+    end
+
+    context 'fanout placeholder' do
+      subject{ manager.into('events.[host]') }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.into).to eq(node(:Into, sql('events.[host]'))) }
+      specify{ expect(subject.to_sql).to eq("SELECT * FROM events INTO events.[host]") }
+    end
+
+    context 'many series placeholder' do
+      subject{ manager.into('events.:series_name') }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.ast.into).to eq(node(:Into, sql('events.:series_name'))) }
+      specify{ expect(subject.to_sql).to eq("SELECT * FROM events INTO events.:series_name") }
+    end
+  end
+end