sql_query_executor 0.0.1 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 301d82d53d8664ca2e4b46b6aa81122f1655f952
-  data.tar.gz: 42279647376f6eb18b54859ab3f05e83f116c43c
+  metadata.gz: d35ed6525f34f2fa2b89077179627bb398e60569
+  data.tar.gz: d7f5b1378fe6932180ed501143f8282620b36ee1
 SHA512:
-  metadata.gz: be871658094f765273a205e33e4b48f716510c808bd6a4873566ef573eccd74fb5019dfbfbd3d3cf7a2b7cd5f10767a3de6c0c0db26502ef54f59e92256326c7
-  data.tar.gz: e30f7282a53341b69b625346bbb34d1b93e861771317b5395f718ec880bb94ed0e531da6fa35d01d3c573bec7e4822dff41c740bbee7b68281bd6cac88cd1019
+  metadata.gz: 17f7149a30b187f41262d8dfe826cf3a100400764aea984b5783cb440f9874b356038574ee5a16e9dd0e7f87d24c40e2085dad37ead3fe0f23db9f23fe8971b5
+  data.tar.gz: 407df8d2c2a114b9979b17f7249bfcf9698a04b317087a59b3199e9cda64bcb2fa58e74657069c76190954bc80b6cba1cc2f97a2e6e8f9e23047629724358ece

data/lib/sql_query_executor/operators/base.rb

@@ -2,7 +2,7 @@ module SqlQueryExecutor
   module Operators
     class Base
       def initialize(query, collection)
-        @query      = query
+        @query      = sanitize_query(query)
         @collection = collection
         @array      = query.split(' ')
         @operator   = @query.split(' ')[1]
@@ -16,31 +16,57 @@ module SqlQueryExecutor
       end
 
       def get_value
-        value = @array.last.gsub('$S$', ' ')
+        value = @array.last.gsub(::SqlQueryExecutor::Query::Base::STRING_SPACE, ' ')
 
         convert_value(value)
       end
 
       def convert_value(value)
-        array = []
-
-        if value.size >= 10
-          array = value.split(/ |:/)
-          array[0] = array.first.split('-')
-          array = array.flatten
-        end
-
-        if (value.to_i.to_s == value.to_s)
-          return value.to_i
-        elsif array.size == 3
-          return array.first.to_i > 1000 ? Date.new(array[0].to_i, array[1].to_i, array[2].to_i) : value
-        elsif array.size == 7
-          array[6] = array[6] == '+0000' ? '+00:00' : array[6].gsub('00', ':00')
-          return array.first.to_i > 1000 ? Time.new(*array) : value
-        end
+        value.gsub!(/[\(\)\'\"]/, "")
+        return value.to_i if is_a_number?(value)
+
+        methods = {3 => "convert_date", 7 => "convert_time"}
+
+        array = split(value)
+  
+        value = (send(methods[array.size], array) || value) if methods.keys.include?(array.size)
 
         value
       end
+
+    private
+      def sanitize_query(query)
+        params = query.scan(/(\(.*?\))/).flatten.compact
+
+        params.each { |param| query.gsub!(param, param.gsub(" ", "")) }
+
+        query
+      end
+
+      def is_a_number?(value)
+        value.to_s == value.to_i.to_s
+      end
+
+      def split(value)
+        return [] unless value.size >= 10
+
+        array = value.split(/[ :]/)
+        array[0] = array.first.split('-')
+        array.flatten
+      end
+
+      def convert_date(args)
+        return if args.first.to_i < 1000
+        
+        Date.new(args[0].to_i, args[1].to_i, args[2].to_i)
+      end
+
+      def convert_time(args)
+        return if args.first.to_i < 1000
+        args[6] = args[6].gsub('00', ':00').gsub("+:", "+")
+        
+        Time.new(*args)
+      end
     end
   end
 end

data/lib/sql_query_executor/operators/between.rb

@@ -3,7 +3,7 @@ require 'sql_query_executor/operators/base'
 module SqlQueryExecutor
   module Operators
     class Between < SqlQueryExecutor::Operators::Base
-      def execute!
+      def execute!(result)
         @collection.select do |record|
           value = convert_value(record.send(@field).to_s)
 
@@ -22,8 +22,8 @@ module SqlQueryExecutor
       def get_value
         value = []
 
-        value << convert_value(@array[2].gsub('$S$', ' '))
-        value << convert_value(@array[4].gsub('$S$', ' '))
+        value << convert_value(@array[2].gsub(SqlQueryExecutor::Query::Base::STRING_SPACE, ' '))
+        value << convert_value(@array[4].gsub(SqlQueryExecutor::Query::Base::STRING_SPACE, ' '))
       end
     end
   end

data/lib/sql_query_executor/operators/default.rb

@@ -8,7 +8,7 @@ module SqlQueryExecutor
         convert_operator
       end
 
-      def execute!
+      def execute!(result)
         @collection.select do |record|
           value = record.send(@field.to_s)
 

data/lib/sql_query_executor/operators/in.rb

@@ -3,8 +3,8 @@ require 'sql_query_executor/operators/base'
 module SqlQueryExecutor
   module Operators
     class In < SqlQueryExecutor::Operators::Base
-      def execute!
-        @collection.select do |record|
+      def execute!(result)
+        result = @collection.select do |record|
           value = record.send(@field)
 
           @value.send('include?', value)
@@ -15,7 +15,7 @@ module SqlQueryExecutor
       def get_value
         value = super
 
-        value.gsub('$S$', '').split(',').map &:strip
+        value.gsub(SqlQueryExecutor::Query::Base::STRING_SPACE, '').split(',').map &:strip
       end
     end
   end

data/lib/sql_query_executor/operators/is.rb

@@ -8,7 +8,7 @@ module SqlQueryExecutor
         convert_operator
       end
 
-      def execute!
+      def execute!(result)
         @collection.select do |record|
           value = record.send(@field)
 

data/lib/sql_query_executor/query/base.rb

@@ -1,23 +1,23 @@
-require 'sql_query_executor/query/executor'
-
 module SqlQueryExecutor
   module Query
     class Base
       attr_reader :query
 
       CONVERT_METHODS = {"String" => ["get_query", ""], "Array" => ["interpolate_query", "query.flatten"], "Hash" => ["concatenate_hash", "query"]}
+      STRING_SPACE = "$SS$"
+      QUERY_SPACE  = "$QS$"
+      TEMP_SPACE  = "$TS$"
 
       def initialize(query, collection)
         query = clean_query_attribute(query)
         array = CONVERT_METHODS[query.class.name]
 
-        @query      = send(array.first, query)
-        @collection = collection
-        sanitize
+        query = sanitize(send(array.first, query))
+        @query = SqlQueryExecutor::Query::SubQuery.new query, collection
       end
 
       def execute!
-        SqlQueryExecutor::Query::Executor.execute!(@query, @collection)
+        @query.execute!
       end
 
     private
@@ -43,34 +43,45 @@ module SqlQueryExecutor
 
         param = convert_param(param)
 
-        args[0] = query.sub("?", param)
+        args[0] = query.sub("?", param.is_a?(Numeric) ? param : "#{param}")
 
         interpolate_query(args)
       end
 
       # Removes all accents and other non default characters
-      def sanitize
+      def sanitize(query)
         cruft = /\'|\"|\(|\)/
 
-        new_query = @query ? @query.dup : @query
-        params = new_query.scan(/(["|'].*?["|'])|(\(.*?\))/).flatten.compact
+        new_query = query ? query.dup : query
+        params = new_query.scan(/(["|'].*?["|'])/).flatten.compact
+
+        params.each do |param|
+          new_param = param.dup
+
+          new_param = new_param.gsub(" ", STRING_SPACE)
+
+          new_query = new_query.gsub(param, new_param)
+        end
+
+        
+        params = new_query.scan(/(\(.*?\))/).flatten.compact
 
         params.each do |param|
           new_param = param.dup
 
-          new_param = new_param.gsub(cruft,"")
-          new_param = new_param.gsub(" ", "$S$")
+          new_param = new_param.gsub(" ", QUERY_SPACE)
 
           new_query = new_query.gsub(param, new_param)
         end
 
-        @query = new_query
+        query = new_query.gsub(" and ", "#{TEMP_SPACE}and#{QUERY_SPACE}").gsub(" or ", "#{TEMP_SPACE}or#{QUERY_SPACE}").gsub(" ", QUERY_SPACE).gsub(TEMP_SPACE, " ")
 
-        remove_spaces
+        remove_spaces(query)
       end
 
-      def remove_spaces
-        @query.gsub!(/\[.*?\]/) { |substr| substr.gsub(' ', '') }
+      def remove_spaces(query)
+        query.gsub!(/\[.*?\]/) { |substr| substr.gsub(' ', '') }
+        query
       end
 
       # Returns converted #param based on its Class, so it can be used on the query
@@ -93,8 +104,10 @@ module SqlQueryExecutor
 
         query.each do |key, value|
           if value.is_a?(Array)
+            value = value.first.is_a?(Numeric) ? value : value.map{ |v| "'#{v}'" }
             query_array << "#{key} in (#{value.join(',')})"
           else
+            value = value.is_a?(Numeric) ? value : "'#{value}'"
             query_array << "#{key} = #{value}"
           end
         end

data/lib/sql_query_executor/query/sentence.rb

@@ -0,0 +1,70 @@
+require 'sql_query_executor/operators/default'
+require 'sql_query_executor/operators/between'
+require 'sql_query_executor/operators/is'
+require 'sql_query_executor/operators/in'
+
+module SqlQueryExecutor
+  module Query
+    class Sentence
+      attr_reader :query, :binding_operator, :operator
+
+      OPERATORS = {
+        "between" => SqlQueryExecutor::Operators::Between,
+        "is"      => SqlQueryExecutor::Operators::Is,
+        "in"      => SqlQueryExecutor::Operators::In,
+        "="       => SqlQueryExecutor::Operators::Default,
+        ">"       => SqlQueryExecutor::Operators::Default,
+        "<"       => SqlQueryExecutor::Operators::Default,
+        ">="      => SqlQueryExecutor::Operators::Default,
+        "<="      => SqlQueryExecutor::Operators::Default,
+        "<>"      => SqlQueryExecutor::Operators::Default,
+        "!="      => SqlQueryExecutor::Operators::Default,
+        "not"     => SqlQueryExecutor::Operators::Default,
+        "exists"  => SqlQueryExecutor::Operators::Default,#Exists
+      }
+
+      BINDING_OPERATORS = {
+        "and" => "&",
+        "or"  => "+"
+      }
+
+      def initialize(query, collection)
+        @query    = query
+        @collection = collection
+        @array = query.split(' ')
+
+        set_binding_operator
+        set_operator
+      end
+
+      def execute!(data)
+        return [] unless @operator
+
+        result = @operator.execute!(data)
+
+        result = data.send(@binding_operator, result) if @binding_operator && (data && !data.empty?)
+
+        result
+      end
+
+    private
+      def set_operator
+        operator = OPERATORS[@query.split(' ')[1]]
+
+        @operator = operator ? operator.new(@query, @collection) : nil
+      end
+
+      def set_binding_operator
+        @binding_operator = BINDING_OPERATORS[@array.first]
+
+        fix_query if @binding_operator
+      end
+
+      def fix_query
+        @array.delete_at(0) 
+
+        @query = @array.join(' ')
+      end
+    end
+  end
+end

data/lib/sql_query_executor/query/sub_query.rb

@@ -1,67 +1,126 @@
-require 'sql_query_executor/operators/default'
-require 'sql_query_executor/operators/between'
-require 'sql_query_executor/operators/is'
-require 'sql_query_executor/operators/in'
-
 module SqlQueryExecutor
   module Query
     class SubQuery
-      OPERATORS = {
-        "between" => SqlQueryExecutor::Operators::Between,
-        "is"      => SqlQueryExecutor::Operators::Is,
-        "in"      => SqlQueryExecutor::Operators::In,
-        "="       => SqlQueryExecutor::Operators::Default,
-        ">"       => SqlQueryExecutor::Operators::Default,
-        "<"       => SqlQueryExecutor::Operators::Default,
-        ">="      => SqlQueryExecutor::Operators::Default,
-        "<="      => SqlQueryExecutor::Operators::Default,
-        "<>"      => SqlQueryExecutor::Operators::Default,
-        "!="      => SqlQueryExecutor::Operators::Default,
-        "not"     => SqlQueryExecutor::Operators::Default,
-        "exists"  => SqlQueryExecutor::Operators::Default,#Exists
-      }
-
-      BINDING_OPERATORS = {
-        "and" => "&",
-        "or"  => "+"
-      }
-
+      BINDING_OPERATORS = { "or" => "+", "and" => "&" }
+      attr_reader :query, :children, :kind
+      ADD_CHILDREN_METHODS = { sentence: :add_sentence_children, sub_query: :add_sub_query_children }
       def initialize(query, collection)
-        @query    = query
         @collection = collection
-        @array = query.split(' ')
-
+        @query      = query
+        @children   = []
         set_binding_operator
-        set_operator
+        set_kind
+        set_children
       end
 
-      def execute!(data)
-        return [] unless @operator
+      def execute!(data=[])
+        return [] unless @children
+
+        result = []
 
-        result = @operator.execute!
+        @children.each do |child|
+          result = child.execute!(result)
+        end
 
         result = data.send(@binding_operator, result) if @binding_operator && (data && !data.empty?)
 
-        result
+        result.sort_by(&:id)
       end
 
     private
-      def set_operator
-        operator = OPERATORS[@query.split(' ')[1]]
+      def set_binding_operator
+        @binding_operator = nil
+        operator = @query.split(Base::QUERY_SPACE).first
 
-        @operator = operator ? operator.new(@query, @collection) : nil
+        if ["and", "or"].include?(operator)
+          @binding_operator =  BINDING_OPERATORS[operator]
+          @query = @query.gsub("#{operator}$QS$", "")
+        end
       end
 
-      def set_binding_operator
-        @binding_operator = BINDING_OPERATORS[@array.first]
+      def set_kind
+        @kind = is_single_query? ? :sentence : :sub_query
+      end
+
+      def set_children
+        send(ADD_CHILDREN_METHODS[@kind])
+      end
+
+      def add_sentence_children
+        @children << SqlQueryExecutor::Query::Sentence.new(@query.gsub(Base::QUERY_SPACE, " "), @collection)
+      end
+
+      def add_sub_query_children
+        array = @query.split(" ")
+        queries = []
+
+        array.each do |query|
+          sanitized_query = replace_parentheses(query)
+          params = sanitized_query.scan(/\$op1\$(\S+)\$cp1\$/).flatten.compact
+
+          params.each do |param|
+            string = param.gsub("$QS$and$QS$", " and$QS$").gsub("$QS$or$QS$", " or$QS$")
+            query = sanitized_query.gsub(param, string)
+          end
 
-        fix_query if @binding_operator
+          query = query.gsub("\$op1\$", "").gsub("\$cp1\$", "").gsub(/\$\Sp\d\$/, "")
+
+          @children << SqlQueryExecutor::Query::SubQuery.new(query, @collection)
+        end
+      end
+
+      def is_single_query?
+        array = @query.gsub(Base::QUERY_SPACE, ' ').split(' ')
+
+        array.size <= 5
+      end
+
+      def build_sub_query(query)
+        array = query.split(" ")
+
+        offset = is_binding_operator?(array.first) ? 1 : 0
+        operator = array[1+offset]
+
+        result = case operator
+        when "between"
+          array[0..4+offset]
+        when "is"
+          size = array[2+offset] == "not" ? 3 : 2
+          array[0..size+offset]
+        when "not"
+          array[0..3+offset]
+        else
+          array[0..2+offset]
+        end
+
+        result.join(' ')
+      end
+
+      def is_binding_operator?(operator)
+        BINDING_OPERATORS.include?(operator)
       end
 
-      def fix_query
-        @array.delete_at(0) 
+      def replace_parentheses(query)
+        count = 1
+        string = ""
+
+        query.each_char do |c|
+          char = c
+          
+          if c == "("
+            char = "$op#{count}$"
+            count += 1
+          end
+
+          if c == ")"
+            count -= 1
+            char = "$cp#{count}$"
+          end
+
+          string << char
+        end
 
-        @query = @array.join(' ')
+        string
       end
     end
   end

data/lib/sql_query_executor/{version → version.rb}

@@ -1,3 +1,3 @@
 module SqlQueryExecutor
-  VERSION = "0.0.1"
+  VERSION = "0.1.0"
 end

data/spec/sql_query_executor/base_spec.rb

@@ -6,11 +6,11 @@ describe SqlQueryExecutor, "Base" do
   before do
     @data = []
 
-    @data << {:id => 1, :name => "US",     :language => 'English'}
-    @data << {:id => 2, :name => "Canada", :language => 'English', :monarch => "The Crown of England"}
-    @data << {:id => 3, :name => "Mexico", :language => 'Spanish'}
-    @data << {:id => 4, :name => "UK",     :language => 'English', :monarch => "The Crown of England"}
-    @data << {:id => 5, :name => "Brazil", :founded_at => Time.parse('1500-04-22 13:34:25')}
+    @data << {id: 1, name: "US",     language: 'English'}
+    @data << {id: 2, name: "Canada", language: 'English', monarch: "The Crown of England"}
+    @data << {id: 3, name: "Mexico", language: 'Spanish'}
+    @data << {id: 4, name: "UK",     language: 'English', monarch: "The Crown of England"}
+    @data << {id: 5, name: "Brazil", founded_at: Time.parse('1500-04-22 13:34:25')}
   end
 
   subject { SqlQueryExecutor::Base.new(@data) }
@@ -413,6 +413,32 @@ describe SqlQueryExecutor, "Base" do
 
         records.should == [@data[0], @data[1], @data[2], @data[3]]
       end
+
+      context "nested queries" do
+        it "respects priority" do
+          records = subject.where("(language = 'English' and name = 'US') or (language is null)")
+          records.count.should == 2
+          records.first.id.should == 1
+
+          records.map! do |record|
+            record.to_h
+          end
+
+          records.should == [@data[0], @data[4]]
+        end
+
+        it "respects priority" do
+          records = subject.where("(language is null) or (language = 'English' and name = 'US')")
+          records.count.should == 2
+          records.first.id.should == 1
+
+          records.map! do |record|
+            record.to_h
+          end
+
+          records.should == [@data[0], @data[4]]
+        end
+      end
     end
 
     describe "in" do
@@ -427,6 +453,18 @@ describe SqlQueryExecutor, "Base" do
 
         records.should == [@data[0], @data[1], @data[2], @data[3]]
       end
+
+      xit "attribute not in condition" do
+        records = subject.where("language not in ('English', 'Spanish')")
+        records.count.should == 1
+        records.first.id.should == 5
+
+        records.map! do |record|
+          record.to_h
+        end
+
+        records.should == [@data[4]]
+      end
     end
 
     describe "not" do

data/sql_query_executor.gemspec

@@ -1,18 +1,18 @@
 # -*- encoding: utf-8 -*-
-# require File.expand_path('../lib/sql_query_executor/version', __FILE__)
+require File.expand_path('../lib/sql_query_executor/version.rb', __FILE__)
 
 Gem::Specification.new do |gem|
   gem.authors       = ["Caio Torres"]
   gem.email         = ["efreesen@gmail.com"]
-  gem.description   = %q{Gem to run SQL like queries on array of hashes}
-  gem.summary       = %q{With SqlQueryExecutor you can run SQL like queries on any array of hashes}
+  gem.description   = %q{Gem to run SQL like queries on array of hashes or similar objects}
+  gem.summary       = %q{With SqlQueryExecutor you can run SQL like queries on any array of hashes or similar objects}
   gem.homepage      = "http://github.com/efreesen/sql_query_executor"
 
   gem.files         = `git ls-files`.split($\)
   gem.test_files    = gem.files.grep(%r{^(spec)/})
   gem.name          = "sql_query_executor"
   gem.require_paths = ["lib"]
-  gem.version       = '0.0.1'
+  gem.version       = SqlQueryExecutor::VERSION
   gem.license       = "GPLv2"
   gem.files         = [
     "LICENSE",

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: sql_query_executor
 version: !ruby/object:Gem::Version
-  version: 0.0.1
+  version: 0.1.0
 platform: ruby
 authors:
 - Caio Torres
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2014-01-18 00:00:00.000000000 Z
+date: 2014-02-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rspec
@@ -52,7 +52,7 @@ dependencies:
     - - '>='
       - !ruby/object:Gem::Version
         version: '0'
-description: Gem to run SQL like queries on array of hashes
+description: Gem to run SQL like queries on array of hashes or similar objects
 email:
 - efreesen@gmail.com
 executables: []
@@ -69,10 +69,9 @@ files:
 - lib/sql_query_executor/operators/in.rb
 - lib/sql_query_executor/operators/is.rb
 - lib/sql_query_executor/query/base.rb
-- lib/sql_query_executor/query/divider.rb
-- lib/sql_query_executor/query/executor.rb
+- lib/sql_query_executor/query/sentence.rb
 - lib/sql_query_executor/query/sub_query.rb
-- lib/sql_query_executor/version
+- lib/sql_query_executor/version.rb
 - lib/sql_query_executor.rb
 - Gemfile
 - spec/sql_query_executor/base_spec.rb
@@ -100,6 +99,7 @@ rubygems_version: 2.0.14
 signing_key: 
 specification_version: 4
 summary: With SqlQueryExecutor you can run SQL like queries on any array of hashes
+  or similar objects
 test_files:
 - Gemfile
 - spec/sql_query_executor/base_spec.rb

data/lib/sql_query_executor/query/divider.rb

@@ -1,56 +0,0 @@
-require 'sql_query_executor/query/sub_query'
-
-module SqlQueryExecutor
-  module Query
-    class Divider
-      BINDING_OPERATORS = ['and', 'or']
-
-      class << self
-        def divide(query, collection)
-          @query = query
-          divide_query(collection)
-        end
-
-      private
-        # Splits the first sub query from the rest of the query and returns it.
-        def divide_query(collection)
-          array = @query.split(" ")
-          operator = array[1].downcase
-
-          sub_query = get_sub_array(operator, array)
-          remaining_query = @query.gsub(sub_query, '').strip
-
-          sub_query = SqlQueryExecutor::Query::SubQuery.new(sub_query, collection)
-
-          return sub_query, remaining_query == '' ? nil : remaining_query
-        end
-
-        def get_sub_array(operator, array)
-          result = case operator
-          when "between"
-            array[0..4]
-          when "is"
-            size = array[2] == "not" ? 3 : 2
-            array[0..size]
-          when "not"
-            array[0..3]
-          else
-            array[0..2]
-          end
-
-          result = fix_array(array, result)
-
-          result.join(' ')
-        end
-
-        def fix_array(array, result)
-          if BINDING_OPERATORS.include?(result.first)
-            array[0..result.size]
-          else
-            result
-          end
-        end
-      end
-    end
-  end
-end

data/lib/sql_query_executor/query/executor.rb

@@ -1,17 +0,0 @@
-require 'sql_query_executor/query/divider'
-
-module SqlQueryExecutor
-  module Query
-    class Executor
-      class << self
-        def execute!(query, collection, data=[])
-          sub_query, remaining_query = SqlQueryExecutor::Query::Divider.divide(query, collection)
-
-          result = sub_query.execute!(data)
-
-          remaining_query.nil? ? result.sort_by{ |r| r.id } : execute!(remaining_query, collection, result)
-        end
-      end
-    end
-  end
-end