sql_query_executor 0.0.1

data/lib/sql_query_executor/operators/default.rb

@@ -0,0 +1,26 @@
+require 'sql_query_executor/operators/base'
+
+module SqlQueryExecutor
+  module Operators
+    class Default < SqlQueryExecutor::Operators::Base
+      def initialize(query, collection)
+        super
+        convert_operator
+      end
+
+      def execute!
+        @collection.select do |record|
+          value = record.send(@field.to_s)
+
+          value.send(@operator, @value) rescue false
+        end
+      end
+
+    private
+      def convert_operator
+        @operator = @operator == "="  ? "==" : @operator
+        @operator = @operator == "<>" ? "!=" : @operator
+      end
+    end
+  end
+end

data/lib/sql_query_executor/operators/in.rb

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

data/lib/sql_query_executor/operators/is.rb

@@ -0,0 +1,29 @@
+require 'sql_query_executor/operators/base'
+
+module SqlQueryExecutor
+  module Operators
+    class Is < SqlQueryExecutor::Operators::Base
+      def initialize(query, collection)
+        super
+        convert_operator
+      end
+
+      def execute!
+        @collection.select do |record|
+          value = record.send(@field)
+
+          value.send(@operator, nil)
+        end
+      end
+
+    private
+      def get_value
+        @array.include?('null') ? 'nil' : @array.last
+      end
+
+      def convert_operator
+        @operator = @array.include?('not') ? '!=' : '=='
+      end
+    end
+  end
+end

data/lib/sql_query_executor/query/base.rb

@@ -0,0 +1,106 @@
+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"]}
+
+      def initialize(query, collection)
+        query = clean_query_attribute(query)
+        array = CONVERT_METHODS[query.class.name]
+
+        @query      = send(array.first, query)
+        @collection = collection
+        sanitize
+      end
+
+      def execute!
+        SqlQueryExecutor::Query::Executor.execute!(@query, @collection)
+      end
+
+    private
+      def clean_query_attribute(query)
+        return query unless query.is_a?(Array)
+
+        query = query.flatten
+
+        query.size == 1 ? query.first : query
+      end
+
+      def get_query(query)
+        query
+      end
+
+      # Prepares query by replacing all ? by it's real values in #args
+      def interpolate_query(args)
+        args.flatten!
+        return args.first if args.size == 1 && args.first.is_a?(String)
+
+        query = args.first
+        param = args.delete_at(1)
+
+        param = convert_param(param)
+
+        args[0] = query.sub("?", param)
+
+        interpolate_query(args)
+      end
+
+      # Removes all accents and other non default characters
+      def sanitize
+        cruft = /\'|\"|\(|\)/
+
+        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(cruft,"")
+          new_param = new_param.gsub(" ", "$S$")
+
+          new_query = new_query.gsub(param, new_param)
+        end
+
+        @query = new_query
+
+        remove_spaces
+      end
+
+      def remove_spaces
+        @query.gsub!(/\[.*?\]/) { |substr| substr.gsub(' ', '') }
+      end
+
+      # Returns converted #param based on its Class, so it can be used on the query
+      def convert_param(param)
+        case param.class.name
+        when "String"
+          param = "'#{param}'"
+        when "Date"
+          param = "'#{param.strftime("%Y-%m-%d")}'"
+        when "Time"
+          param = "'#{param.strftime("%Y-%m-%d %H:%M:%S %z")}'"
+        else
+          param = param.to_s
+        end
+      end
+
+      def concatenate_hash(query)
+        return "" unless query.is_a?(Hash)
+        query_array = []
+
+        query.each do |key, value|
+          if value.is_a?(Array)
+            query_array << "#{key} in (#{value.join(',')})"
+          else
+            query_array << "#{key} = #{value}"
+          end
+        end
+
+        query_array.join(" and ")
+      end
+    end
+  end
+end

data/lib/sql_query_executor/query/divider.rb

@@ -0,0 +1,56 @@
+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

@@ -0,0 +1,17 @@
+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

data/lib/sql_query_executor/query/sub_query.rb

@@ -0,0 +1,68 @@
+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"  => "+"
+      }
+
+      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!
+
+        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/version

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

data/spec/sql_query_executor/base_spec.rb

@@ -0,0 +1,446 @@
+require 'spec_helper'
+
+require 'sql_query_executor'
+
+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')}
+  end
+
+  subject { SqlQueryExecutor::Base.new(@data) }
+
+  describe ".where" do
+    describe "=" do
+      context "when attribute is string" do
+        it "matches a record" do
+          record = subject.where("name = 'US'")
+          record.size.should == 1
+          record.first.id.should == 1
+          record.first.name.should == 'US'
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("name = 'Argentina'")
+          record.count.should == 0
+          record.should == []
+        end
+      end
+
+      context "when attribute is integer" do
+        it "matches a record" do
+          record = subject.where("id = 1")
+          record.count.should == 1
+          record.first.id.should == 1
+          record.first.name.should == 'US'
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("id = 43")
+          record.count.should == 0
+          record.should == []
+        end
+      end
+
+      context "when attribute is datetime" do
+        it "matches a record" do
+          record = subject.where("founded_at = ?", Time.parse('1500-04-22 13:34:25'))
+          record.count.should == 1
+          record.first.id.should == 5
+          record.first.name.should == 'Brazil'
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("id = ?", Time.parse('1500-09-07 13:34:25'))
+          record.count.should == 0
+          record.should == []
+        end
+      end
+    end
+
+    describe ">" do
+      context "when attribute is a string" do
+        it "matches a record" do
+          records = subject.where("name > 'T'")
+          records.count.should == 2
+          records.first.id.should == 1
+
+          records.map! do |record|
+            record.to_h
+          end
+
+          records.should == [@data[0], @data[3]]
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("name > 'Z'")
+          record.count.should == 0
+          record.should == []
+        end
+      end
+
+      context "when attribute is integer" do
+        it "matches a record" do
+          records = subject.where("id > 3")
+          records.count.should == 2
+          records.first.id.should == 4
+
+          records.map! do |record|
+            record.to_h
+          end
+
+          records.should == [@data[3], @data[4]]
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("id > 5")
+          record.count.should == 0
+          record.should == []
+        end
+      end
+
+      context "when attribute is datetime" do
+        it "matches a record" do
+          record = subject.where("founded_at > ?", Time.parse('1500-04-20 13:34:25'))
+          record.count.should == 1
+          record.first.id.should == 5
+          record.first.name.should == 'Brazil'
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("founded_at > ?", Time.parse('1500-04-23 13:34:25'))
+          record.count.should == 0
+          record.should == []
+        end
+      end
+    end
+
+    describe ">=" do
+      context "when attribute is a string" do
+        it "matches a record" do
+          records = subject.where("name >= 'U'")
+          records.count.should == 2
+          records.first.id.should == 1
+
+          records.map! do |record|
+            record.to_h
+          end
+
+          records.should == [@data[0], @data[3]]
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("name >= 'Z'")
+          record.count.should == 0
+          record.should == []
+        end
+      end
+
+      context "when attribute is integer" do
+        it "matches a record" do
+          records = subject.where("id >= 4")
+          records.count.should == 2
+          records.first.id.should == 4
+
+          records.map! do |record|
+            record.to_h
+          end
+
+          records.should == [@data[3], @data[4]]
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("id >= 6")
+          record.count.should == 0
+          record.should == []
+        end
+      end
+
+      context "when attribute is datetime" do
+        it "matches a record" do
+          record = subject.where("founded_at >= ?", Time.parse('1500-04-22 13:34:25'))
+          record.count.should == 1
+          record.first.id.should == 5
+          record.first.name.should == 'Brazil'
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("founded_at >= ?", Time.parse('1500-04-23 13:34:25'))
+          record.count.should == 0
+          record.should == []
+        end
+      end
+    end
+
+    describe "<" do
+      context "when attribute is a string" do
+        it "matches a record" do
+          records = subject.where("name < 'C'")
+          records.count.should == 1
+          records.first.id.should == 5
+
+          records.map! do |record|
+            record.to_h
+          end
+
+          records.should == [@data[4]]
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("name < 'B'")
+          record.count.should == 0
+          record.should == []
+        end
+      end
+
+      context "when attribute is integer" do
+        it "matches a record" do
+          records = subject.where("id < 3")
+          records.count.should == 2
+          records.first.id.should == 1
+
+          records.map! do |record|
+            record.to_h
+          end
+
+          records.should == [@data[0], @data[1]]
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("id < 1")
+          record.count.should == 0
+          record.should == []
+        end
+      end
+
+      context "when attribute is datetime" do
+        it "matches a record" do
+          record = subject.where("founded_at < ?", Time.parse('1500-04-22 13:34:26'))
+          record.count.should == 1
+          record.first.id.should == 5
+          record.first.name.should == 'Brazil'
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("founded_at < ?", Time.parse('1500-04-22 13:34:25'))
+          record.count.should == 0
+          record.should == []
+        end
+      end
+    end
+
+    describe "<=" do
+      context "when attribute is a string" do
+        it "matches a record" do
+          records = subject.where("name <= 'Brb'")
+          records.count.should == 1
+          records.first.id.should == 5
+
+          records.map! do |record|
+            record.to_h
+          end
+
+          records.should == [@data[4]]
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("name <= 'A'")
+          record.count.should == 0
+          record.should == []
+        end
+      end
+
+      context "when attribute is integer" do
+        it "matches a record" do
+          records = subject.where("id <= 2")
+          records.count.should == 2
+          records.first.id.should == 1
+
+          records.map! do |record|
+            record.to_h
+          end
+
+          records.should == [@data[0], @data[1]]
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("id <= 0")
+          record.count.should == 0
+          record.should == []
+        end
+      end
+
+      context "when attribute is datetime" do
+        it "matches a record" do
+          record = subject.where("founded_at <= ?", Time.parse('1500-04-22 13:34:25'))
+          record.count.should == 1
+          record.first.id.should == 5
+          record.first.name.should == 'Brazil'
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("founded_at <= ?", Time.parse('1500-04-22 13:34:24'))
+          record.count.should == 0
+          record.should == []
+        end
+      end
+    end
+
+    describe "between" do
+      context "when attribute is a string" do
+        it "matches a record" do
+          records = subject.where("name between 'A' and 'C'")
+          records.count.should == 1
+          records.first.id.should == 5
+
+          records.map! do |record|
+            record.to_h
+          end
+
+          records.should == [@data[4]]
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("name between 'K' and 'M'")
+          record.count.should == 0
+          record.should == []
+        end
+      end
+
+      context "when attribute is integer" do
+        it "matches a record" do
+          records = subject.where("id between 1 and 2")
+          records.count.should == 2
+          records.first.id.should == 1
+
+          records.map! do |record|
+            record.to_h
+          end
+
+          records.should == [@data[0], @data[1]]
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("id between 6 and 10")
+          record.count.should == 0
+          record.should == []
+        end
+      end
+
+      context "when attribute is datetime" do
+        it "matches a record" do
+          record = subject.where("founded_at between ? and ?", Time.parse('1500-04-22 13:34:24'), Time.parse('1500-04-22 13:34:26'))
+          record.count.should == 1
+          record.first.id.should == 5
+          record.first.name.should == 'Brazil'
+        end
+
+        it "doesn't match any record" do
+          record = subject.where("founded_at between ? and ?", Time.parse('1500-04-22 13:34:26'), Time.parse('1500-09-22 13:34:25'))
+          record.count.should == 0
+          record.should == []
+        end
+      end
+    end
+
+    describe "is" do
+      it "attribute is condition" do
+        records = subject.where("founded_at is null")
+        records.count.should == 4
+        records.first.id.should == 1
+
+        records.map! do |record|
+          record.to_h
+        end
+
+        records.should == [@data[0], @data[1], @data[2], @data[3]]
+      end
+
+      it "attribute is not condition" do
+        id = @data.last[:id]
+        records = subject.where("founded_at is not null")
+        records.count.should == 1
+        records.first.id.should == id
+
+        records.map! do |record|
+          record.to_h
+        end
+
+        records.should == [@data[id-1]]
+      end
+    end
+
+    describe "and" do
+      it "attribute and condition" do
+        records = subject.where("language = 'English' and monarch = 'The Crown of England'")
+        records.count.should == 2
+        records.first.id.should == 2
+
+        records.map! do |record|
+          record.to_h
+        end
+
+        records.should == [@data[1], @data[3]]
+      end
+
+      it "integer attribute and condition" do
+        records = subject.where("id = 2 and language = 'English'")
+        records.count.should == 1
+        records.first.id.should == 2
+
+        records.map! do |record|
+          record.to_h
+        end
+
+        records.should == [@data[1]]
+      end
+    end
+
+    describe "or" do
+      it "attribute or condition" do
+        records = subject.where("language = 'English' or language = 'Spanish'")
+        records.count.should == 4
+        records.first.id.should == 1
+
+        records.map! do |record|
+          record.to_h
+        end
+
+        records.should == [@data[0], @data[1], @data[2], @data[3]]
+      end
+    end
+
+    describe "in" do
+      it "attribute in condition" do
+        records = subject.where("language in ('English', 'Spanish')")
+        records.count.should == 4
+        records.first.id.should == 1
+
+        records.map! do |record|
+          record.to_h
+        end
+
+        records.should == [@data[0], @data[1], @data[2], @data[3]]
+      end
+    end
+
+    describe "not" do
+      xit "attribute not condition" do
+        records = subject.where("not language = 'English'")
+        records.count.should == 1
+        records.first.id.should == 5
+
+        records.map! do |record|
+          record.to_h
+        end
+
+        records.should == [@data[4]]
+      end
+    end
+  end
+end