sql_search_parser 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 66866005a717ecfd956c7e12def19dd1bf84d1ce
+  data.tar.gz: 6a234f90d1ffd9ebe1a3fadb405327116f69dd90
+SHA512:
+  metadata.gz: d1e18ffd9a85b75be8d76d26e1f191c5d7eef31f9de446987b586d01b9333718b22149f5f44693961a4ad0bfa06a4212643a6b9c6894771e7b6b4b44f3a87727
+  data.tar.gz: 56de07980807906da360b056fb6784e9ef4e76368f1b2a45952e4084794def05926b27ee92ab31ee504d550210a87ee6eb4f85510b0841b2a06423136fbf7078

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 NIEK Antoine
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,50 @@
+sql_search_parser
+=================
+
+Simple SQL search conditions parser (where clause) based on RACC
+
+Usage
+-----
+    SQLSearch::Parser.new.parse("a = 2")
+    => #<SQLSearch::Comparison:0x00000000fd12e0 @left=#<SQLSearch::Atoms::Column:0x00000000fd1588 @name="a", @table=nil, @space=nil>, @right=#<SQLSearch::Atoms::Literal:0x00000000fd1380 @value=2, @type=:int>, @operator=:"=">
+
+    SQLSearch::Parser.new.parse("a = 2 and b = 3").to_s
+    => "(`a` = 2) AND (`b` = 3)"
+
+    SQLSearch::Parser.new.parse("b = '2013-01-01T00:00:00Z'").right.value
+    => #<DateTime: 2013-01-01T00:00:00+00:00 ((2456294j,0s,0n),+0s,2299161j)>
+
+    SQLSearch::Parser.new.parse("b = '2013-01-01T00:00:00-05:00'").right.value
+    => #<DateTime: 2013-01-01T00:00:00-05:00 ((2456294j,18000s,0n),-18000s,2299161j)>
+
+    SQLSearch::Parser.new.parse("b IN(1,2,3)").right.values.map(&:value)
+    => [1, 2, 3]
+
+    SQLSearch::Parser.new.parse("b + 1 > c").left
+    => #<SQLSearch::Atoms::Scalar:0x000000016ceef8 @left=#<SQLSearch::Atoms::Column:0x000000016cf308 @name="b", @table=nil, @space=nil>, @right=#<SQLSearch::Atoms::Literal:0x000000016cf100 @value=1, @type=:int>, @operation=:+>
+
+For more examples look at the tests :)
+
+Installation
+------------
+    gem install sql_search_parser
+
+or add in your Gemfile
+
+    gem 'sql_search_parser'
+
+Build Dependencies
+------------------
+rake, rexical, racc
+
+Build & install Gem locally
+-----
+    rake package
+
+Run the tests
+-----
+    rake
+
+or
+
+    rake test

data/Rakefile

@@ -0,0 +1,26 @@
+require_relative 'lib/sql_search/version'
+require 'rake/testtask'
+
+desc "Generate Lexer"
+
+task :lexer do
+  `rex lib/sql_search/parser.rex -o lib/sql_search/parser.rex.rb`
+end
+
+task :parser do
+  `racc lib/sql_search/parser.y -o lib/sql_search/parser.racc.rb`
+end
+
+task :build => [:lexer, :parser]
+
+task :package => [:build] do
+  `gem build sql_search_parser.gemspec`
+  `gem install sql_search_parser-#{SQLSearch::VERSION}.gem`
+end
+
+Rake::TestTask.new do |t|
+  t.pattern = "test/**/*_test.rb"
+end
+
+task :default => [:test]
+

data/lib/sql_search/parser.racc.rb

@@ -0,0 +1,485 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.11
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+
+  require 'date'
+  require_relative 'parser.rex.rb'
+
+module SQLSearch
+  class Parser < Racc::Parser
+
+module_eval(<<'...end parser.y/module_eval...', 'parser.y', 94)
+  def parse(input)
+    scan_str(input)
+  end
+...end parser.y/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+     2,     3,    48,    49,    53,    58,    77,    50,    64,     2,
+     3,    12,    13,    59,    78,    16,    17,    18,    19,    20,
+    12,    13,     2,     3,    16,    17,    18,    19,    20,    22,
+    23,     2,     3,    12,    13,    22,    23,    16,    17,    18,
+    19,    20,    12,    13,     2,     3,    16,    17,    18,    19,
+    20,    22,    23,    70,    39,    12,    13,    67,    67,    16,
+    17,    18,    19,    20,    12,    13,    39,    79,    16,    17,
+    18,    19,    20,    71,    42,    39,    12,    13,    41,    36,
+    16,    17,    18,    19,    20,    12,    13,    39,    61,    16,
+    17,    18,    19,    20,   nil,   nil,    39,    12,    13,   nil,
+   nil,    16,    17,    18,    19,    20,    12,    13,    39,   nil,
+    16,    17,    18,    19,    20,   nil,   nil,    39,    12,    13,
+   nil,   nil,    16,    17,    18,    19,    20,    12,    13,    39,
+   nil,    16,    17,    18,    19,    20,   nil,   nil,    39,    12,
+    13,   nil,   nil,    16,    17,    18,    19,    20,    12,    13,
+    39,   nil,    16,    17,    18,    19,    20,   nil,   nil,    39,
+    12,    13,   nil,   nil,    16,    17,    18,    19,    20,    12,
+    13,    39,    81,    16,    17,    18,    19,    20,    65,   nil,
+    78,    12,    13,    72,   nil,    16,    17,    18,    19,    20,
+    32,    33,    34,    35,   nil,    32,    33,    34,    35,    28,
+   nil,   nil,    27,    29,    30,    22,    23,   nil,    31,    45,
+    32,    33,    34,    35,    28,   nil,    46,    27,    29,    30,
+    46,   nil,   nil,    31,   nil,    32,    33,    34,    35,    32,
+    33,    34,    35,    16,    17,    18,    19,    16,    17,    18,
+    19,    32,    33,    34,    35,    32,    33,    34,    35,    32,
+    33,    34,    35,    21,   nil,    22,    23,    16,    17,    18,
+    19,    16,    17,    18,    19,    32,    33,    34,    35,    16,
+    17,    18,    19,    16,    17,    18,    19,    32,    33,    34,
+    35,    32,    33,    34,    35,    32,    33,    34,    35,    32,
+    33,    34,    35,    32,    33,    34,    35 ]
+
+racc_action_check = [
+     0,     0,    28,    28,    31,    36,    68,    28,    50,    23,
+    23,     0,     0,    36,    68,     0,     0,     0,     0,     0,
+    23,    23,     2,     2,    23,    23,    23,    23,    23,    44,
+    44,     3,     3,     2,     2,    24,    24,     2,     2,     2,
+     2,     2,     3,     3,    22,    22,     3,     3,     3,     3,
+     3,    43,    43,    58,    35,    22,    22,    52,    63,    22,
+    22,    22,    22,    22,    35,    35,    12,    71,    35,    35,
+    35,    35,    35,    61,    21,    13,    12,    12,    20,    11,
+    12,    12,    12,    12,    12,    13,    13,    39,    41,    13,
+    13,    13,    13,    13,   nil,   nil,    34,    39,    39,   nil,
+   nil,    39,    39,    39,    39,    39,    34,    34,    65,   nil,
+    34,    34,    34,    34,    34,   nil,   nil,    48,    65,    65,
+   nil,   nil,    65,    65,    65,    65,    65,    48,    48,    72,
+   nil,    48,    48,    48,    48,    48,   nil,   nil,    29,    72,
+    72,   nil,   nil,    72,    72,    72,    72,    72,    29,    29,
+    32,   nil,    29,    29,    29,    29,    29,   nil,   nil,    27,
+    32,    32,   nil,   nil,    32,    32,    32,    32,    32,    27,
+    27,    33,    74,    27,    27,    27,    27,    27,    51,   nil,
+    74,    33,    33,    62,   nil,    33,    33,    33,    33,    33,
+    51,    51,    51,    51,   nil,    62,    62,    62,    62,    10,
+   nil,   nil,    10,    10,    10,    25,    25,   nil,    10,    25,
+    10,    10,    10,    10,    26,   nil,    26,    26,    26,    26,
+    60,   nil,   nil,    26,   nil,    26,    26,    26,    26,    60,
+    60,    60,    60,    67,    67,    67,    67,    78,    78,    78,
+    78,    40,    40,    40,    40,    37,    37,    37,    37,    47,
+    47,    47,    47,     1,   nil,     1,     1,    49,    49,    49,
+    49,    64,    64,    64,    64,    75,    75,    75,    75,    30,
+    30,    30,    30,    53,    53,    53,    53,    54,    54,    54,
+    54,    55,    55,    55,    55,    56,    56,    56,    56,    57,
+    57,    57,    57,    80,    80,    80,    80 ]
+
+racc_action_pointer = [
+    -4,   253,    18,    27,   nil,   nil,   nil,   nil,   nil,   nil,
+   195,    68,    61,    70,   nil,   nil,   nil,   nil,   nil,   nil,
+    54,    74,    40,     5,    33,   203,   210,   154,    -6,   133,
+   250,    -1,   145,   166,    91,    49,     1,   230,   nil,    82,
+   226,    65,   nil,    49,    27,   nil,   nil,   234,   112,   238,
+     3,   175,    47,   254,   262,   266,   270,   274,    41,   nil,
+   214,    49,   180,    48,   242,   103,   nil,   214,     0,   nil,
+   nil,    44,   124,   nil,   166,   250,   nil,   nil,   218,   nil,
+   278,   nil,   nil ]
+
+racc_action_default = [
+   -41,   -41,   -41,   -41,    -5,    -6,    -7,    -8,    -9,   -10,
+   -41,   -31,   -41,   -41,   -30,   -33,   -34,   -35,   -36,   -37,
+   -38,   -41,   -41,   -41,    -3,   -41,   -41,   -41,   -41,   -41,
+   -41,   -41,   -41,   -41,   -41,   -41,   -41,   -28,   -31,   -41,
+   -29,   -41,    83,    -1,    -2,    -4,   -32,   -11,   -41,   -41,
+   -41,   -41,   -16,   -41,   -24,   -25,   -26,   -27,   -41,   -19,
+   -41,   -39,   -41,   -16,   -41,   -41,   -15,   -41,   -41,   -22,
+   -18,   -41,   -41,   -14,   -41,   -13,   -17,   -21,   -41,   -40,
+   -12,   -20,   -23 ]
+
+racc_goto_table = [
+    26,    66,   nil,   nil,    52,    68,   nil,   nil,   nil,    37,
+    40,     1,    73,    24,    25,   nil,    74,    11,   nil,    11,
+    11,   nil,   nil,    63,    47,   nil,    51,    69,   nil,    54,
+    55,    56,    57,    43,    44,   nil,    60,   nil,    69,    11,
+    11,    76,   nil,   nil,   nil,    62,   nil,   nil,   nil,   nil,
+   nil,   nil,    82,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    75,   nil,   nil,   nil,   nil,   nil,   nil,    80 ]
+
+racc_goto_check = [
+     8,    10,   nil,   nil,     9,    12,   nil,   nil,   nil,     8,
+     8,     1,    10,     1,     1,   nil,    12,    11,   nil,    11,
+    11,   nil,   nil,     9,     8,   nil,     8,     9,   nil,     8,
+     8,     8,     8,     1,     1,   nil,     8,   nil,     9,    11,
+    11,     9,   nil,   nil,   nil,     8,   nil,   nil,   nil,   nil,
+   nil,   nil,     9,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,     8,   nil,   nil,   nil,   nil,   nil,   nil,     8 ]
+
+racc_goto_pointer = [
+   nil,    11,   nil,   nil,   nil,   nil,   nil,   nil,    -3,   -26,
+   -51,    17,   -48,   nil ]
+
+racc_goto_default = [
+   nil,   nil,     4,     5,     6,     7,     8,     9,    10,    14,
+   nil,    38,   nil,    15 ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  3, 26, :_reduce_1,
+  3, 26, :_reduce_2,
+  2, 26, :_reduce_3,
+  3, 26, :_reduce_none,
+  1, 26, :_reduce_none,
+  1, 27, :_reduce_none,
+  1, 27, :_reduce_none,
+  1, 27, :_reduce_none,
+  1, 27, :_reduce_none,
+  1, 27, :_reduce_none,
+  3, 28, :_reduce_11,
+  6, 29, :_reduce_none,
+  5, 29, :_reduce_none,
+  5, 30, :_reduce_14,
+  4, 30, :_reduce_15,
+  0, 35, :_reduce_none,
+  2, 35, :_reduce_none,
+  4, 31, :_reduce_18,
+  3, 31, :_reduce_19,
+  6, 32, :_reduce_20,
+  5, 32, :_reduce_21,
+  1, 37, :_reduce_22,
+  3, 37, :_reduce_23,
+  3, 33, :_reduce_24,
+  3, 33, :_reduce_25,
+  3, 33, :_reduce_26,
+  3, 33, :_reduce_27,
+  2, 33, :_reduce_28,
+  2, 33, :_reduce_29,
+  1, 33, :_reduce_none,
+  1, 33, :_reduce_none,
+  3, 33, :_reduce_none,
+  1, 34, :_reduce_none,
+  1, 38, :_reduce_34,
+  1, 38, :_reduce_35,
+  1, 38, :_reduce_36,
+  1, 38, :_reduce_37,
+  1, 36, :_reduce_38,
+  3, 36, :_reduce_39,
+  5, 36, :_reduce_40 ]
+
+racc_reduce_n = 41
+
+racc_shift_n = 83
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :OR => 2,
+  :AND => 3,
+  :NOT => 4,
+  :LPAREN => 5,
+  :RPAREN => 6,
+  :COMPARISON => 7,
+  :BETWEEN => 8,
+  :LIKE => 9,
+  :ESCAPE => 10,
+  :IS => 11,
+  :NULL => 12,
+  :IN => 13,
+  :COMMA => 14,
+  :ADD => 15,
+  :SUBTRACT => 16,
+  :MULTIPLY => 17,
+  :DIVIDE => 18,
+  :STRING => 19,
+  :APPROXNUM => 20,
+  :INTNUM => 21,
+  :TIME => 22,
+  :NAME => 23,
+  :DOT => 24 }
+
+racc_nt_base = 25
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "OR",
+  "AND",
+  "NOT",
+  "LPAREN",
+  "RPAREN",
+  "COMPARISON",
+  "BETWEEN",
+  "LIKE",
+  "ESCAPE",
+  "IS",
+  "NULL",
+  "IN",
+  "COMMA",
+  "ADD",
+  "SUBTRACT",
+  "MULTIPLY",
+  "DIVIDE",
+  "STRING",
+  "APPROXNUM",
+  "INTNUM",
+  "TIME",
+  "NAME",
+  "DOT",
+  "$start",
+  "search_condition",
+  "predicate",
+  "comparison_predicate",
+  "between_predicate",
+  "like_predicate",
+  "test_for_null",
+  "in_predicate",
+  "scalar_exp",
+  "atom",
+  "opt_escape",
+  "column_ref",
+  "atom_commalist",
+  "literal" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+module_eval(<<'.,.,', 'parser.y', 6)
+  def _reduce_1(val, _values, result)
+     result = Conditions::Or.new(:left => val[0], :right => val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 7)
+  def _reduce_2(val, _values, result)
+     result = Conditions::And.new(:left => val[0], :right => val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 8)
+  def _reduce_3(val, _values, result)
+     result = Conditions::Not.new(:value => val[1]) 
+    result
+  end
+.,.,
+
+# reduce 4 omitted
+
+# reduce 5 omitted
+
+# reduce 6 omitted
+
+# reduce 7 omitted
+
+# reduce 8 omitted
+
+# reduce 9 omitted
+
+# reduce 10 omitted
+
+module_eval(<<'.,.,', 'parser.y', 22)
+  def _reduce_11(val, _values, result)
+     result = Comparison.new(:left => val[0], :right => val[2], :operator => val[1].to_sym) 
+    result
+  end
+.,.,
+
+# reduce 12 omitted
+
+# reduce 13 omitted
+
+module_eval(<<'.,.,', 'parser.y', 31)
+  def _reduce_14(val, _values, result)
+     result = Conditions::Not.new(:value => Comparison.new(:left => val[0], :right => val[3], :operator => :LIKE)) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 32)
+  def _reduce_15(val, _values, result)
+     result = Comparison.new(:left => val[0], :right => val[2], :operator => :LIKE) 
+    result
+  end
+.,.,
+
+# reduce 16 omitted
+
+# reduce 17 omitted
+
+module_eval(<<'.,.,', 'parser.y', 41)
+  def _reduce_18(val, _values, result)
+     result = Comparison.new(:left => val[0], :right => val[3], :operator => :'<>') 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 42)
+  def _reduce_19(val, _values, result)
+     result = Comparison.new(:left => val[0], :right => val[2], :operator => :'=') 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 46)
+  def _reduce_20(val, _values, result)
+     result = Conditions::Not.new(:value => In.new(:left => val[0], :right => Atoms::InValues.new(:values => val[4]))) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 47)
+  def _reduce_21(val, _values, result)
+     result = In.new(:left => val[0], :right => Atoms::InValues.new(:values => val[3])) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 51)
+  def _reduce_22(val, _values, result)
+     result = [val[0]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 52)
+  def _reduce_23(val, _values, result)
+     result = val[0].concat([val[2]]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 58)
+  def _reduce_24(val, _values, result)
+     result = Atoms::Scalar.new(:left => val[0], :right => val[2], :operation => :'+')
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 59)
+  def _reduce_25(val, _values, result)
+     result = Atoms::Scalar.new(:left => val[0], :right => val[2], :operation => :'-')
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 60)
+  def _reduce_26(val, _values, result)
+     result = Atoms::Scalar.new(:left => val[0], :right => val[2], :operation => :'*')
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 61)
+  def _reduce_27(val, _values, result)
+     result = Atoms::Scalar.new(:left => val[0], :right => val[2], :operation => :'/')
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 62)
+  def _reduce_28(val, _values, result)
+     result = Atoms::UnaryScalar.new(:value => val[1], :operation => :'+')
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 63)
+  def _reduce_29(val, _values, result)
+     result = Atoms::UnaryScalar.new(:value => val[1], :operation => :'-')
+    result
+  end
+.,.,
+
+# reduce 30 omitted
+
+# reduce 31 omitted
+
+# reduce 32 omitted
+
+# reduce 33 omitted
+
+module_eval(<<'.,.,', 'parser.y', 74)
+  def _reduce_34(val, _values, result)
+     result = Atoms::Literal.new(:value => val[0], :type => :string) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 75)
+  def _reduce_35(val, _values, result)
+     result = Atoms::Literal.new(:value => val[0], :type => :float) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 76)
+  def _reduce_36(val, _values, result)
+     result = Atoms::Literal.new(:value => val[0], :type => :int) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 77)
+  def _reduce_37(val, _values, result)
+     result = Atoms::Literal.new(:value => val[0], :type => :datetime) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 81)
+  def _reduce_38(val, _values, result)
+     result = Atoms::Column.new(:name => val[0]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 82)
+  def _reduce_39(val, _values, result)
+     result = Atoms::Column.new(:name => val[0], :table=> val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'parser.y', 83)
+  def _reduce_40(val, _values, result)
+     result = Atoms::Column.new(:name => val[4], :table=> val[2], :space => val[0]) 
+    result
+  end
+.,.,
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+  end   # class Parser
+  end   # module SQLSearch

data/lib/sql_search/parser.rex

@@ -0,0 +1,66 @@
+class SQLSearch::Parser
+
+option
+  ignorecase
+
+macro
+  BLANK  [\ \t]+
+  STRING [^']+
+  APPROXNUM {INTNUM}\.{INTNUM}
+  INTNUM \d+
+  COMPARISON (<>|=|[<][=]|[<]|[>][=]|[>])
+
+  NAME [A-z_]([A-z0-9_]*)
+
+  IS is
+  NOT not
+  NULLX null
+  IN in
+  OR or
+  AND and
+  BETWEEN between
+
+  YEARS   \d+
+  MONTHS  \d{2}
+  DAYS    \d{2}
+  HOURS   \d{2}
+  MINUTES \d{2}
+  SECONDS \d{2}
+  UTC_OFFSET  ([+-]{HOURS}:{MINUTES}|Z)
+  TIME    {YEARS}-{MONTHS}-{DAYS}T{HOURS}:{MINUTES}:{SECONDS}{UTC_OFFSET}
+
+rule
+  {BLANK}
+  {APPROXNUM} { [:APPROXNUM, text.to_f] }
+  {INTNUM} { [:INTNUM, text.to_i] }
+  '{TIME}' { [:TIME, DateTime.iso8601(text[1...-1])] }
+  '{STRING}' { [:STRING, text[1...-1]] }
+  IS { [:IS, text] }
+  NOT { [:NOT, text] }
+  NULL { [:NULL, text.upcase] }
+  IN { [:IN, text] }
+  OR { [:OR, text] }
+  AND { [:AND, text] }
+  BETWEEN { [:BETWEEN, text] }
+  LIKE { [:LIKE, text] }
+  {COMPARISON} { [:COMPARISON, text] }
+  {NAME} { [:NAME, text] }
+  \( { [:LPAREN, text] }
+  \) { [:RPAREN, text] }
+  \. { [:DOT, text] }
+  \, { [:COMMA, text] }
+  \+ { [:ADD, text] }
+  \- { [:SUBTRACT, text] }
+  \/ { [:DIVIDE, text] }
+  \* { [:MULTIPLY, text] }
+inner
+
+  def tokenize(code)
+    scan_setup(code)
+    tokens = []
+    while token = next_token
+      tokens << token
+    end
+    tokens
+  end
+end

data/lib/sql_search/parser.rex.rb

@@ -0,0 +1,148 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.5
+# from lexical definition file "lib/sql_search/parser.rex".
+#++
+
+require 'racc/parser'
+class SQLSearch::Parser < Racc::Parser
+  require 'strscan'
+
+  class ScanError < StandardError ; end
+
+  attr_reader   :lineno
+  attr_reader   :filename
+  attr_accessor :state
+
+  def scan_setup(str)
+    @ss = StringScanner.new(str)
+    @lineno =  1
+    @state  = nil
+  end
+
+  def action
+    yield
+  end
+
+  def scan_str(str)
+    scan_setup(str)
+    do_parse
+  end
+  alias :scan :scan_str
+
+  def load_file( filename )
+    @filename = filename
+    open(filename, "r") do |f|
+      scan_setup(f.read)
+    end
+  end
+
+  def scan_file( filename )
+    load_file(filename)
+    do_parse
+  end
+
+
+  def next_token
+    return if @ss.eos?
+    
+    # skips empty actions
+    until token = _next_token or @ss.eos?; end
+    token
+  end
+
+  def _next_token
+    text = @ss.peek(1)
+    @lineno  +=  1  if text == "\n"
+    token = case @state
+    when nil
+      case
+      when (text = @ss.scan(/[ \t]+/i))
+        ;
+
+      when (text = @ss.scan(/\d+\.\d+/i))
+         action { [:APPROXNUM, text.to_f] }
+
+      when (text = @ss.scan(/\d+/i))
+         action { [:INTNUM, text.to_i] }
+
+      when (text = @ss.scan(/'\d+-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}([+-]\d{2}:\d{2}|Z)'/i))
+         action { [:TIME, DateTime.iso8601(text[1...-1])] }
+
+      when (text = @ss.scan(/'[^']+'/i))
+         action { [:STRING, text[1...-1]] }
+
+      when (text = @ss.scan(/IS/i))
+         action { [:IS, text] }
+
+      when (text = @ss.scan(/NOT/i))
+         action { [:NOT, text] }
+
+      when (text = @ss.scan(/NULL/i))
+         action { [:NULL, text.upcase] }
+
+      when (text = @ss.scan(/IN/i))
+         action { [:IN, text] }
+
+      when (text = @ss.scan(/OR/i))
+         action { [:OR, text] }
+
+      when (text = @ss.scan(/AND/i))
+         action { [:AND, text] }
+
+      when (text = @ss.scan(/BETWEEN/i))
+         action { [:BETWEEN, text] }
+
+      when (text = @ss.scan(/LIKE/i))
+         action { [:LIKE, text] }
+
+      when (text = @ss.scan(/(<>|=|[<][=]|[<]|[>][=]|[>])/i))
+         action { [:COMPARISON, text] }
+
+      when (text = @ss.scan(/[A-z_]([A-z0-9_]*)/i))
+         action { [:NAME, text] }
+
+      when (text = @ss.scan(/\(/i))
+         action { [:LPAREN, text] }
+
+      when (text = @ss.scan(/\)/i))
+         action { [:RPAREN, text] }
+
+      when (text = @ss.scan(/\./i))
+         action { [:DOT, text] }
+
+      when (text = @ss.scan(/\,/i))
+         action { [:COMMA, text] }
+
+      when (text = @ss.scan(/\+/i))
+         action { [:ADD, text] }
+
+      when (text = @ss.scan(/\-/i))
+         action { [:SUBTRACT, text] }
+
+      when (text = @ss.scan(/\//i))
+         action { [:DIVIDE, text] }
+
+      when (text = @ss.scan(/\*/i))
+         action { [:MULTIPLY, text] }
+
+      else
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    else
+      raise  ScanError, "undefined state: '" + state.to_s + "'"
+    end  # case state
+    token
+  end  # def _next_token
+
+  def tokenize(code)
+    scan_setup(code)
+    tokens = []
+    while token = next_token
+      tokens << token
+    end
+    tokens
+  end
+end # class

data/lib/sql_search/parser.y

@@ -0,0 +1,97 @@
+class SQLSearch::Parser
+
+rule
+  /* search conditions */
+
+  search_condition:
+    search_condition OR search_condition { result = Conditions::Or.new(:left => val[0], :right => val[2]) }
+    |search_condition AND search_condition { result = Conditions::And.new(:left => val[0], :right => val[2]) }
+    |NOT search_condition { result = Conditions::Not.new(:value => val[1]) }
+    |LPAREN search_condition RPAREN
+    |predicate
+    ;
+
+  predicate:
+    comparison_predicate
+    |between_predicate
+    |like_predicate
+    |test_for_null
+    |in_predicate
+    ;
+
+  comparison_predicate:
+    scalar_exp COMPARISON scalar_exp { result = Comparison.new(:left => val[0], :right => val[2], :operator => val[1].to_sym) }
+    ;
+
+  between_predicate:
+    scalar_exp NOT BETWEEN scalar_exp AND scalar_exp
+    |scalar_exp BETWEEN scalar_exp AND scalar_exp
+    ;
+
+  like_predicate:
+    scalar_exp NOT LIKE atom opt_escape { result = Conditions::Not.new(:value => Comparison.new(:left => val[0], :right => val[3], :operator => :LIKE)) }
+    |scalar_exp LIKE atom opt_escape { result = Comparison.new(:left => val[0], :right => val[2], :operator => :LIKE) }
+    ;
+
+  opt_escape:
+    /* empty */
+    |ESCAPE atom
+    ;
+
+  test_for_null:
+    column_ref IS NOT NULL { result = Comparison.new(:left => val[0], :right => val[3], :operator => :'<>') }
+    |column_ref IS NULL { result = Comparison.new(:left => val[0], :right => val[2], :operator => :'=') }
+    ;
+
+  in_predicate:
+    scalar_exp NOT IN LPAREN atom_commalist RPAREN { result = Conditions::Not.new(:value => In.new(:left => val[0], :right => Atoms::InValues.new(:values => val[4]))) }
+    |scalar_exp IN LPAREN atom_commalist RPAREN { result = In.new(:left => val[0], :right => Atoms::InValues.new(:values => val[3])) }
+    ;
+
+  atom_commalist:
+    atom { result = [val[0]] }
+    |atom_commalist COMMA atom { result = val[0].concat([val[2]]) }
+    ;
+
+    /* scalar expressions */
+
+  scalar_exp:
+    scalar_exp ADD scalar_exp { result = Atoms::Scalar.new(:left => val[0], :right => val[2], :operation => :'+')}
+    |scalar_exp SUBTRACT scalar_exp { result = Atoms::Scalar.new(:left => val[0], :right => val[2], :operation => :'-')}
+    |scalar_exp MULTIPLY scalar_exp { result = Atoms::Scalar.new(:left => val[0], :right => val[2], :operation => :'*')}
+    |scalar_exp DIVIDE scalar_exp { result = Atoms::Scalar.new(:left => val[0], :right => val[2], :operation => :'/')}
+    |ADD scalar_exp { result = Atoms::UnaryScalar.new(:value => val[1], :operation => :'+')}
+    |SUBTRACT scalar_exp { result = Atoms::UnaryScalar.new(:value => val[1], :operation => :'-')}
+    |atom
+    |column_ref
+    |LPAREN scalar_exp RPAREN
+    ;
+
+  atom:
+    literal
+    ;
+
+  literal:
+    STRING { result = Atoms::Literal.new(:value => val[0], :type => :string) }
+    |APPROXNUM { result = Atoms::Literal.new(:value => val[0], :type => :float) }
+    |INTNUM { result = Atoms::Literal.new(:value => val[0], :type => :int) }
+    |TIME { result = Atoms::Literal.new(:value => val[0], :type => :datetime) }
+    ;
+
+  column_ref:
+    NAME { result = Atoms::Column.new(:name => val[0]) }
+    |NAME DOT NAME { result = Atoms::Column.new(:name => val[0], :table=> val[2]) }
+    |NAME DOT NAME DOT NAME { result = Atoms::Column.new(:name => val[4], :table=> val[2], :space => val[0]) }
+    ;
+
+end
+
+---- header
+  require 'date'
+  require_relative 'parser.rex.rb'
+
+---- inner
+  def parse(input)
+    scan_str(input)
+  end
+

data/lib/sql_search/version.rb

@@ -0,0 +1,3 @@
+module SQLSearch
+  VERSION = '0.0.2'
+end

data/lib/sql_search_parser.rb

@@ -0,0 +1,126 @@
+module SQLSearch
+  module Conditions
+    class And
+      attr_reader :left, :right
+      def initialize options
+        @left = options[:left]; @right = options[:right]
+      end
+
+      def to_s
+        "(#{left}) AND (#{right})"
+      end
+    end
+
+    class Or
+      attr_reader :left, :right
+      def initialize options
+        @left = options[:left]; @right = options[:right]
+      end
+
+      def to_s
+        "(#{left}) OR (#{right})"
+      end
+    end
+
+    class Not
+      attr_reader :value
+      def initialize options
+        @value = options[:value]
+      end
+
+      def to_s
+        "NOT(#{value})"
+      end
+    end
+  end
+
+  class Comparison
+    attr_reader :left, :right, :operator
+
+    def initialize options
+      @left = options[:left]
+      @right = options[:right]
+      @operator = options[:operator]
+    end
+
+    def to_s
+      "#{left} #{operator} #{right}"
+    end
+  end
+
+  class In < Comparison
+    def initialize options
+      super options
+      @operator = :IN
+    end
+  end
+
+  module Atoms
+    class InValues
+      attr_reader :values
+      def initialize options
+        @values = options[:values]
+      end
+
+      def to_s
+        "(#{values.join(', ')})"
+      end
+    end
+
+    class Scalar
+      attr_reader :left, :right, :operation
+      def initialize options
+        @left = options[:left]
+        @right = options[:right]
+        @operation = options[:operation]
+      end
+
+      def to_s
+        "#{left} #{operation} #{right}"
+      end
+    end
+
+    class UnaryScalar < Scalar
+      attr_reader :value, :operation
+      def initialize options
+        @value = options[:value]
+        @operation = options[:operation]
+      end
+
+      def to_s
+        "#{operation}#{value}"
+      end
+    end
+
+    class Literal
+      attr_reader :value, :type
+      def initialize options
+        @value = options[:value]
+        @type = options[:type]
+      end
+
+      def to_s
+        case type
+        when :string then "'#{value}'"
+        else "#{value}"
+        end
+      end
+    end
+
+    class Column
+      attr_reader :name, :table, :space
+
+      def initialize options
+        @name = options[:name]
+        @table = options[:table]
+        @space = options[:space]
+      end
+
+      def to_s
+        [space,table,name].compact.map { |a| "`#{a}`" }.join('.')
+      end
+    end
+  end
+end
+
+require 'sql_search/parser.racc.rb'

metadata

@@ -0,0 +1,108 @@
+--- !ruby/object:Gem::Specification
+name: sql_search_parser
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Antoine Niek
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: rexical
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: racc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Simple SQL search conditions parser (where clause)
+email: antoineniek@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- LICENSE
+- README.md
+- Rakefile
+- lib/sql_search_parser.rb
+- lib/sql_search/parser.rex.rb
+- lib/sql_search/parser.y
+- lib/sql_search/parser.rex
+- lib/sql_search/version.rb
+- lib/sql_search/parser.racc.rb
+homepage: https://github.com/zapo/sql_search_parser
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.14
+signing_key: 
+specification_version: 4
+summary: Simple SQL search conditions parser (where clause)
+test_files: []