sparkql 1.1.17 → 1.2.0

data/lib/sparkql/parser.rb

@@ -16,72 +16,86 @@ module Sparkql
 ##### State transition tables begin ###
 
 racc_action_table = [
-    35,    14,    15,    43,    44,    34,    45,    46,    47,    14,
-    22,    31,    32,    33,    36,    37,    38,    39,    40,    35,
-    17,    16,    23,    49,    34,    50,    10,    11,    14,   -28,
-    31,    32,    33,    36,    37,    38,    39,    40,    35,    56,
-    60,    17,    16,    34,    61,    10,    11,    14,    59,    31,
-    32,    33,    36,    37,    38,    39,    40,    35,    18,    19,
-    35,    64,    34,   nil,   nil,    34,   nil,   nil,    31,    32,
-    33,    31,    32,    33,    35,    14,   nil,    43,    44,    34,
-    45,    46,    47,    14,   nil,    31,    32,    33,     8,   nil,
-     9,   nil,    10,    11,    14,     8,   nil,     9,   nil,    10,
-    11,    14,     9,   nil,    10,    11,    14,     9,   nil,    10,
-    11,    14,     9,   nil,    10,    11,    14 ]
+    36,    14,    72,    44,    45,    35,    46,    47,    48,    14,
+    58,    32,    33,    34,    37,    38,    39,    40,    41,    36,
+    22,    62,    18,    19,    35,    63,    10,    11,    14,    23,
+    32,    33,    34,    37,    38,    39,    40,    41,    36,    17,
+    16,    61,    50,    35,    51,    10,    11,    14,    15,    32,
+    33,    34,    37,    38,    39,    40,    41,    36,    17,    16,
+    75,    57,    35,    66,    76,   -35,    14,   nil,    32,    33,
+    34,    37,    38,    39,    40,    41,    36,    14,   nil,    44,
+    45,    35,    46,    47,    48,    14,   nil,    32,    33,    34,
+    37,    38,    39,    40,    41,    36,   nil,   nil,    36,   nil,
+    35,   nil,   nil,    35,    14,   nil,    32,    33,    34,    32,
+    33,    34,    36,   nil,     8,   nil,     9,    35,    10,    11,
+    14,   nil,   nil,    32,    33,    34,     8,   nil,     9,   nil,
+    10,    11,    14,     9,   nil,    10,    11,    14,     9,   nil,
+    10,    11,    14,     9,   nil,    10,    11,    14 ]
 
 racc_action_check = [
-    18,    19,     1,    19,    19,    18,    19,    19,    19,    18,
-    13,    18,    18,    18,    18,    18,    18,    18,    18,    22,
-    21,    21,    15,    21,    22,    22,    22,    22,    22,    28,
-    22,    22,    22,    22,    22,    22,    22,    22,    61,    29,
-    51,     2,     2,    61,    51,    61,    61,    61,    42,    61,
-    61,    61,    61,    61,    61,    61,    61,    34,     6,     6,
-    35,    57,    34,   nil,   nil,    35,   nil,   nil,    34,    34,
-    34,    35,    35,    35,    56,    59,   nil,    59,    59,    56,
-    59,    59,    59,    56,   nil,    56,    56,    56,     0,   nil,
-     0,   nil,     0,     0,     0,     9,   nil,     9,   nil,     9,
-     9,     9,     8,   nil,     8,     8,     8,    16,   nil,    16,
-    16,    16,    17,   nil,    17,    17,    17 ]
+    76,    61,    59,    61,    61,    76,    61,    61,    61,    76,
+    30,    76,    76,    76,    76,    76,    76,    76,    76,    63,
+    13,    52,     6,     6,    63,    52,    63,    63,    63,    15,
+    63,    63,    63,    63,    63,    63,    63,    63,    22,    21,
+    21,    43,    21,    22,    22,    22,    22,    22,     1,    22,
+    22,    22,    22,    22,    22,    22,    22,    58,     2,     2,
+    67,    29,    58,    58,    67,    28,    58,   nil,    58,    58,
+    58,    58,    58,    58,    58,    58,    18,    19,   nil,    19,
+    19,    18,    19,    19,    19,    18,   nil,    18,    18,    18,
+    18,    18,    18,    18,    18,    57,   nil,   nil,    36,   nil,
+    57,   nil,   nil,    36,    57,   nil,    57,    57,    57,    36,
+    36,    36,    35,   nil,     9,   nil,     9,    35,     9,     9,
+     9,   nil,   nil,    35,    35,    35,     0,   nil,     0,   nil,
+     0,     0,     0,    17,   nil,    17,    17,    17,    16,   nil,
+    16,    16,    16,     8,   nil,     8,     8,     8 ]
 
 racc_action_pointer = [
-    83,     2,    36,   nil,   nil,   nil,    55,   nil,    95,    90,
-   nil,   nil,   nil,     3,   nil,    22,   100,   105,    -2,   -10,
-   nil,    15,    17,   nil,   nil,   nil,   nil,   nil,    17,    27,
-   nil,   nil,   nil,   nil,    55,    58,   nil,   nil,   nil,   nil,
-   nil,   nil,    36,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
-   nil,    32,   nil,   nil,   nil,   nil,    72,    53,   nil,    64,
-   nil,    36,   nil,   nil,   nil,   nil,   nil ]
+   121,    48,    53,   nil,   nil,   nil,    19,   nil,   136,   109,
+   nil,   nil,   nil,    13,   nil,    29,   131,   126,    74,    66,
+   nil,    34,    36,   nil,   nil,   nil,   nil,   nil,    53,    49,
+     3,   nil,   nil,   nil,   nil,   110,    96,   nil,   nil,   nil,
+   nil,   nil,   nil,    29,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    13,   nil,   nil,   nil,   nil,    93,    55,    -6,
+   nil,   -10,   nil,    17,   nil,   nil,   nil,    52,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,    -2,   nil ]
 
 racc_action_default = [
-    -2,   -48,    -1,    -3,    -4,    -5,   -48,    -8,   -48,   -48,
-   -13,   -14,   -15,   -48,   -21,   -48,   -48,   -48,   -48,   -48,
-    -9,   -48,   -48,    67,   -10,   -11,    -6,   -16,   -17,   -18,
-   -27,   -32,   -33,   -34,   -48,   -48,   -37,   -38,   -39,   -40,
-   -41,    -7,   -48,   -42,   -43,   -44,   -45,   -46,   -47,   -12,
-   -19,   -48,   -22,   -24,   -25,   -26,   -48,   -48,   -36,   -48,
-   -20,   -48,   -29,   -30,   -35,   -31,   -23 ]
+    -2,   -55,    -1,    -3,    -4,    -5,   -55,    -8,   -55,   -55,
+   -13,   -14,   -15,   -55,   -23,   -55,   -55,   -55,   -55,   -55,
+    -9,   -55,   -55,    78,   -10,   -11,    -6,   -16,   -17,   -18,
+   -55,   -34,   -39,   -40,   -41,   -55,   -55,   -44,   -45,   -46,
+   -47,   -48,    -7,   -55,   -49,   -50,   -51,   -52,   -53,   -54,
+   -12,   -19,   -55,   -24,   -26,   -27,   -28,   -55,   -55,   -55,
+   -43,   -55,   -20,   -55,   -36,   -37,   -21,   -55,   -29,   -31,
+   -32,   -33,   -42,   -38,   -25,   -22,   -55,   -30 ]
 
 racc_goto_table = [
-    28,    48,    42,     2,    55,    52,    20,    30,     1,    26,
-    41,    27,    21,    29,    24,    25,    51,   nil,   nil,   nil,
-   nil,   nil,   nil,    57,    58,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    63,   nil,
-   nil,    48,    65,    55,    66,    62 ]
+    30,    27,    43,    31,    68,    56,    53,    49,     2,    28,
+    20,    52,    67,    29,    42,    26,     1,    21,    24,    25,
+    59,    60,    77,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+    30,    69,    64,    70,    73,    65,    56,    74,   nil,    49,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    30,    69,
+   nil,    70 ]
 
 racc_goto_check = [
-    10,    10,    17,     2,     6,    15,     3,    16,     1,     7,
-     8,    11,     2,    12,     3,     3,    14,   nil,   nil,   nil,
-   nil,   nil,   nil,    16,    16,   nil,   nil,   nil,   nil,   nil,
-   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    10,   nil,
-   nil,    10,    17,     6,    15,    16 ]
+    14,    11,    20,    18,    19,     6,    17,    10,     2,    12,
+     3,    15,    16,    13,     8,     7,     1,     2,     3,     3,
+    18,    18,    19,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+    14,    11,    18,    18,    20,    10,     6,    17,   nil,    10,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,   nil,    14,    11,
+   nil,    18 ]
 
 racc_goto_pointer = [
-   nil,     8,     3,    -2,   nil,   nil,   -18,    -9,    -9,   nil,
-   -18,    -7,    -5,   nil,    -6,   -17,   -11,   -17 ]
+   nil,    16,     8,     2,   nil,   nil,   -17,    -3,    -5,   nil,
+   -12,   -17,    -9,    -5,   -18,   -11,   -46,   -16,   -15,   -54,
+   -17 ]
 
 racc_goto_default = [
    nil,   nil,   nil,     3,     4,     5,     6,   nil,   nil,     7,
-    12,    53,   nil,    13,   nil,   nil,    54,   nil ]
+    12,    54,    71,   nil,    13,   nil,   nil,   nil,    55,   nil,
+   nil ]
 
 racc_reduce_table = [
   0, 0, :racc_error,
@@ -105,37 +119,44 @@ racc_reduce_table = [
   1, 28, :_reduce_18,
   3, 31, :_reduce_19,
   4, 31, :_reduce_20,
-  1, 34, :_reduce_none,
+  3, 33, :_reduce_21,
+  4, 33, :_reduce_22,
   1, 35, :_reduce_none,
-  3, 35, :_reduce_23,
-  1, 36, :_reduce_none,
   1, 36, :_reduce_none,
-  1, 36, :_reduce_26,
-  1, 33, :_reduce_none,
-  1, 33, :_reduce_none,
-  3, 33, :_reduce_29,
-  3, 33, :_reduce_30,
-  3, 29, :_reduce_31,
-  1, 37, :_reduce_none,
-  1, 37, :_reduce_none,
+  3, 36, :_reduce_25,
+  1, 38, :_reduce_none,
+  1, 38, :_reduce_none,
+  1, 38, :_reduce_28,
   1, 37, :_reduce_none,
-  3, 37, :_reduce_35,
-  2, 37, :_reduce_36,
+  3, 37, :_reduce_30,
+  1, 40, :_reduce_none,
+  1, 40, :_reduce_none,
+  1, 40, :_reduce_none,
+  1, 34, :_reduce_none,
+  1, 34, :_reduce_none,
+  3, 34, :_reduce_36,
+  3, 34, :_reduce_37,
+  3, 29, :_reduce_38,
+  1, 39, :_reduce_none,
+  1, 39, :_reduce_none,
+  1, 39, :_reduce_none,
+  3, 39, :_reduce_42,
+  2, 39, :_reduce_43,
   1, 32, :_reduce_none,
   1, 32, :_reduce_none,
   1, 32, :_reduce_none,
   1, 32, :_reduce_none,
   1, 32, :_reduce_none,
-  1, 38, :_reduce_none,
-  1, 38, :_reduce_none,
-  1, 38, :_reduce_none,
-  1, 38, :_reduce_none,
-  1, 38, :_reduce_none,
-  1, 38, :_reduce_none ]
+  1, 41, :_reduce_none,
+  1, 41, :_reduce_none,
+  1, 41, :_reduce_none,
+  1, 41, :_reduce_none,
+  1, 41, :_reduce_none,
+  1, 41, :_reduce_none ]
 
-racc_reduce_n = 48
+racc_reduce_n = 55
 
-racc_shift_n = 67
+racc_shift_n = 78
 
 racc_token_table = {
   false => 0,
@@ -214,11 +235,14 @@ Racc_token_to_s_table = [
   "group",
   "function",
   "literal",
+  "literal_function",
   "literal_list",
   "function_name",
   "function_args",
+  "literal_function_args",
   "function_arg",
   "literals",
+  "literal_function_arg",
   "rangeable" ]
 
 Racc_debug_parser = false
@@ -297,42 +321,42 @@ def _reduce_20(val, _values, result)
     result
 end
 
-# reduce 21 omitted
-
-# reduce 22 omitted
+def _reduce_21(val, _values, result)
+ result = tokenize_function(val[0], []) 
+    result
+end
 
-def _reduce_23(val, _values, result)
- result = tokenize_function_args(val[0], val[2]) 
+def _reduce_22(val, _values, result)
+ result = tokenize_function(val[0], val[2]) 
     result
 end
 
-# reduce 24 omitted
+# reduce 23 omitted
 
-# reduce 25 omitted
+# reduce 24 omitted
 
-def _reduce_26(val, _values, result)
- result = tokenize_field_arg(val[0]) 
+def _reduce_25(val, _values, result)
+ result = tokenize_function_args(val[0], val[2]) 
     result
 end
 
-# reduce 27 omitted
+# reduce 26 omitted
 
-# reduce 28 omitted
+# reduce 27 omitted
 
-def _reduce_29(val, _values, result)
- result = tokenize_multiple(val[0], val[2]) 
+def _reduce_28(val, _values, result)
+ result = tokenize_field_arg(val[0]) 
     result
 end
 
+# reduce 29 omitted
+
 def _reduce_30(val, _values, result)
- result = tokenize_multiple(val[0], val[2]) 
+ result = tokenize_function_args(val[0], val[2]) 
     result
 end
 
-def _reduce_31(val, _values, result)
- result = tokenize_multiple(val[0], val[2]) 
-    result
-end
+# reduce 31 omitted
 
 # reduce 32 omitted
 
@@ -340,19 +364,22 @@ end
 
 # reduce 34 omitted
 
-def _reduce_35(val, _values, result)
- result = val[1] 
-    result
-end
+# reduce 35 omitted
 
 def _reduce_36(val, _values, result)
- result = tokenize_literal_negation(val[1]) 
+ result = tokenize_multiple(val[0], val[2]) 
     result
 end
 
-# reduce 37 omitted
+def _reduce_37(val, _values, result)
+ result = tokenize_multiple(val[0], val[2]) 
+    result
+end
 
-# reduce 38 omitted
+def _reduce_38(val, _values, result)
+ result = tokenize_multiple(val[0], val[2]) 
+    result
+end
 
 # reduce 39 omitted
 
@@ -360,9 +387,15 @@ end
 
 # reduce 41 omitted
 
-# reduce 42 omitted
+def _reduce_42(val, _values, result)
+ result = val[1] 
+    result
+end
 
-# reduce 43 omitted
+def _reduce_43(val, _values, result)
+ result = tokenize_literal_negation(val[1]) 
+    result
+end
 
 # reduce 44 omitted
 
@@ -372,6 +405,20 @@ end
 
 # reduce 47 omitted
 
+# reduce 48 omitted
+
+# reduce 49 omitted
+
+# reduce 50 omitted
+
+# reduce 51 omitted
+
+# reduce 52 omitted
+
+# reduce 53 omitted
+
+# reduce 54 omitted
+
 def _reduce_none(val, _values, result)
   val[0]
 end

data/lib/sparkql/parser.y

@@ -102,7 +102,7 @@ rule
 # on filtering values
   condition
     : literal
-    | function
+    | literal_function
     | literal_list { result = tokenize_list(val[0]) }
     ;
     
@@ -115,6 +115,11 @@ rule
     : function_name LPAREN RPAREN { result = tokenize_function(val[0], []) }
     | function_name LPAREN function_args RPAREN { result = tokenize_function(val[0], val[2]) }
     ;
+
+  literal_function
+    : function_name LPAREN RPAREN { result = tokenize_function(val[0], []) }
+    | function_name LPAREN literal_function_args RPAREN { result = tokenize_function(val[0], val[2]) }
+    ;
     
   function_name
     : KEYWORD
@@ -126,20 +131,31 @@ rule
   function_args
     : function_arg
     | function_args COMMA function_arg { result = tokenize_function_args(val[0], val[2]) }
-    ; 
-    
+    ;
+
   function_arg
     : literal
     | literals
     | field { result = tokenize_field_arg(val[0]) }
     ;
-    
+
+  literal_function_args
+    : literal_function_arg
+    | literal_function_args COMMA literal_function_arg { result = tokenize_function_args(val[0], val[2]) }
+    ;
+
+  literal_function_arg
+    : literal
+    | literals
+    | literal_function
+    ;
+
 ##### Literal List
 # 
 # A comma delimited list of functions and values.
   literal_list
     : literals
-    | function
+    | literal_function
     | literal_list COMMA literals { result = tokenize_multiple(val[0], val[2]) }
     | literal_list COMMA function { result = tokenize_multiple(val[0], val[2]) }
     ;

data/lib/sparkql/parser_compatibility.rb

@@ -4,61 +4,51 @@ module Sparkql::ParserCompatibility
   MAXIMUM_MULTIPLE_VALUES = 200
   MAXIMUM_EXPRESSIONS = 75
   MAXIMUM_LEVEL_DEPTH = 2
+  MAXIMUM_FUNCTION_DEPTH = 5
 
-  # TODO I Really don't think this is required anymore
   # Ordered by precedence.
   FILTER_VALUES = [
     {
       :type => :datetime,
-      :regex => /^[0-9]{4}\-[0-9]{2}\-[0-9]{2}T[0-9]{2}\:[0-9]{2}\:[0-9]{2}\.[0-9]{6}$/,
       :operators => Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
     },
     {
       :type => :date,
-      :regex => /^[0-9]{4}\-[0-9]{2}\-[0-9]{2}$/,
       :operators => Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
     },
     {
       :type => :time,
-      :regex => /^[0-9]{2}\:[0-9]{2}(\:[0-9]{2})?(\.[0-9]{6)$/,
       :operators => Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
     },
     {
       :type => :character,
-      :regex => /^'([^'\\]*(\\.[^'\\]*)*)'$/, # Strings must be single quoted.  Any inside single quotes must be escaped.
       :multiple => /^'([^'\\]*(\\.[^'\\]*)*)'/,
       :operators => Sparkql::Token::EQUALITY_OPERATORS
     },
     {
       :type => :integer,
-      :regex => /^\-?[0-9]+$/,
       :multiple => /^\-?[0-9]+/,
       :operators => Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
     },
     {
       :type => :decimal,
-      :regex => /^\-?[0-9]+\.[0-9]+$/,
       :multiple => /^\-?[0-9]+\.[0-9]+/,
       :operators => Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
     },
     {
       :type => :shape,
-      # This type is not parseable, so no regex
       :operators => Sparkql::Token::EQUALITY_OPERATORS
     },
     {
       :type => :boolean,
-      :regex => /^true|false$/,
       :operators => Sparkql::Token::EQUALITY_OPERATORS
     },
     {
       :type => :null,
-      :regex => /^NULL|Null|null$/,
       :operators => Sparkql::Token::EQUALITY_OPERATORS
     },
     {
       :type => :function,
-      # This type is not parseable, so no regex
       :operators => Sparkql::Token::OPERATORS + [Sparkql::Token::RANGE_OPERATOR]
     },
   ]
@@ -206,6 +196,10 @@ module Sparkql::ParserCompatibility
     MAXIMUM_MULTIPLE_VALUES
   end
 
+  def max_function_depth
+    MAXIMUM_FUNCTION_DEPTH
+  end
+
   private
 
   def tokenizer_error( error_hash )
@@ -224,11 +218,11 @@ module Sparkql::ParserCompatibility
       (supports_nulls && expression[:type] == :null)
       return true
     # If the field will be passed into a function,
-    # check the type of the return value (:field_function_type),
+    # check the type of the return value of the function
     # and coerce if necessary.
-    elsif expression[:field_function_type] &&
-          expression[:type] == :integer && 
-          expression[:field_function_type] == :decimal
+    elsif expression[:field_manipulations] &&
+          expression[:type] == :integer &&
+          expression[:field_manipulations][:return_type] == :decimal
       expression[:type] = :decimal
       expression[:cast] = :integer
       return true
@@ -264,9 +258,9 @@ module Sparkql::ParserCompatibility
   # the function matches what is expected, and that the function supports the
   # field type as the first argument.
   def check_function_type?(expression, expected)
-    return false unless expression[:field_function_type] == expression[:type]
+    return false unless expression.key?(:field_manipulations) && expression[:field_manipulations][:return_type] == expression[:type]
     # Lookup the function arguments
-    function = Sparkql::FunctionResolver::SUPPORTED_FUNCTIONS[expression[:field_function].to_sym]
+    function = Sparkql::FunctionResolver::SUPPORTED_FUNCTIONS[expression[:field_manipulations][:function_name].to_sym]
     return false if function.nil?
 
     Array(function[:args].first).include?(expected)

data/lib/sparkql/parser_tools.rb

@@ -24,35 +24,37 @@ module Sparkql::ParserTools
   
   def tokenize_expression(field, op, val)
     operator = get_operator(val,op) unless val.nil?
-    field_args = {}
-    # Function support for fields is stapled in here. The function information
-    # is remapped to the expression
+
+    field_manipulations = nil
     if field.is_a?(Hash) && field[:type] == :function
-      function = Sparkql::FunctionResolver::SUPPORTED_FUNCTIONS[field[:value].to_sym]
-      if !function.nil?
-        field_args[:field_function] = field[:value]
-        field_args[:args] = field[:args]
-
-        if field_args[:field_function] == 'cast'
-          field_args[:field_function_type] = field[:args].last.to_sym
-        else
-          field_args[:field_function_type] = function[:return_type]
-        end
-      else
-        tokenizer_error(:token => field[:value], 
+      function = Sparkql::FunctionResolver::SUPPORTED_FUNCTIONS[field[:function_name].to_sym]
+      if function.nil?
+        tokenizer_error(:token => field[:function_name],
           :message => "Unsupported function type", :status => :fatal )
       end
-      field = field[:args].first
+      field_manipulations = field
+      field = field[:field]
     end
-    custom_field = !field.nil? && field.start_with?('"')
+
+    custom_field = !field.nil? && field.is_a?(String) && field.start_with?('"')
+
     block_group = (@lexer.level == 0) ? 0 : @lexer.block_group_identifier
     expression = {:field => field, :operator => operator, :conjunction => 'And',
       :conjunction_level => 0, :level => @lexer.level,
-      :block_group => block_group, :custom_field => custom_field}.
-      merge!(field_args)
+      :block_group => block_group, :custom_field => custom_field}
+
+    if !field_manipulations.nil?
+      # Keeping field_function and field_function_type for backward compatibility with datacon
+      expression.merge!(field_manipulations: field_manipulations,
+                        field_function: field_manipulations[:function_name],
+                        field_function_type: field_manipulations[:return_type],
+                        args: field_manipulations[:function_parameters])
+    end
+
     expression = val.merge(expression) unless val.nil?
     expression[:condition] ||= expression[:value]
     validate_level_depth expression
+    validate_field_function_depth(expression[:field_manipulations])
     if operator.nil?
       tokenizer_error(:token => op, :expression => expression,
         :message => "Operator not supported for this type and value string", :status => :fatal )
@@ -145,10 +147,14 @@ module Sparkql::ParserTools
   end
   
   def tokenize_field_arg(field)
-    {
-      :type => :field,
-      :value => field,
-    }
+    if field.is_a?(Hash) && field[:type] == :function
+      field
+    else
+      {
+        :type => :field,
+        :value => field,
+      }
+    end
   end
   
   def tokenize_function(name, f_args)
@@ -180,7 +186,6 @@ module Sparkql::ParserTools
   def on_error(error_token_id, error_value, value_stack)
     token_name = token_to_str(error_token_id)
     token_name.downcase!
-    token = error_value.to_s.inspect
     tokenizer_error(:token => @lexer.current_token_value, 
                     :message => "Error parsing token #{token_name}",
                     :status => :fatal, 
@@ -194,7 +199,15 @@ module Sparkql::ParserTools
             :status => :fatal, :syntax => false, :constraint => true )
     end
   end
-  
+
+  def validate_field_function_depth(expression)
+    if nested_function_depth(expression) > max_function_depth
+      compile_error(:token => "(", :expression => expression,
+            :message => "You have exceeded the maximum function nesting level.  Please nest no more than #{max_function_depth} levels deep.",
+            :status => :fatal, :syntax => false, :constraint => true )
+    end
+  end
+
   def validate_expressions results
     if results.size > max_expressions 
       compile_error(:token => results[max_expressions][:field], :expression => results[max_expressions],
@@ -237,4 +250,26 @@ module Sparkql::ParserTools
     end
   end
 
+  def nested_function_depth(expression)
+    return 0 unless expression && expression[:type] == :function
+
+    height = 0
+    queue = []
+    queue.push(expression)
+
+    while true
+      count = queue.size
+      return height if count == 0
+
+      height += 1
+
+      while count > 0
+        node = queue.shift
+        node[:args].each do |child|
+          queue.push(child) if child[:type] == :function
+        end
+        count -= 1
+      end
+    end
+  end
 end