sql-parser-tl 0.0.3

data/lib/sql-parser/parser.rex

@@ -0,0 +1,113 @@
+class SQLParser::Parser
+
+option
+  ignorecase
+
+macro
+  DIGIT   [0-9]
+  UINT    {DIGIT}+
+  BLANK   \s+
+
+  YEARS   {UINT}
+  MONTHS  {UINT}
+  DAYS    {UINT}
+  DATE    {YEARS}-{MONTHS}-{DAYS}
+
+  IDENT   [\w\$]+
+
+  KW_TRAIL ([\s()]+)|$  # Keywords must trail with these characters; otherwise, aliases containing a keyword as a prefix will be misinterpreted
+
+rule
+# [:state]  pattern       [actions]
+
+# literals
+            \"{DATE}\"            { [:date_string, Date.parse(text)] }
+            \'{DATE}\'            { [:date_string, Date.parse(text)] }
+
+            \'                    { @state = :STRS;  [:single_quote, text] }
+  :STRS     \'                    { @state = nil;    [:single_quote, text] }
+  :STRS     .*?(?=(?<!\\)\')      {                  [:character_string_literal, text.gsub("''", "'")] }
+
+            \"                    { @state = :STRD;  [:double_quote, text] }
+  :STRD     \"                    { @state = nil;    [:double_quote, text] }
+  :STRD     .*?(?=(?<!\\)\")      {                  [:character_string_literal, text.gsub('""', '"')] }
+
+            {UINT}        { [:unsigned_integer, text.to_i] }
+
+# skip
+            {BLANK}       # no action
+
+# keywords
+            SELECT(?={KW_TRAIL})        { [:SELECT, text] }
+            DATE(?={KW_TRAIL})          { [:DATE, text] }
+            ASC(?={KW_TRAIL})           { [:ASC, text] }
+            AS(?={KW_TRAIL})            { [:AS, text] }
+            FROM(?={KW_TRAIL})          { [:FROM, text] }
+            WHERE(?={KW_TRAIL})         { [:WHERE, text] }
+            BETWEEN(?={KW_TRAIL})       { [:BETWEEN, text] }
+            AND(?={KW_TRAIL})           { [:AND, text] }
+            NOT(?={KW_TRAIL})           { [:NOT, text] }
+            INNER(?={KW_TRAIL})         { [:INNER, text] }
+            INSERT(?={KW_TRAIL})        { [:INSERT, text] }
+            INTO(?={KW_TRAIL})          { [:INTO, text] }
+            IN(?={KW_TRAIL})            { [:IN, text] }
+            ORDER(?={KW_TRAIL})         { [:ORDER, text] }
+            OR(?={KW_TRAIL})            { [:OR, text] }
+            LIKE(?={KW_TRAIL})          { [:LIKE, text] }
+            IS(?={KW_TRAIL})            { [:IS, text] }
+            NULL(?={KW_TRAIL})          { [:NULL, text] }
+            COUNT(?={KW_TRAIL})         { [:COUNT, text] }
+            AVG(?={KW_TRAIL})           { [:AVG, text] }
+            MAX(?={KW_TRAIL})           { [:MAX, text] }
+            MIN(?={KW_TRAIL})           { [:MIN, text] }
+            SUM(?={KW_TRAIL})           { [:SUM, text] }
+            GROUP(?={KW_TRAIL})         { [:GROUP, text] }
+            BY(?={KW_TRAIL})            { [:BY, text] }
+            HAVING(?={KW_TRAIL})        { [:HAVING, text] }
+            CROSS(?={KW_TRAIL})         { [:CROSS, text] }
+            JOIN(?={KW_TRAIL})          { [:JOIN, text] }
+            ON(?={KW_TRAIL})            { [:ON, text] }
+            LEFT(?={KW_TRAIL})          { [:LEFT, text] }
+            OUTER(?={KW_TRAIL})         { [:OUTER, text] }
+            RIGHT(?={KW_TRAIL})         { [:RIGHT, text] }
+            FULL(?={KW_TRAIL})          { [:FULL, text] }
+            USING(?={KW_TRAIL})         { [:USING, text] }
+            EXISTS(?={KW_TRAIL})        { [:EXISTS, text] }
+            DESC(?={KW_TRAIL})          { [:DESC, text] }
+            CURRENT_USER(?={KW_TRAIL})  { [:CURRENT_USER, text] }
+            VALUES(?={KW_TRAIL})        { [:VALUES, text] }
+            LIMIT(?={KW_TRAIL})         { [:LIMIT, text] }
+            OFFSET(?={KW_TRAIL})        { [:OFFSET, text] }
+            DISTINCT(?={KW_TRAIL})      { [:DISTINCT, text] }
+            INDEX(?={KW_TRAIL})         { [:INDEX, text] }
+            FORCE(?={KW_TRAIL})         { [:FORCE, text] }
+            USE(?={KW_TRAIL})           { [:USE, text] }
+            IGNORE(?={KW_TRAIL})        { [:IGNORE, text] }
+
+
+# tokens
+            E             { [:E, text] }
+
+            <>            { [:not_equals_operator, text] }
+            !=            { [:not_equals_operator, text] }
+            =             { [:equals_operator, text] }
+            <=            { [:less_than_or_equals_operator, text] }
+            <             { [:less_than_operator, text] }
+            >=            { [:greater_than_or_equals_operator, text] }
+            >             { [:greater_than_operator, text] }
+
+            \(            { [:left_paren, text] }
+            \)            { [:right_paren, text] }
+            \*            { [:asterisk, text] }
+            \/            { [:solidus, text] }
+            \+            { [:plus_sign, text] }
+            \-            { [:minus_sign, text] }
+            \.            { [:period, text] }
+            ,             { [:comma, text] }
+
+# identifier
+            `{IDENT}`     { [:identifier, text[1..-2]] }
+            {IDENT}       { [:identifier, text] }
+
+---- header ----
+require 'date'

data/lib/sql-parser/parser.rex.rb

@@ -0,0 +1,324 @@
+#--
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.5
+# from lexical definition file "lib/sql-parser/parser.rex".
+#++
+
+require 'racc/parser'
+class SQLParser::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(/\"[0-9]+-[0-9]+-[0-9]+\"/i))
+         action { [:date_string, Date.parse(text)] }
+
+      when (text = @ss.scan(/\'[0-9]+-[0-9]+-[0-9]+\'/i))
+         action { [:date_string, Date.parse(text)] }
+
+      when (text = @ss.scan(/\'/i))
+         action { @state = :STRS;  [:single_quote, text] }
+
+      when (text = @ss.scan(/\"/i))
+         action { @state = :STRD;  [:double_quote, text] }
+
+      when (text = @ss.scan(/[0-9]+/i))
+         action { [:unsigned_integer, text.to_i] }
+
+      when (text = @ss.scan(/\s+/i))
+        ;
+
+      when (text = @ss.scan(/SELECT(?=([\s()]+)|$)/i))
+         action { [:SELECT, text] }
+
+      when (text = @ss.scan(/DATE(?=([\s()]+)|$)/i))
+         action { [:DATE, text] }
+
+      when (text = @ss.scan(/ASC(?=([\s()]+)|$)/i))
+         action { [:ASC, text] }
+
+      when (text = @ss.scan(/AS(?=([\s()]+)|$)/i))
+         action { [:AS, text] }
+
+      when (text = @ss.scan(/FROM(?=([\s()]+)|$)/i))
+         action { [:FROM, text] }
+
+      when (text = @ss.scan(/WHERE(?=([\s()]+)|$)/i))
+         action { [:WHERE, text] }
+
+      when (text = @ss.scan(/BETWEEN(?=([\s()]+)|$)/i))
+         action { [:BETWEEN, text] }
+
+      when (text = @ss.scan(/AND(?=([\s()]+)|$)/i))
+         action { [:AND, text] }
+
+      when (text = @ss.scan(/NOT(?=([\s()]+)|$)/i))
+         action { [:NOT, text] }
+
+      when (text = @ss.scan(/INNER(?=([\s()]+)|$)/i))
+         action { [:INNER, text] }
+
+      when (text = @ss.scan(/INSERT(?=([\s()]+)|$)/i))
+         action { [:INSERT, text] }
+
+      when (text = @ss.scan(/INTO(?=([\s()]+)|$)/i))
+         action { [:INTO, text] }
+
+      when (text = @ss.scan(/IN(?=([\s()]+)|$)/i))
+         action { [:IN, text] }
+
+      when (text = @ss.scan(/ORDER(?=([\s()]+)|$)/i))
+         action { [:ORDER, text] }
+
+      when (text = @ss.scan(/OR(?=([\s()]+)|$)/i))
+         action { [:OR, text] }
+
+      when (text = @ss.scan(/LIKE(?=([\s()]+)|$)/i))
+         action { [:LIKE, text] }
+
+      when (text = @ss.scan(/IS(?=([\s()]+)|$)/i))
+         action { [:IS, text] }
+
+      when (text = @ss.scan(/NULL(?=([\s()]+)|$)/i))
+         action { [:NULL, text] }
+
+      when (text = @ss.scan(/COUNT(?=([\s()]+)|$)/i))
+         action { [:COUNT, text] }
+
+      when (text = @ss.scan(/AVG(?=([\s()]+)|$)/i))
+         action { [:AVG, text] }
+
+      when (text = @ss.scan(/MAX(?=([\s()]+)|$)/i))
+         action { [:MAX, text] }
+
+      when (text = @ss.scan(/MIN(?=([\s()]+)|$)/i))
+         action { [:MIN, text] }
+
+      when (text = @ss.scan(/SUM(?=([\s()]+)|$)/i))
+         action { [:SUM, text] }
+
+      when (text = @ss.scan(/GROUP(?=([\s()]+)|$)/i))
+         action { [:GROUP, text] }
+
+      when (text = @ss.scan(/BY(?=([\s()]+)|$)/i))
+         action { [:BY, text] }
+
+      when (text = @ss.scan(/HAVING(?=([\s()]+)|$)/i))
+         action { [:HAVING, text] }
+
+      when (text = @ss.scan(/CROSS(?=([\s()]+)|$)/i))
+         action { [:CROSS, text] }
+
+      when (text = @ss.scan(/JOIN(?=([\s()]+)|$)/i))
+         action { [:JOIN, text] }
+
+      when (text = @ss.scan(/ON(?=([\s()]+)|$)/i))
+         action { [:ON, text] }
+
+      when (text = @ss.scan(/LEFT(?=([\s()]+)|$)/i))
+         action { [:LEFT, text] }
+
+      when (text = @ss.scan(/OUTER(?=([\s()]+)|$)/i))
+         action { [:OUTER, text] }
+
+      when (text = @ss.scan(/RIGHT(?=([\s()]+)|$)/i))
+         action { [:RIGHT, text] }
+
+      when (text = @ss.scan(/FULL(?=([\s()]+)|$)/i))
+         action { [:FULL, text] }
+
+      when (text = @ss.scan(/USING(?=([\s()]+)|$)/i))
+         action { [:USING, text] }
+
+      when (text = @ss.scan(/EXISTS(?=([\s()]+)|$)/i))
+         action { [:EXISTS, text] }
+
+      when (text = @ss.scan(/DESC(?=([\s()]+)|$)/i))
+         action { [:DESC, text] }
+
+      when (text = @ss.scan(/CURRENT_USER(?=([\s()]+)|$)/i))
+         action { [:CURRENT_USER, text] }
+
+      when (text = @ss.scan(/VALUES(?=([\s()]+)|$)/i))
+         action { [:VALUES, text] }
+
+      when (text = @ss.scan(/LIMIT(?=([\s()]+)|$)/i))
+         action { [:LIMIT, text] }
+
+      when (text = @ss.scan(/OFFSET(?=([\s()]+)|$)/i))
+         action { [:OFFSET, text] }
+
+      when (text = @ss.scan(/DISTINCT(?=([\s()]+)|$)/i))
+         action { [:DISTINCT, text] }
+
+      when (text = @ss.scan(/INDEX(?=([\s()]+)|$)/i))
+         action { [:INDEX, text] }
+
+      when (text = @ss.scan(/FORCE(?=([\s()]+)|$)/i))
+         action { [:FORCE, text] }
+
+      when (text = @ss.scan(/USE(?=([\s()]+)|$)/i))
+         action { [:USE, text] }
+
+      when (text = @ss.scan(/IGNORE(?=([\s()]+)|$)/i))
+         action { [:IGNORE, text] }
+
+      when (text = @ss.scan(/E/i))
+         action { [:E, text] }
+
+      when (text = @ss.scan(/<>/i))
+         action { [:not_equals_operator, text] }
+
+      when (text = @ss.scan(/!=/i))
+         action { [:not_equals_operator, text] }
+
+      when (text = @ss.scan(/=/i))
+         action { [:equals_operator, text] }
+
+      when (text = @ss.scan(/<=/i))
+         action { [:less_than_or_equals_operator, text] }
+
+      when (text = @ss.scan(/</i))
+         action { [:less_than_operator, text] }
+
+      when (text = @ss.scan(/>=/i))
+         action { [:greater_than_or_equals_operator, text] }
+
+      when (text = @ss.scan(/>/i))
+         action { [:greater_than_operator, text] }
+
+      when (text = @ss.scan(/\(/i))
+         action { [:left_paren, text] }
+
+      when (text = @ss.scan(/\)/i))
+         action { [:right_paren, text] }
+
+      when (text = @ss.scan(/\*/i))
+         action { [:asterisk, text] }
+
+      when (text = @ss.scan(/\//i))
+         action { [:solidus, text] }
+
+      when (text = @ss.scan(/\+/i))
+         action { [:plus_sign, text] }
+
+      when (text = @ss.scan(/\-/i))
+         action { [:minus_sign, text] }
+
+      when (text = @ss.scan(/\./i))
+         action { [:period, text] }
+
+      when (text = @ss.scan(/,/i))
+         action { [:comma, text] }
+
+      when (text = @ss.scan(/`[\w\$]+`/i))
+         action { [:identifier, text[1..-2]] }
+
+      when (text = @ss.scan(/[\w\$]+/i))
+         action { [:identifier, text] }
+
+      when (text = @ss.scan(/----/i))
+        ;
+
+      when (text = @ss.scan(/require/i))
+        ;
+
+      else
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    when :STRS
+      case
+      when (text = @ss.scan(/\'/i))
+         action { @state = nil;    [:single_quote, text] }
+
+      when (text = @ss.scan(/.*?(?=(?<!\\)\')/i))
+         action {                  [:character_string_literal, text.gsub("''", "'")] }
+
+      else
+        text = @ss.string[@ss.pos .. -1]
+        raise  ScanError, "can not match: '" + text + "'"
+      end  # if
+
+    when :STRD
+      case
+      when (text = @ss.scan(/\"/i))
+         action { @state = nil;    [:double_quote, text] }
+
+      when (text = @ss.scan(/.*?(?=(?<!\\)\")/i))
+         action {                  [:character_string_literal, text.gsub('""', '"')] }
+
+      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
+
+end # class
+
+if __FILE__ == $0
+  exit  if ARGV.size != 1
+  filename = ARGV.shift
+  rex = SQLParser::Parser.new
+  begin
+    rex.load_file  filename
+    while  token = rex.next_token
+      p token
+    end
+  rescue
+    $stderr.printf  "%s:%d:%s\n", rex.filename, rex.lineno, $!.message
+  end
+end