influxdb-arel 0.0.1 → 0.1.0

data/lib/influxdb/arel/visitor/delete_statement.rb

@@ -0,0 +1,32 @@
+module Influxdb
+  module Arel
+    class Visitor
+      class DeleteStatement
+        include WhereStatement
+
+        attr_reader :visitor
+
+        def initialize(visitor)
+          @visitor = visitor
+        end
+
+        def visit(object)
+          build_from(object)
+          build_wheres(object)
+
+          result.strip
+        end
+
+        private
+
+        def build_from(object)
+          result << " FROM #{visitor.accept(object.table)}"
+        end
+
+        def result
+          @result ||= 'DELETE'
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/arel/visitor/select_statement.rb

@@ -0,0 +1,59 @@
+module Influxdb
+  module Arel
+    class Visitor
+      class SelectStatement
+        include WhereStatement
+
+        attr_reader :visitor
+
+        def initialize(visitor)
+          @visitor = visitor
+        end
+
+        def visit(object)
+          build_attributes(object)
+          build_from(object)
+          build_wheres(object)
+          build_groups(object)
+          build_rest_of_clauses(object)
+
+          result.strip
+        end
+
+        private
+
+        def build_rest_of_clauses(object)
+          result << " #{visitor.accept(object.order)}" if object.order
+          result << " #{visitor.accept(object.limit)}" if object.limit
+          result << " #{visitor.accept(object.into)}" if object.into
+        end
+
+        def build_attributes(object)
+          unless object.attributes.empty?
+            result << SPACE
+            result << object.attributes.map{|attribute| visitor.accept(attribute) }.join(COMMA)
+          else
+            result << SPACE
+            result << Arel.star
+          end
+        end
+
+        def build_from(object)
+          result << " FROM #{visitor.accept(object.table)}"
+        end
+
+        def build_groups(object)
+          unless object.groups.empty?
+            result << GROUP_BY
+            result << object.groups.map{|group| visitor.accept(group) }.join(COMMA)
+            result << " #{visitor.accept(object.fill)}" if object.fill
+          end
+        end
+
+        def result
+          @result ||= 'SELECT'
+        end
+      end
+    end
+  end
+end

data/lib/influxdb/arel/visitor/where_statement.rb

@@ -0,0 +1,14 @@
+module Influxdb
+  module Arel
+    class Visitor
+      module WhereStatement
+        def build_wheres(object)
+          unless object.wheres.empty?
+            result << WHERE
+            result << object.wheres.map{|where| visitor.accept(where) }.join(AND)
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,173 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Builder do
+  describe '#from' do
+    subject{ builder(:events).from(:table) }
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+    specify{ expect(subject.ast.tables).to eq([node(:Table, :table)]) }
+    specify{ expect(subject.to_sql).to eq('SELECT * FROM table') }
+  end
+
+  describe '#merge' do
+    subject{ builder(:events).merge(:errors) }
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+    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') }
+
+    context 'when table as argument' do
+      subject{ builder(:events).merge(node(:Table, :errors)) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      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 'without argument' do
+      subject{ builder(:events).merge }
+      specify{ expect{ subject }.to raise_error }
+    end
+
+    context 'without argument with more than two tables' do
+      subject{ builder.from(:events, :errors, :logs).merge }
+      specify{ expect{ subject }.to raise_error }
+    end
+
+    context 'without argument with two tables' do
+      subject{ builder.from(:events, :errors).merge }
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      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
+  end
+
+  describe '#join' do
+    subject{ builder(:events).join(:errors) }
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+    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') }
+
+    context 'when table as argument' do
+      subject{ builder(:events).join(node(:Table, :errors)) }
+
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      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 'without argument' do
+      subject{ builder(:events).join }
+      specify{ expect{ subject }.to raise_error }
+    end
+
+    context 'without argument with more than two tables' do
+      subject{ builder.from(:events, :errors, :logs).join }
+      specify{ expect{ subject }.to raise_error }
+    end
+
+    context 'without argument with two tables' do
+      subject{ builder.from(:events, :errors).join }
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      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
+  end
+
+  describe '#order' do
+    context 'when sort by ascending order' do
+      subject{ builder(:events).order(: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
+
+    context 'when sort by ascending order' do
+      subject{ builder(:events).order('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
+
+    context 'when sort by descending order' do
+      subject{ builder(:events).order(: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
+
+    context 'when sort by descending order' do
+      subject{ builder(:events).order('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
+  end
+
+  describe '#asc' do
+    subject{ builder(:events).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{ builder(:events).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 '#limit' do
+    subject{ builder(:events).limit(100) }
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+    specify{ expect(subject.limit_value).to eq(node(:Limit, 100)) }
+    specify{ expect(subject.to_sql).to eq('SELECT * FROM events LIMIT 100') }
+  end
+
+  describe '#group' do
+    subject{ builder(:events).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') }
+
+    context 'chaining' do
+      subject{ builder(: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(: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 '#where' do
+    subject{ builder(:events).where("name = 'Undr'") }
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+    specify{ expect(subject.where_values).to eq([sql("name = 'Undr'")]) }
+    specify{ expect(subject.to_sql).to eq("SELECT * FROM events WHERE name = 'Undr'") }
+
+    context 'chaining' do
+      subject{ builder(:events).where("name = 'Undr'").where(sql("email = 'undr@gmail.com'")) }
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.where_values).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 '#select' do
+    subject{ builder('events').select('name', :type) }
+    specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+    specify{ expect(subject.select_values).to eq([node(:Attribute, 'name'), node(:Attribute, 'type')]) }
+    specify{ expect(subject.to_sql).to eq('SELECT name, type FROM events') }
+
+    context 'chaining' do
+      subject{ builder('events').select{ time }.select('name', :type) }
+      specify{ expect(subject).to be_instance_of(Influxdb::Arel::SelectManager) }
+      specify{ expect(subject.select_values).to eq(
+        [node(:Attribute, 'time'), node(:Attribute, 'name'), node(:Attribute, 'type')]
+      ) }
+      specify{ expect(subject.to_sql).to eq('SELECT time, name, type FROM events') }
+    end
+  end
+end

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

@@ -26,24 +26,3 @@ describe Integer 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

@@ -1,17 +1,14 @@
 require 'spec_helper'
 
 describe Influxdb::Arel::Nodes::And do
-  describe '#to_sql' do
-    subject{ node(:And, ['first', sql('second'), 'third']).to_sql }
+  let(:described_node){ node(:And, ['first', sql('second'), 'third']) }
 
-    specify{ expect(subject).to eq("'first' AND second AND 'third'") }
-  end
+  it_should_behave_like :node_to_sql, "'first' AND second AND 'third'"
+  it_should_behave_like :node_boolean_predications, "'first' AND second AND 'third'"
 
   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 }
+    specify{ expect(described_node.eql?(node(:And, ['first', sql('second'), 'third']))).to be_truthy }
+    specify{ expect(described_node.eql?(node(:And, ['first', 'second', 'third']))).to be_truthy }
+    specify{ expect(described_node.eql?(node(:And, ['first', 'second', 'third', 'fourth']))).to be_falsy }
   end
 end

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

@@ -0,0 +1,21 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::Attribute do
+  let(:described_node){ node(:Attribute, 'value') }
+
+  it_should_behave_like :unary_node, :Attribute, 'value'
+  it_should_behave_like :node_as, 'value'
+  it_should_behave_like :node_expressions, 'value'
+  it_should_behave_like :node_predications, 'value'
+  it_should_behave_like :node_math, 'value'
+
+  describe '#time?' do
+    specify{ expect(node(:Attribute, 'value').time?).to be_falsy }
+    specify{ expect(node(:Attribute, 'time').time?).to be_truthy }
+  end
+
+  describe '#sequence_number?' do
+    specify{ expect(node(:Attribute, 'value').sequence_number?).to be_falsy }
+    specify{ expect(node(:Attribute, 'sequence_number').sequence_number?).to be_truthy }
+  end
+end

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

@@ -36,10 +36,6 @@ 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

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

@@ -4,6 +4,7 @@ describe Influxdb::Arel::Nodes::Duration do
   let(:described_node){ node(:Duration, 10, 'h') }
 
   it_should_behave_like :node_to_sql, '10h'
+  it_should_behave_like :node_boolean_predications, '10h'
 
   describe '#eql?' do
     specify{ expect(described_node.eql?(node(:Duration, 10, 'h'))).to be_truthy }

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

@@ -4,6 +4,7 @@ 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)'
+  it_should_behave_like :node_boolean_predications, 'left IN (1, 2, 3)'
 
   describe '#eql?' do
     specify{ expect(described_node.eql?(node(:In, sql('left'), [1, 2, 3]))).to be_truthy }

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

@@ -0,0 +1,17 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::Multiplication do
+  it_should_behave_like :infix_operation_node, :Multiplication, 'left * right'
+end
+
+describe Influxdb::Arel::Nodes::Division do
+  it_should_behave_like :infix_operation_node, :Division, 'left / right'
+end
+
+describe Influxdb::Arel::Nodes::Addition do
+  it_should_behave_like :infix_operation_node, :Addition, 'left + right'
+end
+
+describe Influxdb::Arel::Nodes::Subtraction do
+  it_should_behave_like :infix_operation_node, :Subtraction, 'left - right'
+end

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

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::Merge do
+  describe 'initialization' do
+    let(:described_node){ node(:Merge, left, right) }
+
+    context 'with tables' do
+      let(:left){ node(:Table, 'left') }
+      let(:right){ node(:Table, 'right') }
+
+      specify{ expect(described_node.left).to be_instance_of(Influxdb::Arel::Nodes::Table) }
+      specify{ expect(described_node.right).to be_instance_of(Influxdb::Arel::Nodes::Table) }
+    end
+
+    context 'with aliases' do
+      let(:left){ node(:Table, 'left').as(:alias1) }
+      let(:right){ node(:Table, 'right').as(:alias2) }
+
+      specify{ expect(described_node.left).to be_instance_of(Influxdb::Arel::Nodes::Table) }
+      specify{ expect(described_node.right).to be_instance_of(Influxdb::Arel::Nodes::Table) }
+    end
+  end
+
+  it_should_behave_like :binary_node, :Merge, 'left MERGE right'
+end

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

@@ -4,5 +4,6 @@ describe Influxdb::Arel::Nodes::Now do
   let(:described_node){ node(:Now) }
 
   it_should_behave_like :node_to_sql, 'now()'
+  it_should_behave_like :node_boolean_predications, 'now()'
   it_should_behave_like :node_math, 'now()'
 end

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

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Influxdb::Arel::Nodes::Ordering do
+  it_should_behave_like :unary_node, :Ordering, 'ORDER VALUE'
+
+  describe '#invert' do
+    subject{ node(:Ordering, direction).invert }
+
+    context 'from ascending order' do
+      let(:direction){ :asc }
+      specify{ expect(subject).to eq(node(:Ordering, :desc)) }
+    end
+
+    context 'from descending order' do
+      let(:direction){ :desc }
+      specify{ expect(subject).to eq(node(:Ordering, :asc)) }
+    end
+  end
+end