sql-parser 0.0.1

data/lib/sql-parser/parser.rex

@@ -0,0 +1,100 @@
+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+
+
+rule
+# [:state]  pattern       [actions]
+
+# literals
+            \"{DATE}\"    { [:date_string, Date.parse(text)] }
+            \'{DATE}\'    { [:date_string, Date.parse(text)] }
+
+            \'            { state = :STRS;  [:quote, text] }
+  :STRS     \'            { state = nil;    [:quote, text] }
+  :STRS     .*(?=\')      {                 [:character_string_literal, text.gsub("''", "'")] }
+
+            \"            { state = :STRD;  [:quote, text] }
+  :STRD     \"            { state = nil;    [:quote, text] }
+  :STRD     .*(?=\")      {                 [:character_string_literal, text.gsub('""', '"')] }
+
+            {UINT}        { [:unsigned_integer, text.to_i] }
+
+# skip
+            {BLANK}       # no action
+
+# keywords
+            SELECT        { [:SELECT, text] }
+            DATE          { [:DATE, text] }
+            ASC           { [:ASC, text] }
+            AS            { [:AS, text] }
+            FROM          { [:FROM, text] }
+            WHERE         { [:WHERE, text] }
+            BETWEEN       { [:BETWEEN, text] }
+            AND           { [:AND, text] }
+            NOT           { [:NOT, text] }
+            INNER         { [:INNER, text] }
+            IN            { [:IN, text] }
+            ORDER         { [:ORDER, text] }
+            OR            { [:OR, text] }
+            LIKE          { [:LIKE, text] }
+            IS            { [:IS, text] }
+            NULL          { [:NULL, text] }
+            COUNT         { [:COUNT, text] }
+            AVG           { [:AVG, text] }
+            MAX           { [:MAX, text] }
+            MIN           { [:MIN, text] }
+            SUM           { [:SUM, text] }
+            GROUP         { [:GROUP, text] }
+            BY            { [:BY, text] }
+            HAVING        { [:HAVING, text] }
+            CROSS         { [:CROSS, text] }
+            JOIN          { [:JOIN, text] }
+            ON            { [:ON, text] }
+            LEFT          { [:LEFT, text] }
+            OUTER         { [:OUTER, text] }
+            RIGHT         { [:RIGHT, text] }
+            FULL          { [:FULL, text] }
+            USING         { [:USING, text] }
+            EXISTS        { [:EXISTS, text] }
+            DESC          { [:DESC, text] }
+            CURRENT_USER  { [:CURRENT_USER, 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,273 @@
+module SQLParser
+
+  class Parser < Racc::Parser
+  
+    class ScanError < StandardError ; end
+
+    attr_reader :lineno
+    attr_reader :filename
+
+    def scan_setup ; end
+
+    def action &block
+      yield
+    end
+
+    def scan_str( str )
+      scan_evaluate  str
+      do_parse
+    end
+
+    def load_file( filename )
+      @filename = filename
+      open(filename, "r") do |f|
+        scan_evaluate  f.read
+      end
+    end
+
+    def scan_file( filename )
+      load_file  filename
+      do_parse
+    end
+
+    def next_token
+      @rex_tokens.shift
+    end
+
+    def scan_evaluate( str )
+      scan_setup
+      @rex_tokens = []
+      @lineno  =  1
+      ss = StringScanner.new(str)
+      state = nil
+      until ss.eos?
+        text = ss.peek(1)
+        @lineno  +=  1  if text == "\n"
+        case state
+        when nil
+          case
+          when (text = ss.scan(/\"[0-9]+-[0-9]+-[0-9]+\"/i))
+             @rex_tokens.push action { [:date_string, Date.parse(text)] }
+
+          when (text = ss.scan(/\'[0-9]+-[0-9]+-[0-9]+\'/i))
+             @rex_tokens.push action { [:date_string, Date.parse(text)] }
+
+          when (text = ss.scan(/\'/i))
+             @rex_tokens.push action { state = :STRS;  [:quote, text] }
+
+          when (text = ss.scan(/\"/i))
+             @rex_tokens.push action { state = :STRD;  [:quote, text] }
+
+          when (text = ss.scan(/[0-9]+/i))
+             @rex_tokens.push action { [:unsigned_integer, text.to_i] }
+
+          when (text = ss.scan(/\s+/i))
+            ;
+
+          when (text = ss.scan(/SELECT/i))
+             @rex_tokens.push action { [:SELECT, text] }
+
+          when (text = ss.scan(/DATE/i))
+             @rex_tokens.push action { [:DATE, text] }
+
+          when (text = ss.scan(/ASC/i))
+             @rex_tokens.push action { [:ASC, text] }
+
+          when (text = ss.scan(/AS/i))
+             @rex_tokens.push action { [:AS, text] }
+
+          when (text = ss.scan(/FROM/i))
+             @rex_tokens.push action { [:FROM, text] }
+
+          when (text = ss.scan(/WHERE/i))
+             @rex_tokens.push action { [:WHERE, text] }
+
+          when (text = ss.scan(/BETWEEN/i))
+             @rex_tokens.push action { [:BETWEEN, text] }
+
+          when (text = ss.scan(/AND/i))
+             @rex_tokens.push action { [:AND, text] }
+
+          when (text = ss.scan(/NOT/i))
+             @rex_tokens.push action { [:NOT, text] }
+
+          when (text = ss.scan(/INNER/i))
+             @rex_tokens.push action { [:INNER, text] }
+
+          when (text = ss.scan(/IN/i))
+             @rex_tokens.push action { [:IN, text] }
+
+          when (text = ss.scan(/ORDER/i))
+             @rex_tokens.push action { [:ORDER, text] }
+
+          when (text = ss.scan(/OR/i))
+             @rex_tokens.push action { [:OR, text] }
+
+          when (text = ss.scan(/LIKE/i))
+             @rex_tokens.push action { [:LIKE, text] }
+
+          when (text = ss.scan(/IS/i))
+             @rex_tokens.push action { [:IS, text] }
+
+          when (text = ss.scan(/NULL/i))
+             @rex_tokens.push action { [:NULL, text] }
+
+          when (text = ss.scan(/COUNT/i))
+             @rex_tokens.push action { [:COUNT, text] }
+
+          when (text = ss.scan(/AVG/i))
+             @rex_tokens.push action { [:AVG, text] }
+
+          when (text = ss.scan(/MAX/i))
+             @rex_tokens.push action { [:MAX, text] }
+
+          when (text = ss.scan(/MIN/i))
+             @rex_tokens.push action { [:MIN, text] }
+
+          when (text = ss.scan(/SUM/i))
+             @rex_tokens.push action { [:SUM, text] }
+
+          when (text = ss.scan(/GROUP/i))
+             @rex_tokens.push action { [:GROUP, text] }
+
+          when (text = ss.scan(/BY/i))
+             @rex_tokens.push action { [:BY, text] }
+
+          when (text = ss.scan(/HAVING/i))
+             @rex_tokens.push action { [:HAVING, text] }
+
+          when (text = ss.scan(/CROSS/i))
+             @rex_tokens.push action { [:CROSS, text] }
+
+          when (text = ss.scan(/JOIN/i))
+             @rex_tokens.push action { [:JOIN, text] }
+
+          when (text = ss.scan(/ON/i))
+             @rex_tokens.push action { [:ON, text] }
+
+          when (text = ss.scan(/LEFT/i))
+             @rex_tokens.push action { [:LEFT, text] }
+
+          when (text = ss.scan(/OUTER/i))
+             @rex_tokens.push action { [:OUTER, text] }
+
+          when (text = ss.scan(/RIGHT/i))
+             @rex_tokens.push action { [:RIGHT, text] }
+
+          when (text = ss.scan(/FULL/i))
+             @rex_tokens.push action { [:FULL, text] }
+
+          when (text = ss.scan(/USING/i))
+             @rex_tokens.push action { [:USING, text] }
+
+          when (text = ss.scan(/EXISTS/i))
+             @rex_tokens.push action { [:EXISTS, text] }
+
+          when (text = ss.scan(/DESC/i))
+             @rex_tokens.push action { [:DESC, text] }
+
+          when (text = ss.scan(/CURRENT_USER/i))
+             @rex_tokens.push action { [:CURRENT_USER, text] }
+
+          when (text = ss.scan(/E/i))
+             @rex_tokens.push action { [:E, text] }
+
+          when (text = ss.scan(/<>/i))
+             @rex_tokens.push action { [:not_equals_operator, text] }
+
+          when (text = ss.scan(/!=/i))
+             @rex_tokens.push action { [:not_equals_operator, text] }
+
+          when (text = ss.scan(/=/i))
+             @rex_tokens.push action { [:equals_operator, text] }
+
+          when (text = ss.scan(/<=/i))
+             @rex_tokens.push action { [:less_than_or_equals_operator, text] }
+
+          when (text = ss.scan(/</i))
+             @rex_tokens.push action { [:less_than_operator, text] }
+
+          when (text = ss.scan(/>=/i))
+             @rex_tokens.push action { [:greater_than_or_equals_operator, text] }
+
+          when (text = ss.scan(/>/i))
+             @rex_tokens.push action { [:greater_than_operator, text] }
+
+          when (text = ss.scan(/\(/i))
+             @rex_tokens.push action { [:left_paren, text] }
+
+          when (text = ss.scan(/\)/i))
+             @rex_tokens.push action { [:right_paren, text] }
+
+          when (text = ss.scan(/\*/i))
+             @rex_tokens.push action { [:asterisk, text] }
+
+          when (text = ss.scan(/\//i))
+             @rex_tokens.push action { [:solidus, text] }
+
+          when (text = ss.scan(/\+/i))
+             @rex_tokens.push action { [:plus_sign, text] }
+
+          when (text = ss.scan(/\-/i))
+             @rex_tokens.push action { [:minus_sign, text] }
+
+          when (text = ss.scan(/\./i))
+             @rex_tokens.push action { [:period, text] }
+
+          when (text = ss.scan(/,/i))
+             @rex_tokens.push action { [:comma, text] }
+
+          when (text = ss.scan(/`\w+`/i))
+             @rex_tokens.push action { [:identifier, text[1..-2]] }
+
+          when (text = ss.scan(/\w+/i))
+             @rex_tokens.push 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))
+             @rex_tokens.push action { state = nil;    [:quote, text] }
+
+          when (text = ss.scan(/.*(?=\')/i))
+             @rex_tokens.push 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))
+             @rex_tokens.push action { state = nil;    [:quote, text] }
+
+          when (text = ss.scan(/.*(?=\")/i))
+             @rex_tokens.push 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
+           
+      end  
+           
+    end
+       
+  end
+     
+end   

data/lib/sql-parser/sql_visitor.rb

@@ -0,0 +1,351 @@
+module SQLParser
+  
+  class SQLVisitor
+    
+    def initialize
+      @negated = false
+    end
+
+    def visit(node)
+      node.accept(self)
+    end
+
+    def visit_DirectSelect(o)
+      [
+        o.query_expression,
+        o.order_by
+      ].compact.collect { |e| visit(e) }.join(' ')
+    end
+
+    def visit_OrderBy(o)
+      "ORDER BY #{arrayize(o.sort_specification)}"
+    end
+
+    def visit_Subquery(o)
+      "(#{visit(o.query_specification)})"
+    end
+
+    def visit_Select(o)
+      # FIXME: This feels like a hack
+      initialize
+
+      "SELECT #{visit_all([o.list, o.table_expression].compact).join(' ')}"
+    end
+
+    def visit_SelectList(o)
+      arrayize(o.columns)
+    end
+
+    def visit_Distinct(o)
+      "DISTINCT(#{visit(o.column)})"
+    end
+
+    def visit_All(o)
+      '*'
+    end
+
+    def visit_TableExpression(o)
+      [
+        o.from_clause,
+        o.where_clause,
+        o.group_by_clause,
+        o.having_clause
+      ].compact.collect { |e| visit(e) }.join(' ')
+    end
+
+    def visit_FromClause(o)
+      "FROM #{arrayize(o.tables)}"
+    end
+
+    def visit_OrderClause(o)
+      "ORDER BY #{arrayize(o.columns)}"
+    end
+
+    def visit_Ascending(o)
+      "#{visit(o.column)} ASC"
+    end
+
+    def visit_Descending(o)
+      "#{visit(o.column)} DESC"
+    end
+
+    def visit_HavingClause(o)
+      "HAVING #{visit(o.search_condition)}"
+    end
+
+    def visit_GroupByClause(o)
+      "GROUP BY #{arrayize(o.columns)}"
+    end
+
+    def visit_WhereClause(o)
+      "WHERE #{visit(o.search_condition)}"
+    end
+
+    def visit_On(o)
+      "ON #{visit(o.search_condition)}"
+    end
+
+    def visit_Using(o)
+      "USING (#{arrayize(o.columns)})"
+    end
+
+    def visit_Or(o)
+      search_condition('OR', o)
+    end
+
+    def visit_And(o)
+      search_condition('AND', o)
+    end
+
+    def visit_Exists(o)
+      if @negated
+        "NOT EXISTS #{visit(o.table_subquery)}"
+      else
+        "EXISTS #{visit(o.table_subquery)}"
+      end
+    end
+
+    def visit_Is(o)
+      if @negated
+        comparison('IS NOT', o)
+      else
+        comparison('IS', o)
+      end
+    end
+
+    def visit_Like(o)
+      if @negated
+        comparison('NOT LIKE', o)
+      else
+        comparison('LIKE', o)
+      end
+    end
+
+    def visit_In(o)
+      if @negated
+        comparison('NOT IN', o)
+      else
+        comparison('IN', o)
+      end
+    end
+
+    def visit_InValueList(o)
+      "(#{arrayize(o.values)})"
+    end
+
+    def visit_Between(o)
+      if @negated
+        "#{visit(o.left)} NOT BETWEEN #{visit(o.min)} AND #{visit(o.max)}"
+      else
+        "#{visit(o.left)} BETWEEN #{visit(o.min)} AND #{visit(o.max)}"
+      end
+    end
+
+    def visit_GreaterOrEquals(o)
+      comparison('>=', o)
+    end
+
+    def visit_LessOrEquals(o)
+      comparison('<=', o)
+    end
+
+    def visit_Greater(o)
+      comparison('>', o)
+    end
+
+    def visit_Less(o)
+      comparison('<', o)
+    end
+
+    def visit_Equals(o)
+      if @negated
+        comparison('<>', o)
+      else
+        comparison('=', o)
+      end
+    end
+
+    def visit_Sum(o)
+      aggregate('SUM', o)
+    end
+
+    def visit_Minimum(o)
+      aggregate('MIN', o)
+    end
+
+    def visit_Maximum(o)
+      aggregate('MAX', o)
+    end
+
+    def visit_Average(o)
+      aggregate('AVG', o)
+    end
+
+    def visit_Count(o)
+      aggregate('COUNT', o)
+    end
+
+    def visit_CrossJoin(o)
+      "#{visit(o.left)} CROSS JOIN #{visit(o.right)}"
+    end
+
+    def visit_InnerJoin(o)
+      qualified_join('INNER', o)
+    end
+
+    def visit_LeftJoin(o)
+      qualified_join('LEFT', o)
+    end
+
+    def visit_LeftOuterJoin(o)
+      qualified_join('LEFT OUTER', o)
+    end
+
+    def visit_RightJoin(o)
+      qualified_join('RIGHT', o)
+    end
+
+    def visit_RightOuterJoin(o)
+      qualified_join('RIGHT OUTER', o)
+    end
+
+    def visit_FullJoin(o)
+      qualified_join('FULL', o)
+    end
+
+    def visit_FullOuterJoin(o)
+      qualified_join('FULL OUTER', o)
+    end
+
+    def visit_Table(o)
+      quote(o.name)
+    end
+
+    def visit_QualifiedColumn(o)
+      "#{visit(o.table)}.#{visit(o.column)}"
+    end
+
+    def visit_Column(o)
+      quote(o.name)
+    end
+
+    def visit_As(o)
+      "#{visit(o.value)} AS #{visit(o.column)}"
+    end
+
+    def visit_Multiply(o)
+      arithmetic('*', o)
+    end
+
+    def visit_Divide(o)
+      arithmetic('/', o)
+    end
+
+    def visit_Add(o)
+      arithmetic('+', o)
+    end
+
+    def visit_Subtract(o)
+      arithmetic('-', o)
+    end
+
+    def visit_Not(o)
+      negate { visit(o.value) }
+    end
+
+    def visit_UnaryPlus(o)
+      "+#{visit(o.value)}"
+    end
+
+    def visit_UnaryMinus(o)
+      "-#{visit(o.value)}"
+    end
+
+    def visit_True(o)
+      'TRUE'
+    end
+
+    def visit_False(o)
+      'FALSE'
+    end
+
+    def visit_Null(o)
+      'NULL'
+    end
+
+    def visit_CurrentUser(o)
+      'CURRENT_USER'
+    end
+
+    def visit_DateTime(o)
+      "'%s'" % escape(o.value.strftime('%Y-%m-%d %H:%M:%S'))
+    end
+
+    def visit_Date(o)
+      "DATE '%s'" % escape(o.value.strftime('%Y-%m-%d'))
+    end
+
+    def visit_String(o)
+      "'%s'" % escape(o.value)
+    end
+
+    def visit_ApproximateFloat(o)
+      "#{visit(o.mantissa)}E#{visit(o.exponent)}"
+    end
+
+    def visit_Float(o)
+      o.value.to_s
+    end
+
+    def visit_Integer(o)
+      o.value.to_s
+    end
+
+    private
+
+    def negate
+      @negated = true
+      yield
+    ensure
+      @negated = false
+    end
+
+    def quote(str)
+      "`#{str}`"
+    end
+
+    def escape(str)
+      str.gsub(/'/, "''")
+    end
+
+    def arithmetic(operator, o)
+      search_condition(operator, o)
+    end
+
+    def comparison(operator, o)
+      [visit(o.left), operator, visit(o.right)].join(' ')
+    end
+
+    def search_condition(operator, o)
+      "(#{visit(o.left)} #{operator} #{visit(o.right)})"
+    end
+
+    def visit_all(nodes)
+      nodes.collect { |e| visit(e) }
+    end
+
+    def arrayize(arr)
+      visit_all(arr).join(', ')
+    end
+
+    def aggregate(function_name, o)
+      "#{function_name}(#{visit(o.column)})"
+    end
+
+    def qualified_join(join_type, o)
+      "#{visit(o.left)} #{join_type} JOIN #{visit(o.right)} #{visit(o.search_condition)}"
+    end
+    
+  end
+  
+end