[NEW] supports postgresql-style string escape (e.g. E'foobar')

[NEW] supports postgresql-style interval values (e.g.  interval '2 days')
[NEW] supports standalone BEGIN and COMMIT statements
[NEW] supports postgresql's SET statements (e.g. SET client_min_messages TO 'panic')

Author: jasonallen

lib/sql_tree/node/expression.rb

@@ -49,6 +49,11 @@ def self.parse_atomic(tokens)
         else
           Variable.parse(tokens)
         end
+      elsif SQLTree::Token::STRING_ESCAPE == tokens.peek
+        tokens.consume(SQLTree::Token::STRING_ESCAPE)
+        Value.parse(tokens)
+      elsif SQLTree::Token::INTERVAL === tokens.peek
+        IntervalValue.parse(tokens)
       else
         Value.parse(tokens)
       end
@@ -333,7 +338,35 @@ def self.parse(tokens)
         return function_call
       end
     end
-    
+
+
+    # Represents a postgresql INTERVAL value. Example: interval '2 days'.
+    #
+    # The value is the literal text of the interval (e.g. "2 days").
+    class IntervalValue < SQLTree::Node::Expression
+      # The actual value this node represents.
+      leaf :value
+
+      def initialize(value) # :nodoc:
+        @value = value
+      end
+
+      # Generates an SQL representation for this value.
+      def to_sql(options = {})
+        "interval " + quote_str(@value)
+      end
+
+      def self.parse(tokens)
+        tokens.consume(SQLTree::Token::INTERVAL)
+        if SQLTree::Token::String === tokens.peek
+          self.new(tokens.next.literal)
+        else
+          raise SQLTree::Parser::UnexpectedToken.new(tokens.current, :literal)
+        end
+      end
+    end
+
+
     # Represents alitreal value in an SQL expression. This node is a leaf node
     # and thus has no child nodes.
     #
@@ -345,14 +378,14 @@ def self.parse(tokens)
     # * an integer or decimal value, which is represented by an appropriate 
     #   <tt>Numeric</tt> instance.
     class Value  < SQLTree::Node::Expression
-      
+
       # The actual value this node represents.
       leaf :value
 
       def initialize(value) # :nodoc:
         @value = value
       end
-      
+
       # Generates an SQL representation for this value.
       #
       # This method supports nil, string, numeric, date and time values.
@@ -389,7 +422,7 @@ def self.parse(tokens)
         end
       end
     end
-    
+
     # Represents a variable within an SQL expression. This is a leaf node, so it
     # does not have any child nodes. A variale can point to a field of a table or 
     # to another expression that was declared elsewhere.

lib/sql_tree/parser.rb

@@ -116,6 +116,9 @@ def parse!
     when SQLTree::Token::INSERT then SQLTree::Node::InsertQuery.parse(self)
     when SQLTree::Token::DELETE then SQLTree::Node::DeleteQuery.parse(self)
     when SQLTree::Token::UPDATE then SQLTree::Node::UpdateQuery.parse(self)
+    when SQLTree::Token::BEGIN  then SQLTree::Node::BeginStatement.parse(self)
+    when SQLTree::Token::COMMIT then SQLTree::Node::CommitStatement.parse(self)
+    when SQLTree::Token::SET    then SQLTree::Node::SetQuery.parse(self)
     else raise UnexpectedToken.new(self.peek)
     end
   end

lib/sql_tree/token.rb

@@ -140,10 +140,12 @@ def inspect # :nodoc:
   RPAREN = Class.new(SQLTree::Token).new(')')
   DOT    = Class.new(SQLTree::Token).new('.')
   COMMA  = Class.new(SQLTree::Token).new(',')
+  STRING_ESCAPE = Class.new(SQLTree::Token).new('E')
 
   # A list of all the SQL reserverd keywords.
   KEYWORDS = %w{SELECT FROM WHERE GROUP HAVING ORDER DISTINCT LEFT RIGHT INNER FULL OUTER NATURAL JOIN USING
-                AND OR NOT AS ON IS NULL BY LIKE ILIKE BETWEEN IN ASC DESC INSERT INTO VALUES DELETE UPDATE SET}
+                AND OR NOT AS ON IS NULL BY LIKE ILIKE BETWEEN IN ASC DESC INSERT INTO VALUES DELETE UPDATE
+                SET BEGIN COMMIT TO INTERVAL}
 
   # Create a token for all the reserved keywords in SQL
   KEYWORDS.each { |kw| const_set(kw, Class.new(SQLTree::Token::Keyword)) }

lib/sql_tree/tokenizer.rb

@@ -94,6 +94,7 @@ def each_token(&block) # :yields: SQLTree::Token
       when ',';            handle_token(SQLTree::Token::COMMA, &block)
       when /\d/;           tokenize_number(&block)
       when "'";            tokenize_quoted_string(&block)
+      when 'E';            tokenize_possible_escaped_string(&block)
       when /\w/;           tokenize_keyword(&block)
       when OPERATOR_CHARS; tokenize_operator(&block)
       when SQLTree.identifier_quote_char; tokenize_quoted_identifier(&block)
@@ -106,6 +107,17 @@ def each_token(&block) # :yields: SQLTree::Token
 
   alias :each :each_token
 
+  # Tokenizes a something that could be a 'postgresql'-styled string (e.g.
+  # E'foobar'). If the very next char isn't a single quote, then it falls back
+  # to tokenizing a keyword.
+  def tokenize_possible_escaped_string(&block)
+    if peek_char == "'"
+      handle_token(SQLTree::Token::STRING_ESCAPE, &block)
+    else
+      tokenize_keyword(&block)
+    end
+  end
+
   # Tokenizes a eyword in the code. This can either be a reserved SQL keyword
   # or a variable. This method will yield variables directly. Keywords will be
   # yielded with a delay, because they may need to be combined with other

spec/integration/parse_and_generate_spec.rb

@@ -80,4 +80,23 @@
     SQLTree['UPDATE  table  SET  field1  = 123 WHERE   id  = 17'].to_sql.should ==
             'UPDATE "table" SET "field1" = 123 WHERE ("id" = 17)'
   end
+
+  it "should parse and generate a SET query" do
+    SQLTree["SET client_min_messages TO 'panic'"].to_sql.should ==
+            "SET \"client_min_messages\" TO 'panic'"
+  end
+
+  it "should parse and generate a BEGIN statement" do
+    SQLTree["BEGIN"].to_sql.should == "BEGIN"
+  end
+
+  it "should parse and generate a COMMIT statement" do
+    SQLTree["COMMIT"].to_sql.should == "COMMIT"
+  end
+
+  # TODO: make this work
+  # it "should parse and generate a SELECT query with a function that takes star as arg" do
+  #   SQLTree["SELECT count(*) FROM jobs"].to_sql.should ==
+  #     "SELECT count(*) FROM jobs"
+  # end
 end

spec/unit/expression_node_spec.rb

@@ -19,6 +19,16 @@
       function.arguments.should == [SQLTree::Node::Expression::Value.new('string')]
     end
 
+    it "shoud parse an escaped string correctly" do
+      string = SQLTree::Node::Expression["E'string'"]
+      string.should == SQLTree::Node::Expression::Value.new("string")
+    end
+
+    it "should parse a postgresql interval expression correctly" do
+      interval = SQLTree::Node::Expression["interval '2 hours'"]
+      interval.value.should == "2 hours"
+    end
+
     it "should parse a logical OR expression correctly" do
       logical = SQLTree::Node::Expression["'this' OR 'that"]
       logical.operator.should == 'OR'

spec/unit/tokenizer_spec.rb

@@ -11,6 +11,10 @@
       SQLTree::Tokenizer.tokenize('and').should tokenize_to(:and)
     end
 
+    it "should tokenize a begin SQL keyword" do
+      SQLTree::Tokenizer.tokenize('BEGIN').should tokenize_to(:begin)
+    end
+
     it "should tokenize muliple separate keywords" do
       SQLTree::Tokenizer.tokenize('SELECT DISTINCT').should tokenize_to(:select, :distinct)
     end
@@ -58,6 +62,14 @@
     it "should tokenize commas" do
       SQLTree::Tokenizer.tokenize('a , "b"').should tokenize_to(sql_var('a'), comma, sql_var('b'))
     end
+
+    it "should tokenize postgresql string escape token" do
+      SQLTree::Tokenizer.tokenize("E'foo'").should tokenize_to(:string_escape, "foo")
+    end
+
+    it "should tokenize postgresql interval statements" do
+      SQLTree::Tokenizer.tokenize("interval '2 days'").should tokenize_to(:interval, "2 days")
+    end
   end
 
   # # Combined tokens are disabled for now;
@@ -77,6 +89,10 @@
     it "should tokenize a function call" do
       SQLTree::Tokenizer.tokenize("MD5('test')").should tokenize_to(sql_var('MD5'), lparen, 'test', rparen)
     end
+
+    it "should tokenize a posgresql SET call" do
+      SQLTree::Tokenizer.tokenize("SET client_min_messages TO 'panic'").should tokenize_to(:set, sql_var('client_min_messages'), :to, 'panic')
+    end
   end
 
 end