rasti-db 1.1.1 → 1.2.0

data/lib/rasti/db/nql/syntax.treetop

@@ -0,0 +1,168 @@
+module Rasti
+  module DB
+    module NQL
+      grammar Syntax
+        
+        rule sentence
+          space* proposition:proposition space* <Nodes::Sentence>
+        end
+
+        rule proposition
+          disjunction /
+          conjunction /
+          statement
+        end
+
+        rule disjunction
+          left:(conjunction / statement) space* '|' space* right:proposition <Nodes::Disjunction>
+        end
+
+        rule conjunction
+          left:statement space* '&' space* right:(conjunction / statement) <Nodes::Conjunction>
+        end
+
+        rule statement
+          parenthesis_sentence /
+          comparison
+        end
+
+        rule parenthesis_sentence
+          '(' sentence ')' <Nodes::ParenthesisSentence>
+        end
+
+        rule comparison
+          comparison_not_include           /
+          comparison_include               /
+          comparison_like                  /
+          comparison_greater_than_or_equal /
+          comparison_less_than_or_equal    /
+          comparison_greater_than          /
+          comparison_less_than             /
+          comparison_not_equal             /
+          comparison_equal
+        end
+
+        rule field
+          _tables:(table:field_name '.')* _column:field_name <Nodes::Field>
+        end
+
+        rule comparison_include
+          field:field space* comparator:':' space* argument:basic <Nodes::Comparisons::Include>
+        end
+
+        rule comparison_not_include
+          field:field space* comparator:'!:' space* argument:basic <Nodes::Comparisons::NotInclude>
+        end
+
+        rule comparison_like
+          field:field space* comparator:'~' space* argument:basic <Nodes::Comparisons::Like>
+        end
+
+        rule comparison_greater_than
+          field:field space* comparator:'>' space* argument:basic <Nodes::Comparisons::GreaterThan>
+        end
+
+        rule comparison_greater_than_or_equal
+          field:field space* comparator:'>=' space* argument:basic <Nodes::Comparisons::GreaterThanOrEqual>
+        end
+
+        rule comparison_less_than
+          field:field space* comparator:'<' space* argument:basic <Nodes::Comparisons::LessThan>
+        end
+
+        rule comparison_less_than_or_equal
+          field:field space* comparator:'<=' space* argument:basic <Nodes::Comparisons::LessThanOrEqual>
+        end
+
+        rule comparison_not_equal
+          field:field space* comparator:'!=' space* argument:basic <Nodes::Comparisons::NotEqual>
+        end
+
+        rule comparison_equal
+          field:field space* comparator:'=' space* argument:basic <Nodes::Comparisons::Equal>
+        end
+
+        rule basic
+          boolean        /
+          time           /
+          float          /
+          integer        /
+          literal_string /
+          string
+        end
+
+        rule space
+          [\s\t\n]
+        end
+
+        rule field_name
+          [a-z_]+
+        end
+
+        rule time
+          date:(value:date 'T')? hour:(digit digit) ':' minutes:(digit digit) seconds:(':' value:(digit digit))? timezone:(value:timezone)? <Nodes::Constants::Time>
+        end
+
+        rule date
+          year:(digit digit digit digit) '-' month:(digit digit) '-' day:(digit digit)
+        end
+
+        rule timezone
+          sign:sign hour:(digit digit) ':' minutes:(digit digit)
+        end
+
+        rule sign
+          '+' / 
+          '-'
+        end
+
+        rule literal_string
+          '"' string:any_character+ '"' <Nodes::Constants::LiteralString>
+        end
+
+        rule string
+          valid_character+ <Nodes::Constants::String>
+        end
+
+        rule any_character
+          valid_character /
+          reserved_character
+        end
+
+        rule valid_character 
+          [0-9a-zA-ZÁÀÄÂÃÅĀĂǍáàäâãåāăǎÉÈËÊĒĔĖĚéèëêēĕėěÍÌÏÎĨĬǏíìïîĩĭǐÓÒÖÔÕŌŎŐǑóòöôõōŏőǒÚÙÜÛŨŪŬŮŰǓúùüûũūŭůűǔÑñçÇ%@#+-_'?!$*/\s]
+        end
+
+        rule boolean
+          true /
+          false
+        end
+
+        rule true
+          'true' <Nodes::Constants::True>
+        end
+
+        rule false
+          'false' <Nodes::Constants::False>
+        end
+
+        rule float
+          digit+ '.' digit+ <Nodes::Constants::Float>
+        end
+
+        rule integer
+          digit+ <Nodes::Constants::Integer>
+        end
+
+        rule digit
+          [0-9]
+        end
+
+        rule reserved_character
+          [&|.():!=<>~]
+        end
+
+      end
+    end
+  end
+end

data/lib/rasti/db/query.rb

@@ -92,6 +92,17 @@ module Rasti
       end
       alias_method :inspect, :to_s
 
+      def nql(filter_expression)
+        sentence = nql_parser.parse filter_expression
+
+        raise NQL::InvalidExpressionError.new(filter_expression) if sentence.nil?
+
+        dependency_tables = sentence.dependency_tables
+        query = dependency_tables.empty? ? self : join(*dependency_tables)
+        
+        query.where sentence.filter_condition
+      end
+
       private
 
       def chainable(&block)
@@ -122,6 +133,10 @@ module Rasti
         collection_class.queries.key?(method) || super
       end
 
+      def nql_parser
+        NQL::SyntaxParser.new
+      end
+
       attr_reader :collection_class, :dataset, :relations, :schema
 
     end

data/lib/rasti/db/relations/graph_builder.rb

@@ -14,7 +14,7 @@ module Rasti
           end
 
           def joins_to(dataset, relations, collection_class, schema=nil)
-            ds = recusrive_joins dataset, recursive_parse(relations), collection_class, schema
+            ds = recursive_joins dataset, recursive_parse(relations), collection_class, schema
             qualified_collection_name = schema ? Sequel[schema][collection_class.collection_name] : Sequel[collection_class.collection_name]
             ds.distinct.select_all(qualified_collection_name)
           end
@@ -41,13 +41,13 @@ module Rasti
             end
           end
 
-          def recusrive_joins(dataset, joins, collection_class, schema, prefix=nil)
+          def recursive_joins(dataset, joins, collection_class, schema, prefix=nil)
             joins.each do |relation_name, nested_joins|
               relation = get_relation collection_class, relation_name
 
               dataset = relation.join_to dataset, schema, prefix
 
-              dataset = recusrive_joins dataset, nested_joins, relation.target_collection_class, schema, relation.join_relation_name(prefix) unless nested_joins.empty?
+              dataset = recursive_joins dataset, nested_joins, relation.target_collection_class, schema, relation.join_relation_name(prefix) unless nested_joins.empty?
             end
 
             dataset

data/lib/rasti/db/version.rb

@@ -1,5 +1,5 @@
 module Rasti
   module DB
-    VERSION = '1.1.1'
+    VERSION = '1.2.0'
   end
 end

data/rasti-db.gemspec

@@ -19,13 +19,15 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['lib']
 
   spec.add_runtime_dependency 'sequel', '~> 5.0'
+  spec.add_runtime_dependency 'treetop', '~> 1.4.8'
   spec.add_runtime_dependency 'consty', '~> 1.0', '>= 1.0.3'
   spec.add_runtime_dependency 'timing', '~> 0.1', '>= 0.1.3'
   spec.add_runtime_dependency 'class_config', '~> 0.0', '>= 0.0.2'
+  spec.add_runtime_dependency 'multi_require', '~> 1.0'
 
   spec.add_development_dependency 'bundler', '~> 1.12'
   spec.add_development_dependency 'rake', '~> 11.0'
-  spec.add_development_dependency 'minitest', '~> 5.0'
+  spec.add_development_dependency 'minitest', '~> 5.0', '< 5.11'
   spec.add_development_dependency 'minitest-colorin', '~> 0.1'
   spec.add_development_dependency 'minitest-line', '~> 0.6'
   spec.add_development_dependency 'simplecov', '~> 0.12'

data/spec/coverage_helper.rb

@@ -2,4 +2,8 @@ require 'simplecov'
 require 'coveralls'
 
 SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new [SimpleCov::Formatter::HTMLFormatter, Coveralls::SimpleCov::Formatter]
-SimpleCov.start
+
+SimpleCov.start do
+  add_filter 'lib/rasti/db/nql/syntax.rb'
+  add_filter 'spec/'
+end

data/spec/nql/dependency_tables_spec.rb

@@ -0,0 +1,35 @@
+require 'minitest_helper'
+
+describe 'NQL::DepedencyTables' do
+
+  let(:parser) { Rasti::DB::NQL::SyntaxParser.new }
+
+  def parse(expression)
+    parser.parse expression
+  end
+
+  it 'must have no dependency tables' do
+    tree = parse 'column = 1'
+
+    tree.dependency_tables.must_be_empty
+  end
+
+  it 'must have one dependency table' do
+    tree = parse 'relation_table_one.relation_table_two.column = 1'
+
+    tree.dependency_tables.must_equal ['relation_table_one.relation_table_two']
+  end
+
+  it 'must have multiple dependency tables' do
+    tree = parse 'a.b.c = 1 & (d.e: 2 | f.g.h = 1) | i = 4'
+
+    tree.dependency_tables.must_equal ['a.b', 'd', 'f.g']
+  end
+
+  it 'must have repeated sub-dependency' do
+    tree = parse 'a.b.c = 1 & a.d: 2'
+
+    tree.dependency_tables.must_equal ['a.b', 'a']
+  end
+
+end

data/spec/nql/filter_condition_spec.rb

@@ -0,0 +1,146 @@
+require 'minitest_helper'
+
+describe 'NQL::FilterCondition' do
+
+  let(:parser) { Rasti::DB::NQL::SyntaxParser.new }
+
+  def filter_condition(expression)
+    tree = parser.parse expression
+    tree.filter_condition
+  end
+
+  def assert_identifier(identifier, expected_value)
+    identifier.must_be_instance_of Sequel::SQL::Identifier
+    identifier.value.must_equal expected_value
+  end
+
+  def assert_comparison(filter, expected_left, expected_comparator, expected_right)
+    filter.must_be_instance_of Sequel::SQL::BooleanExpression
+    filter.op.must_equal expected_comparator.to_sym
+    
+    left, right = filter.args
+    assert_identifier left, expected_left
+
+    right.must_equal expected_right
+  end
+
+  describe 'Comparison' do
+
+    it 'must create filter from expression with <' do
+      splitted_expression = ['column', '<', 1]
+
+      assert_comparison filter_condition(splitted_expression.join(' ')), *splitted_expression
+    end
+
+    it 'must create filter from expression with >' do
+      splitted_expression = ['column', '>', 1]
+
+      assert_comparison filter_condition(splitted_expression.join(' ')), *splitted_expression
+    end
+
+    it 'must create filter from expression with <=' do
+      splitted_expression = ['column', '<=', 1]
+
+      assert_comparison filter_condition(splitted_expression.join(' ')), *splitted_expression
+    end
+
+    it 'must create filter from expression with >=' do
+      splitted_expression = ['column', '>=', 1]
+
+      assert_comparison filter_condition(splitted_expression.join(' ')), *splitted_expression
+    end
+
+    it 'must create filter from expression with !=' do
+      splitted_expression = ['column', '!=', 1]
+
+      assert_comparison filter_condition(splitted_expression.join(' ')), *splitted_expression
+    end
+
+    it 'must create filter from expression with =' do
+      filter = filter_condition 'column = 1'
+      identifier, value = filter.first
+
+      assert_identifier identifier, 'column'
+      value.must_equal 1
+    end
+
+    it 'must create filter from expression with ~' do
+      filter = filter_condition 'column ~ test'
+      assert_comparison filter, 'column', 'ILIKE', 'test'
+    end
+
+    it 'must create filter from expression with :' do
+      filter = filter_condition 'column: test'
+      assert_comparison filter, 'column', 'ILIKE', '%test%'
+    end
+
+    it 'must create filter from expression with !:' do
+      filter = filter_condition 'column!: test'
+      assert_comparison filter, 'column', 'NOT ILIKE', '%test%'
+    end
+
+  end
+
+  describe 'Constants' do
+
+    it 'must create filter from expression with LiteralString' do
+      filter = filter_condition 'column: "test "'
+      assert_comparison filter, 'column', 'ILIKE', '%test %'
+    end
+
+    it 'must create filter from expression with Time' do
+      filter = filter_condition 'column > 2019-03-27T12:20:00-03:00'
+      assert_comparison filter, 'column', '>', '2019-03-27 12:20:00 -0300'
+    end
+
+  end
+
+  it 'must create filter from expression with field with multiple tables' do
+    filter = filter_condition 'table_one.table_two.column = test'
+    identifier, value = filter.first
+
+    identifier.must_be_instance_of Sequel::SQL::QualifiedIdentifier
+    identifier.table.must_equal 'table_one__table_two'
+    identifier.column.must_equal :column
+    value.must_equal 'test'
+  end
+
+  it 'must create filter from expression with conjunction' do
+    filter = filter_condition 'column_one > 1 & column_two < 3'
+
+    filter.must_be_instance_of Sequel::SQL::BooleanExpression
+    filter.op.must_equal :AND
+    major_expression, minor_expression = filter.args
+
+    assert_comparison major_expression, 'column_one', '>', 1
+    assert_comparison minor_expression, 'column_two', '<', 3
+  end
+
+  it 'must create filter from expression with disjunction' do
+    filter = filter_condition 'column_one > 1 | column_two != 3'
+
+    filter.must_be_instance_of Sequel::SQL::BooleanExpression
+    filter.op.must_equal :OR
+    major_expression, not_equal_expression = filter.args
+
+    assert_comparison major_expression, 'column_one', '>', 1
+    assert_comparison not_equal_expression, 'column_two', '!=', 3
+  end
+
+  it 'must create filter from expression with parenthesis' do
+    filter = filter_condition 'column_one > 1 & (column_two != 3 | column_three < 5)'
+
+    filter.must_be_instance_of Sequel::SQL::BooleanExpression
+    filter.op.must_equal :AND
+    
+    major_expression, and_expression = filter.args
+    assert_comparison major_expression, 'column_one', '>', 1
+
+    and_expression.op.must_equal :OR
+    not_equal_expression, minor_expression = and_expression.args
+
+    assert_comparison not_equal_expression, 'column_two', '!=', 3
+    assert_comparison minor_expression, 'column_three', '<', 5
+  end
+
+end

data/spec/nql/syntax_parser_spec.rb

@@ -0,0 +1,209 @@
+require 'minitest_helper'
+
+describe 'NQL::SyntaxParser' do
+
+  let(:parser) { Rasti::DB::NQL::SyntaxParser.new }
+
+  def parse(expression)
+    parser.parse(expression).tap do |tree|
+      tree.wont_be_nil
+    end
+  end
+
+  describe 'Comparison' do
+
+    describe 'Comparators' do
+      
+      {
+        '='  => Rasti::DB::NQL::Nodes::Comparisons::Equal,
+        '!=' => Rasti::DB::NQL::Nodes::Comparisons::NotEqual,
+        '>'  => Rasti::DB::NQL::Nodes::Comparisons::GreaterThan,
+        '>=' => Rasti::DB::NQL::Nodes::Comparisons::GreaterThanOrEqual,
+        '<'  => Rasti::DB::NQL::Nodes::Comparisons::LessThan,
+        '<=' => Rasti::DB::NQL::Nodes::Comparisons::LessThanOrEqual,
+        '~'  => Rasti::DB::NQL::Nodes::Comparisons::Like,
+        ':'  => Rasti::DB::NQL::Nodes::Comparisons::Include,
+        '!:' => Rasti::DB::NQL::Nodes::Comparisons::NotInclude
+      }.each do |comparator, node_class|
+        it "must parse expression with '#{comparator}'" do
+          tree = parse "column #{comparator} value"
+
+          proposition = tree.proposition
+          proposition.must_be_instance_of node_class
+          proposition.comparator.text_value.must_equal comparator
+          proposition.field.text_value.must_equal 'column'
+          proposition.argument.text_value.must_equal 'value'
+        end
+      end
+
+    end
+
+    it "must parse expression without spaces between elements" do
+      tree = parse 'column=value'
+
+      proposition = tree.proposition
+      proposition.must_be_instance_of Rasti::DB::NQL::Nodes::Comparisons::Equal
+      proposition.comparator.text_value.must_equal '='
+      proposition.field.text_value.must_equal 'column'
+      proposition.argument.text_value.must_equal 'value'
+    end
+
+    describe 'Right hand Operand' do
+
+      it 'must parse expression with integer' do
+        tree = parse 'column = 1'
+
+        right_hand_operand = tree.proposition.argument
+        right_hand_operand.must_be_instance_of Rasti::DB::NQL::Nodes::Constants::Integer
+        right_hand_operand.value.must_equal 1
+      end
+
+      it 'must parse expression with float' do
+        tree = parse 'column = 2.3'
+
+        right_hand_operand = tree.proposition.argument
+        right_hand_operand.must_be_instance_of Rasti::DB::NQL::Nodes::Constants::Float
+        right_hand_operand.value.must_equal 2.3
+      end
+
+      it 'must parse expression with true' do
+        tree = parse 'column = true'
+
+        right_hand_operand = tree.proposition.argument
+        right_hand_operand.must_be_instance_of Rasti::DB::NQL::Nodes::Constants::True
+        right_hand_operand.value.must_equal true
+      end
+
+      it 'must parse expression with false' do
+        tree = parse 'column = false'
+
+        right_hand_operand = tree.proposition.argument
+        right_hand_operand.must_be_instance_of Rasti::DB::NQL::Nodes::Constants::False
+        right_hand_operand.value.must_equal false
+      end
+
+      it 'must parse expression with string' do
+        tree = parse 'column = String1 '
+
+        right_hand_operand = tree.proposition.argument
+        right_hand_operand.must_be_instance_of Rasti::DB::NQL::Nodes::Constants::String
+        right_hand_operand.value.must_equal 'String1'
+      end
+
+      it 'must parse expression with literal string' do
+        tree = parse 'column = "a & (b | c) | d:=e"'
+
+        right_hand_operand = tree.proposition.argument
+        right_hand_operand.must_be_instance_of Rasti::DB::NQL::Nodes::Constants::LiteralString
+        right_hand_operand.value.must_equal 'a & (b | c) | d:=e'
+      end
+
+      describe 'Time' do
+
+        it 'must parse expression with hours and minutes' do
+          tree = parse 'column > 12:20'
+
+          right_hand_operand = tree.proposition.argument
+          right_hand_operand.must_be_instance_of Rasti::DB::NQL::Nodes::Constants::Time
+          right_hand_operand.value.must_equal Timing::TimeInZone.parse('12:20').to_s
+        end
+
+        it 'must parse expression with date, hours, minutes and seconds' do
+          tree = parse 'column > 2019-03-27T12:20:00'
+
+          right_hand_operand = tree.proposition.argument
+          right_hand_operand.must_be_instance_of Rasti::DB::NQL::Nodes::Constants::Time
+          right_hand_operand.value.must_equal Timing::TimeInZone.parse('2019-03-27T12:20:00').to_s
+        end
+
+        it 'must parse expression with date, hours, minutes, seconds and timezone' do
+          tree = parse 'column > 2019-03-27T12:20:00-03:00'
+
+          right_hand_operand = tree.proposition.argument
+          right_hand_operand.must_be_instance_of Rasti::DB::NQL::Nodes::Constants::Time
+          right_hand_operand.value.must_equal Timing::TimeInZone.parse('2019-03-27T12:20:00-03:00').to_s
+        end
+
+      end
+    
+    end
+
+    it 'must parse expression with field with tables' do
+      tree = parse 'relation_table_one.relation_table_two.column = 1'
+
+      left_hand_operand = tree.proposition.field
+      left_hand_operand.tables.must_equal ['relation_table_one', 'relation_table_two']
+      left_hand_operand.column.must_equal 'column'
+    end
+
+  end
+
+  describe 'Parenthesis Sentence' do
+    
+    it 'must parse parenthesis comparison' do
+      tree = parse '(column: name)'
+
+      tree.proposition.sentence.text_value.must_equal 'column: name'
+    end
+
+    it 'must parse conjunction over parenthesis of disjunction' do
+      tree = parse '(column_one: 1 | column_two: two) & column_three: 3.0'
+
+      tree.proposition.must_be_instance_of Rasti::DB::NQL::Nodes::Conjunction
+      tree.proposition.left.sentence.text_value.must_equal 'column_one: 1 | column_two: two'
+    end
+
+  end
+
+
+  describe 'Conjunction' do
+
+    def parse_and_assert(expression, conjunction_values)
+      tree = parse expression
+      
+      tree.proposition.must_be_instance_of Rasti::DB::NQL::Nodes::Conjunction
+      tree.proposition.values.map(&:text_value).zip(conjunction_values).each do |actual, expected|
+        actual.must_equal expected
+      end
+    end
+
+    it 'must parse conjunction of two comparisons' do
+      parse_and_assert 'column_one != 1 & column_two: name', ['column_one != 1', 'column_two: name']
+    end
+
+    it 'must parse multiple conjunctions' do
+      parse_and_assert 'column_one > 1 & column_two: name & column_three < 9.2', ['column_one > 1', 'column_two: name ', 'column_three < 9.2']
+    end
+
+    it 'must parse conjunction with parenthesis expression' do
+      parse_and_assert '(column_one > 1 | column_two: name) & column_three < 9.2', ['(column_one > 1 | column_two: name)', 'column_three < 9.2']
+    end
+
+  end
+
+  describe 'Disjunction' do
+
+    def parse_and_assert(expression, disjunction_values)
+      tree = parse expression
+      
+      tree.proposition.must_be_instance_of Rasti::DB::NQL::Nodes::Disjunction
+      tree.proposition.values.map(&:text_value).zip(disjunction_values).each do |actual, expected|
+        actual.must_equal expected
+      end
+    end
+
+    it 'must parse disjunction of two disjunctions' do
+      parse_and_assert 'column_one != 1 | column_two: name', ['column_one != 1', 'column_two: name'] 
+    end
+
+    it 'must parse disjunction over conjunction' do
+      parse_and_assert 'column_one != 1 & column_two: name | column_three < 1.2', ['column_one != 1 & column_two: name ', 'column_three < 1.2'] 
+    end
+
+    it 'must parse multiple conjunctions' do
+      parse_and_assert 'column_one != 1 | column_two: name | column_three < 1.2', ['column_one != 1', 'column_two: name ', 'column_three < 1.2']
+    end
+
+  end
+
+end