added support for LIMIT in queries

Author: andykent

lib/grammar.coffee

@@ -15,19 +15,24 @@ grammar =
   ]
 
   Query: [
+    o "SelectWithLimitQuery"
     o "SelectQuery"
   ]
 
   SelectQuery: [
     o 'Select'
-    o 'Select OrderClause',                           -> $1.order = $2; $1
-    o 'Select GroupClause',                           -> $1.group = $2; $1
-    o 'Select GroupClause OrderClause',               -> $1.group = $2; $1.order = $3; $1
+    o 'Select OrderClause',                               -> $1.order = $2; $1
+    o 'Select GroupClause',                               -> $1.group = $2; $1
+    o 'Select GroupClause OrderClause',                   -> $1.group = $2; $1.order = $3; $1
+  ]
+  
+  SelectWithLimitQuery: [
+    o 'SelectQuery LimitClause',                          -> $1.limit = $2; $1
   ]
 
   Select: [
     o 'SelectClause'
-    o 'SelectClause WhereClause',                     -> $1.where = $2; $1
+    o 'SelectClause WhereClause',                         -> $1.where = $2; $1
   ]
 
   SelectClause: [
@@ -38,6 +43,10 @@ grammar =
     o 'WHERE Conditions',                                 -> new Where($2)
   ]
 
+  LimitClause: [
+    o 'LIMIT Number',                                 -> new Limit($2)
+  ]
+  
   # TODO: order by can take mulitple sorts and also the direction is optional
   OrderClause: [
     o 'ORDER BY Value DIRECTION',                         -> new Order($3, $4)
@@ -68,9 +77,17 @@ grammar =
 
   Value: [
     o 'Literal'
+    o 'Number'
+    o 'String'
+    o 'Function'
+  ]
+  
+  Number: [
     o 'NUMBER',                                           -> new NumberValue($1)
+  ]
+  
+  String: [
     o 'STRING',                                           -> new StringValue($1)
-    o 'Function'
   ]
 
   Literal: [

lib/lexer.coffee

@@ -56,6 +56,7 @@ class Lexer
     @tokenizeFromWord('ORDER') or
     @tokenizeFromWord('BY') or
     @tokenizeFromWord('HAVING') or
+    @tokenizeFromWord('LIMIT') or
     @tokenizeFromWord('AS')
   operatorToken:    -> @tokenizeFromList('OPERATOR', SQL_OPERATORS)  
   conditionalToken: -> @tokenizeFromList('CONDITIONAL', SQL_CONDITIONALS)

lib/nodes.coffee

@@ -3,12 +3,14 @@ exports.Select = class Select
       @order = null
       @group = null
       @where = null
+      @limit = null
     toString: ->
       ret = ["SELECT #{@fields.join(', ')}"] 
       ret.push "FROM #{@source}"
       ret.push @where.toString() if @where
       ret.push @group.toString() if @group
       ret.push @order.toString() if @order
+      ret.push @limit.toString() if @limit
       ret.join("\n  ")
 
 exports.LiteralValue = class LiteralValue
@@ -27,6 +29,10 @@ exports.Order = class Order
   constructor: (@value, @direction='ASC') -> null
   toString: -> "ORDER BY #{@value} #{@direction}"
 
+exports.Limit = class Limit
+  constructor: (@value) -> null
+  toString: -> "LIMIT #{@value}"
+
 exports.Group = class Group
   constructor: (@values) ->
     @having = null

spec/grammar.spec.coffee

@@ -20,6 +20,13 @@ describe "SQL Grammer", ->
         GROUP BY `x`, `y`
       """
 
+    it "parses LIMIT clauses", ->
+      expect(parse("SELECT * FROM my_table LIMIT 10").toString()).toEqual """
+      SELECT *
+        FROM `my_table`
+        LIMIT 10
+      """
+    
     it "parses WHERE clauses", ->
       expect(parse("SELECT * FROM my_table WHERE x > 1 AND y = 'foo'").toString()).toEqual """
       SELECT *