influxdb-arel 0.0.1 → 0.1.0

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

@@ -8,6 +8,7 @@ describe Influxdb::Arel::Nodes::SqlLiteral do
   end
 
   it_should_behave_like :node_as, 'expressions'
+  it_should_behave_like :node_boolean_predications, 'expressions'
   it_should_behave_like :node_expressions, 'expressions'
   it_should_behave_like :node_predications, 'expressions'
 
@@ -15,13 +16,8 @@ describe Influxdb::Arel::Nodes::SqlLiteral 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

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

@@ -1,14 +1,14 @@
 require 'spec_helper'
 
 describe Influxdb::Arel::Nodes::TableAlias do
-  let(:described_node){ node(:TableAlias, table('events'), 'alias') }
+  let(:described_node){ node(:TableAlias, node(: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')) }
+    specify{ expect(subject.relation).to eq(node(:Table, 'events')) }
   end
 
   describe '#table_alias' do
@@ -19,15 +19,8 @@ describe Influxdb::Arel::Nodes::TableAlias 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')) }
+    specify{ expect(subject.unalias).to eq(node(:Table, 'events')) }
   end
 
   describe '#table_name' do

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

@@ -0,0 +1,8 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::Table do
+  let(:described_node){ node(:Table, 'value') }
+
+  it_should_behave_like :unary_node, :Table, 'value'
+  it_should_behave_like :node_joining_merging, 'value'
+end

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

@@ -16,10 +16,6 @@ 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/quoter/repository_spec.rb

@@ -0,0 +1,10 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Quoter::Repository do
+  subject{ Influxdb::Arel::Quoter::Repository.new }
+
+  before{ subject.add(String){|value| "quoted #{value}" } }
+
+  specify{ expect(subject.quote('string')).to eq('quoted string') }
+  specify{ expect(subject.quote(/.*/)).to eq('/.*/') }
+end

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

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Quoter do
+  describe '#quote' do
+    context 'with String' do
+      specify{ expect(subject.quote('string')).to eq("'string'") }
+    end
+
+    context 'with Time' do
+      specify{ expect(subject.quote(Time.parse('2014-10-09 10:49:19 +0700'))).to eq("'2014-10-09 03:49:19'") }
+    end
+
+    context 'with Date' do
+      specify{ expect(subject.quote(Date.parse('2014-10-09'))).to eq("'2014-10-08'") }
+    end
+
+    context 'with DateTime' do
+      specify{ expect(subject.quote(DateTime.parse('2014-10-09 10:49:19 +0700'))).to eq("'2014-10-09 03:49:19'") }
+    end
+
+    context 'with BigDecimal' do
+      specify{ expect(subject.quote(BigDecimal.new('1.03'))).to eq('1.03') }
+    end
+
+    context 'with NilClass' do
+      specify{ expect(subject.quote(nil)).to eq('null') }
+    end
+
+    context 'with SqlLiteral' do
+      specify{ expect(subject.quote(sql('SOME SQL'))).to eq('SOME SQL') }
+    end
+  end
+end

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

@@ -1,28 +1,70 @@
 require 'spec_helper'
 
 describe Influxdb::Arel::SelectManager do
-  let(:manager){ Influxdb::Arel::SelectManager.new(table('events')) }
+  let(:manager){ Influxdb::Arel::SelectManager.new(:events) }
 
   describe '#group' do
-    subject{ manager.group('time(1s)', 'name', :type) }
+    context 'without block' 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') }
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.group_values).to eq([
+        node(:Attribute, 'time(1s)'), node(:Attribute, 'name'), node(:Attribute, 'type')
+      ]) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events GROUP BY time(1s), name, type') }
+    end
+
+    context 'with block' do
+      subject{ manager.group{ [time('1s'), name, :type] } }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.group_values).to eq([
+        node(:Time, '1s'), node(:Attribute, 'name'), node(:Attribute, 'type')
+      ]) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events GROUP BY time(1s), name, type') }
+    end
 
     context 'chaining' do
-      subject{ table('events').group('time(1s)').group('name', :type) }
+      subject{ manager.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.group_values).to eq([
+        node(:Attribute, 'time(1s)'), node(:Attribute, 'name'), node(:Attribute, 'type')
       ]) }
       specify{ expect(subject.to_sql).to eq('SELECT * FROM events GROUP BY time(1s), name, type') }
     end
   end
 
+  describe '#group!' do
+    context 'without block' do
+      subject{ manager.group!('time(1s)', 'name', :type) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.group_values).to eq([
+        node(:Attribute, 'time(1s)'), node(:Attribute, 'name'), node(:Attribute, 'type')
+      ]) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events GROUP BY time(1s), name, type') }
+    end
+
+    context 'with block' do
+      subject{ manager.group!{ [time('1s'), name, :type] } }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.group_values).to eq([
+        node(:Time, '1s'), node(:Attribute, 'name'), node(:Attribute, 'type')
+      ]) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events GROUP BY time(1s), name, type') }
+    end
+
+    context 'chaining' do
+      subject{ manager.group('time(1s)').group!('name', :type) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.group_values).to eq([node(:Attribute, 'name'), node(:Attribute, 'type')]) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events GROUP BY name, type') }
+    end
+  end
+
   describe '#fill' do
     context 'with empty groups' do
       subject{ manager.fill(0) }
@@ -58,19 +100,11 @@ describe Influxdb::Arel::SelectManager do
   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.ast.tables).to eq([node(:Table, 'table')]) }
       specify{ expect(subject.to_sql).to eq('SELECT * FROM table') }
     end
 
@@ -78,31 +112,33 @@ describe Influxdb::Arel::SelectManager 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.ast.tables).to eq([node(:Table, 'table')]) }
       specify{ expect(subject.to_sql).to eq('SELECT * FROM table') }
     end
 
-    context 'with sql node' do
-      subject{ manager.from(sql('table')) }
+    context 'with block' 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.ast.tables).to eq([node(:Table, 'table')]) }
       specify{ expect(subject.to_sql).to eq('SELECT * FROM table') }
     end
 
-    context 'with table alias' do
-      subject{ manager.from(table('table').as('alias')) }
+    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([table('table').as('alias')]) }
-      specify{ expect(subject.to_sql).to eq('SELECT * FROM table') }
+      specify{ expect(subject.ast.tables).to eq([node(:Table, 'events')]) }
+      specify{ expect(subject.ast.regexp).to eq(node(:Table, /events\..*/)) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM /events\..*/') }
     end
 
-    context 'with regexp' do
-      subject{ manager.from(/events\..*/) }
+    context 'with several regexps' do
+      subject{ manager.from(/events\..*/, /logs\..*/) }
 
       specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ast.series).to eq([sql('/events\..*/')]) }
+      specify{ expect(subject.ast.tables).to eq([node(:Table, 'events')]) }
+      specify{ expect(subject.ast.regexp).to eq(node(:Table, /events\..*/)) }
       specify{ expect(subject.to_sql).to eq('SELECT * FROM /events\..*/') }
     end
 
@@ -110,181 +146,316 @@ describe Influxdb::Arel::SelectManager 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.ast.tables).to eq([node(: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')) }
+      subject{ manager.from(:table1){ [table2, :table3] } }
 
       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') }
+      specify{ expect(subject.ast.tables).to eq([node(:Table, 'table1'), node(:Table, 'table2'), node(:Table, 'table3')]) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM table1, table2, table3') }
     end
 
     context 'with several non unique tables' do
-      subject{ manager.from('table1', table('table1'), 'table1') }
+      subject{ manager.from(:table1){ [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.ast.tables).to eq([node(:Table, 'table1')]) }
       specify{ expect(subject.to_sql).to eq('SELECT * FROM table1') }
     end
 
     context 'chaining' do
-      subject{ manager.from('table1').from('table2') }
+      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.ast.tables).to eq([node(:Table, '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') }
+    context 'joining' do
+      let(:alias1){ node(:Table, 'table1').as(:alias1) }
+      let(:alias2){ node(:Table, 'table2').as(:alias2) }
 
-    subject{ manager.join('errors') }
+      context do
+        subject{ manager.from{ join(:table1, :table2) } }
 
-    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') }
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.join).to eq(node(:Join, node(:Table, 'table1'), node(:Table, 'table2'))) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 INNER JOIN table2') }
+      end
 
-    context 'when table as argument' do
-      subject{ manager.join(table('errors')) }
+      context do
+        subject{ manager.from{ join(table1, table2) } }
 
-      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') }
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.join).to eq(node(:Join, node(:Table, 'table1'), node(:Table, 'table2'))) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 INNER JOIN table2') }
+      end
+
+      context do
+        subject{ manager.from{ join(table1.as(:alias1), table2.as(:alias2)) } }
+
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.join).to eq(node(:Join, alias1, alias2)) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 AS alias1 INNER JOIN table2 AS alias2') }
+      end
+
+      context do
+        subject{ manager.from(:table1){ join(:table2) } }
+
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.join).to eq(node(:Join, node(:Table, 'table1'), node(:Table, 'table2'))) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 INNER JOIN table2') }
+      end
+
+      context do
+        subject{ manager.from(:table1){ join(table2) } }
+
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.join).to eq(node(:Join, node(:Table, 'table1'), node(:Table, 'table2'))) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 INNER JOIN table2') }
+      end
+
+      context do
+        subject{ manager.from(:table1){ join(table2.as(:alias2)) } }
+
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.join).to eq(node(:Join, node(:Table, 'table1'), alias2)) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 INNER JOIN table2 AS alias2') }
+      end
+
+      context do
+        subject{ manager.from{ table1.join(table2.as(:alias2)) } }
+
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.join).to eq(node(:Join, node(:Table, 'table1'), alias2)) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 INNER JOIN table2 AS alias2') }
+      end
+
+      context do
+        subject{ manager.from{ table1.as(:alias1).join(table2.as(:alias2)) } }
+
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.join).to eq(node(:Join, alias1, alias2)) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 AS alias1 INNER JOIN table2 AS alias2') }
+      end
     end
 
-    context 'when alias as argument' do
-      let(:table_alias){ table('errors').as('fatal_errors') }
+    context 'merging' do
+      let(:alias1){ node(:Table, 'table1').as(:alias1) }
+      let(:alias2){ node(:Table, 'table2').as(:alias2) }
 
-      subject{ manager.join(table_alias) }
+      context do
+        subject{ manager.from{ merge(:table1, :table2) } }
 
-      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') }
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.merge).to eq(node(:Merge, node(:Table, 'table1'), node(:Table, 'table2'))) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 MERGE table2') }
+      end
+
+      context do
+        subject{ manager.from{ merge(table1, table2) } }
+
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.merge).to eq(node(:Merge, node(:Table, 'table1'), node(:Table, 'table2'))) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 MERGE table2') }
+      end
+
+      context do
+        subject{ manager.from{ merge(table1.as(:alias1), table2.as(:alias2)) } }
+
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.merge).to eq(node(:Merge, alias1, alias2)) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 MERGE table2') }
+      end
+
+      context do
+        subject{ manager.from(:table1){ merge(:table2) } }
+
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.merge).to eq(node(:Merge, node(:Table, 'table1'), node(:Table, 'table2'))) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 MERGE table2') }
+      end
+
+      context do
+        subject{ manager.from(:table1){ merge(table2) } }
+
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.merge).to eq(node(:Merge, node(:Table, 'table1'), node(:Table, 'table2'))) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 MERGE table2') }
+      end
+
+      context do
+        subject{ manager.from(:table1){ merge(table2.as(:alias2)) } }
+
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.merge).to eq(node(:Merge, node(:Table, 'table1'), alias2)) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 MERGE table2') }
+      end
+
+      context do
+        subject{ manager.from{ table1.merge(table2.as(:alias2)) } }
+
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.merge).to eq(node(:Merge, node(:Table, 'table1'), alias2)) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 MERGE table2') }
+      end
+
+      context do
+        subject{ manager.from{ table1.as(:alias1).merge(table2.as(:alias2)) } }
+
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.merge).to eq(node(:Merge, alias1, alias2)) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM table1 MERGE table2') }
+      end
     end
+  end
 
-    context 'with two aliases' do
-      subject{ manager.from(table_alias1).join(table_alias2) }
+  describe '#join' do
+    context 'with one table' do
+      subject{ manager.join(:errors) }
 
       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') }
+      specify{ expect(subject.ast.join).to eq(node(:Join, node(:Table, 'events'), node(:Table, 'errors'))) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events INNER JOIN errors') }
+    end
+
+    context 'with two table' do
+      context do
+        let(:manager){ Influxdb::Arel::SelectManager.new }
+
+        subject{ manager.join(:errors, :logs) }
+
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.join).to eq(node(:Join, node(:Table, 'errors'), node(:Table, 'logs'))) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM errors INNER JOIN logs') }
+      end
+
+      context 'and default table' do
+        subject{ manager.join(:errors, :logs) }
+
+        specify{ expect{ subject }.to raise_error }
+      end
     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') }
+      specify{ expect{ subject }.to raise_error }
     end
 
-    context 'without argument with many series' do
-      subject{ manager.from('user_events', 'errors').join }
+    context 'without argument but 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.ast.join).to eq(node(:Join, node(:Table, 'user_events'), node(:Table, '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') }
+    context 'without argument but with too many aliases' do
+      subject{ manager.from(:table1, :table2, :table3).join }
+      specify{ expect{ subject }.to raise_error }
     end
 
     context 'with merging' do
-      subject{ manager.from(table_alias1, table_alias2).merge.join }
+      subject{ manager.from(:user_events, :errors).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') }
+      specify{ expect(subject.ast.merge).to eq(node(:Merge, node(:Table, 'user_events'), node(:Table, 'errors'))) }
+      specify{ expect(subject.ast.join).to eq(node(:Join, node(:Table, 'user_events'), node(:Table, 'errors'))) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM user_events INNER JOIN errors') }
     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')) }
+    context 'with one table' do
+      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'), table('errors'))) }
+      specify{ expect(subject.ast.merge).to eq(node(:Merge, node(:Table, 'events'), node(: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') }
+    context 'with two table' do
+      context do
+        let(:manager){ Influxdb::Arel::SelectManager.new }
 
-      subject{ manager.merge(table_alias) }
+        subject{ manager.merge(:errors, :logs) }
 
-      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
+        specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+        specify{ expect(subject.ast.merge).to eq(node(:Merge, node(:Table, 'errors'), node(:Table, 'logs'))) }
+        specify{ expect(subject.to_sql).to eq('SELECT * FROM errors MERGE logs') }
+      end
 
-    context 'when alias as argument' do
-      let(:table_alias){ table('errors').as('fatal_errors') }
+      context 'and default table' do
+        subject{ manager.merge(:errors, :logs) }
 
-      subject{ manager.merge(table_alias) }
+        specify{ expect{ subject }.to raise_error }
+      end
+    end
 
-      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') }
+    context 'without argument' do
+      subject{ manager.merge }
+      specify{ expect{ subject }.to raise_error }
     end
 
-    context 'with two aliases' do
-      subject{ manager.from(table_alias1).merge(table_alias2) }
+    context 'without argument but with many tables' 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, table('events'), table('errors'))) }
-      specify{ expect(subject.to_sql).to eq('SELECT * FROM events MERGE errors') }
+      specify{ expect(subject.ast.merge).to eq(node(:Merge, node(:Table, 'user_events'), node(:Table, 'errors'))) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM user_events MERGE errors') }
     end
 
-    context 'without argument' do
-      subject{ manager.merge }
+    context 'without argument but with too many tables' do
+      subject{ manager.from(:table1, :table2, :table3).merge }
+      specify{ expect{ subject }.to raise_error }
+    end
+
+    context 'with joining' do
+      subject{ manager.from(:user_events, :errors).join.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') }
+      specify{ expect(subject.ast.merge).to eq(node(:Merge, node(:Table, 'user_events'), node(:Table, 'errors'))) }
+      specify{ expect(subject.ast.join).to eq(node(:Join, node(:Table, 'user_events'), node(:Table, 'errors'))) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM user_events INNER JOIN errors') }
     end
+  end
+
+  describe '#select' do
+    let(:nodes){ [node(:Attribute, 'time'), node(:Attribute, 'name'), node(:Attribute, 'age')] }
 
-    context 'without argument with many series' do
-      subject{ manager.from('user_events', 'errors').merge }
+    subject{ manager.select(:time){ [name, :age] } }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+    specify{ expect(subject.select_values).to eq(nodes) }
+    specify{ expect(subject.to_sql).to eq('SELECT time, name, age FROM events') }
+
+    context 'chaining' do
+      subject{ manager.select(:time).select{ [name, :age] } }
 
       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') }
+      specify{ expect(subject.select_values).to eq(nodes) }
+      specify{ expect(subject.to_sql).to eq('SELECT time, name, age FROM events') }
     end
   end
 
-  describe '#column' do
-    subject{ manager.column(table('events')[:time], 'name', :type) }
+  describe '#select!' do
+    let(:nodes){ [node(:Attribute, 'time'), node(:Attribute, 'name'), node(:Attribute, 'age')] }
+
+    subject{ manager.select!(:time){ [name, :age] } }
 
     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') }
+    specify{ expect(subject.select_values).to eq(nodes) }
+    specify{ expect(subject.to_sql).to eq('SELECT time, name, age FROM events') }
 
     context 'chaining' do
-      subject{ manager.column(table('events')[:time]).column('name', :type) }
+      subject{ manager.select(:time).select!{ [name, :age] } }
 
       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') }
+      specify{ expect(subject.select_values).to eq([node(:Attribute, 'name'), node(:Attribute, 'age')]) }
+      specify{ expect(subject.to_sql).to eq('SELECT name, age FROM events') }
     end
   end
 
@@ -296,7 +467,7 @@ describe Influxdb::Arel::SelectManager 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.order_value).to eq(asc) }
       specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER ASC') }
     end
 
@@ -304,7 +475,7 @@ describe Influxdb::Arel::SelectManager 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.order_value).to eq(asc) }
       specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER ASC') }
     end
 
@@ -312,15 +483,7 @@ describe Influxdb::Arel::SelectManager 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.order_value).to eq(asc) }
       specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER ASC') }
     end
 
@@ -328,7 +491,7 @@ describe Influxdb::Arel::SelectManager 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.order_value).to eq(desc) }
       specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER DESC') }
     end
 
@@ -336,7 +499,7 @@ describe Influxdb::Arel::SelectManager 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.order_value).to eq(desc) }
       specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER DESC') }
     end
 
@@ -344,49 +507,86 @@ describe Influxdb::Arel::SelectManager 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.order_value).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 }
+    describe 'chaining' do
+      subject{ manager.order(desc).order(asc) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.order_value).to eq(asc) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER ASC') }
+    end
+  end
+
+  describe '#asc' do
+    subject{ manager.asc }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+    specify{ expect(subject.order_value).to eq(node(:Ordering, 'asc')) }
+    specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER ASC') }
+  end
+
+  describe '#desc' do
+    subject{ manager.desc }
+
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+    specify{ expect(subject.order_value).to eq(node(:Ordering, 'desc')) }
+    specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER DESC') }
+  end
+
+  describe '#invert_order' do
+    context 'from native order' do
+      subject{ manager.invert_order }
 
       specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ordering).to eq(desc) }
+      specify{ expect(subject.order_value).to eq(node(:Ordering, 'asc')) }
+      specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER ASC') }
+    end
+
+    context 'from asc to desc' do
+      subject{ manager.asc.invert_order }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.order_value).to eq(node(:Ordering, 'desc')) }
       specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER DESC') }
     end
 
-    describe 'chaining' do
-      subject{ manager.order(desc).order(asc) }
+    context 'from desc to asc' do
+      subject{ manager.desc.invert_order }
 
       specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.ordering).to eq(asc) }
+      specify{ expect(subject.order_value).to eq(node(:Ordering, 'asc')) }
       specify{ expect(subject.to_sql).to eq('SELECT * FROM events ORDER ASC') }
     end
   end
 
-  describe '#take' do
-    subject{ manager.take(100) }
+  describe '#limit' do
+    subject{ manager.limit(100) }
 
     specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-    specify{ expect(subject.taken).to eq(node(:Limit, 100)) }
+    specify{ expect(subject.limit_value).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) }
+      subject{ manager.limit(100).limit(1) }
 
       specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
-      specify{ expect(subject.taken).to eq(node(:Limit, 1)) }
+      specify{ expect(subject.limit_value).to eq(node(:Limit, 1)) }
       specify{ expect(subject.to_sql).to eq('SELECT * FROM events LIMIT 1') }
     end
   end
 
   describe '#where' do
+    let(:equality1){ node(:Equality, node(:Attribute, 'name'), 'Undr') }
+    let(:equality2){ node(:Equality, node(:Attribute, 'age'), 20) }
+
     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.where_values).to eq([sql("name = 'Undr'")]) }
       specify{ expect(subject.to_sql).to eq("SELECT * FROM events WHERE name = 'Undr'") }
     end
 
@@ -394,24 +594,24 @@ describe Influxdb::Arel::SelectManager 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.where_values).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')) }
+    context 'with conditions as Hash' do
+      subject{ manager.where(name: 'Undr', age: 20) }
 
       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'") }
+      specify{ expect(subject.where_values).to eq([node(:And, [equality1, equality2])]) }
+      specify{ expect(subject.to_sql).to eq("SELECT * FROM events WHERE name = 'Undr' AND age = 20") }
     end
 
     context 'chaining' do
-      subject{ manager.where("name = 'Undr'").where("email = 'undr@gmail.com'") }
+      subject{ manager.where(name: 'Undr').where(age: 20) }
 
       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'") }
+      specify{ expect(subject.where_values).to eq([equality1, equality2]) }
+      specify{ expect(subject.to_sql).to eq("SELECT * FROM events WHERE name = 'Undr' AND age = 20") }
     end
   end