sql-parser2 0.0.3

data/lib/sql-parser/parser.rex

@@ -0,0 +1,106 @@
+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] }
+            UPDATE        { [:UPDATE, text] }
+            DELETE        { [:DELETE, 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] }
+            INSERT        { [:INSERT, text] }
+            INTO          { [:INTO, 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] }
+            VALUES        { [:VALUES, text] }
+            SET           { [:SET, 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,298 @@
+#--
+# 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;  [:quote, text] }
+
+      when (text = @ss.scan(/\"/i))
+         action { @state = :STRD;  [: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/i))
+         action { [:SELECT, text] }
+
+      when (text = @ss.scan(/UPDATE/i))
+         action { [:UPDATE, text] }
+
+      when (text = @ss.scan(/DELETE/i))
+         action { [:DELETE, text] }
+
+      when (text = @ss.scan(/DATE/i))
+         action { [:DATE, text] }
+
+      when (text = @ss.scan(/ASC/i))
+         action { [:ASC, text] }
+
+      when (text = @ss.scan(/AS/i))
+         action { [:AS, text] }
+
+      when (text = @ss.scan(/FROM/i))
+         action { [:FROM, text] }
+
+      when (text = @ss.scan(/WHERE/i))
+         action { [:WHERE, text] }
+
+      when (text = @ss.scan(/BETWEEN/i))
+         action { [:BETWEEN, text] }
+
+      when (text = @ss.scan(/AND/i))
+         action { [:AND, text] }
+
+      when (text = @ss.scan(/NOT/i))
+         action { [:NOT, text] }
+
+      when (text = @ss.scan(/INNER/i))
+         action { [:INNER, text] }
+
+      when (text = @ss.scan(/INSERT/i))
+         action { [:INSERT, text] }
+
+      when (text = @ss.scan(/INTO/i))
+         action { [:INTO, text] }
+
+      when (text = @ss.scan(/IN/i))
+         action { [:IN, text] }
+
+      when (text = @ss.scan(/ORDER/i))
+         action { [:ORDER, text] }
+
+      when (text = @ss.scan(/OR/i))
+         action { [:OR, text] }
+
+      when (text = @ss.scan(/LIKE/i))
+         action { [:LIKE, text] }
+
+      when (text = @ss.scan(/IS/i))
+         action { [:IS, text] }
+
+      when (text = @ss.scan(/NULL/i))
+         action { [:NULL, text] }
+
+      when (text = @ss.scan(/COUNT/i))
+         action { [:COUNT, text] }
+
+      when (text = @ss.scan(/AVG/i))
+         action { [:AVG, text] }
+
+      when (text = @ss.scan(/MAX/i))
+         action { [:MAX, text] }
+
+      when (text = @ss.scan(/MIN/i))
+         action { [:MIN, text] }
+
+      when (text = @ss.scan(/SUM/i))
+         action { [:SUM, text] }
+
+      when (text = @ss.scan(/GROUP/i))
+         action { [:GROUP, text] }
+
+      when (text = @ss.scan(/BY/i))
+         action { [:BY, text] }
+
+      when (text = @ss.scan(/HAVING/i))
+         action { [:HAVING, text] }
+
+      when (text = @ss.scan(/CROSS/i))
+         action { [:CROSS, text] }
+
+      when (text = @ss.scan(/JOIN/i))
+         action { [:JOIN, text] }
+
+      when (text = @ss.scan(/ON/i))
+         action { [:ON, text] }
+
+      when (text = @ss.scan(/LEFT/i))
+         action { [:LEFT, text] }
+
+      when (text = @ss.scan(/OUTER/i))
+         action { [:OUTER, text] }
+
+      when (text = @ss.scan(/RIGHT/i))
+         action { [:RIGHT, text] }
+
+      when (text = @ss.scan(/FULL/i))
+         action { [:FULL, text] }
+
+      when (text = @ss.scan(/USING/i))
+         action { [:USING, text] }
+
+      when (text = @ss.scan(/EXISTS/i))
+         action { [:EXISTS, text] }
+
+      when (text = @ss.scan(/DESC/i))
+         action { [:DESC, text] }
+
+      when (text = @ss.scan(/CURRENT_USER/i))
+         action { [:CURRENT_USER, text] }
+
+      when (text = @ss.scan(/VALUES/i))
+         action { [:VALUES, text] }
+
+      when (text = @ss.scan(/SET/i))
+         action { [:SET, 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;    [: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;    [: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

data/lib/sql-parser/sql_visitor.rb

@@ -0,0 +1,385 @@
+module SQLParser
+  
+  class SQLVisitor
+    
+    def initialize
+      @negated = false
+    end
+
+    def visit(node)
+      node.accept(self)
+    end
+
+    def visit_Delete(o)
+      name = visit(o.from_clause)
+      where_clause = o.where_clause.nil? ? '' : ' ' + visit(o.where_clause)
+      "DELETE #{name}#{where_clause}"
+    end
+
+    def visit_Update(o)
+      name = visit(o.table_reference)
+      update_column_list = visit(o.update_column_list)
+      where_clause = o.where_clause.nil? ? '' : ' ' + visit(o.where_clause)
+      "UPDATE #{name} SET #{update_column_list}#{where_clause}"
+    end
+
+    def visit_UpdateColumn(o)
+      column = visit(o.column)
+      value = visit(o.value)
+      "#{column} = #{value}"
+    end
+
+    def visit_UpdateColumnList(o)
+      arrayize(o.update_columns)
+    end
+    
+    def visit_Insert(o)
+      name = visit(o.table_reference)
+      columns = ' ' + visit(o.column_list) if o.column_list
+      values = ' VALUES ' + visit(o.in_value_list)
+      "INSERT INTO #{name}#{columns}#{values}"
+    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_InColumnList(o)
+      "(#{arrayize(o.columns)})"
+    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