fix bug

Author: bramtayl

src/iterate.jl

@@ -100,7 +100,6 @@ function name_and_type(handle, column_number, nullable = true, strict_types = tr
 end
 
 function getiterator(source_code::SourceCode)
-    # TODO REVIEW
     statement = Stmt(
         source_code.source,
         string(finalize(translate(source_code.code)))

src/translate.jl

@@ -1,33 +1,36 @@
 # The translation pass turns Julia expressions into SQL expressions
-# Frustratingly, primary tables are translated differently from secondary tables, so translate must propagate the `primary` keyword
+# Frustratingly, _primary tables are translated differently from secondary tables, so translate must propagate the `_primary` keyword
 struct SQLExpression
     call::Symbol
     arguments::Vector{Any}
     SQLExpression(call, arguments...) = new(call, Any[arguments...])
 end
 
-function translate(something::Union{Char, AbstractString}; primary = true)
+function nest(sql_expression)
+    SQLExpression(:AS, SQLExpression(:FROM, sql_expression), :__TABLE__)
+end
+
+function translate(something::Union{Char, AbstractString}; _primary = true)
     repr(something)
 end
 
-function translate(something; primary = true)
+function translate(something; _primary = true)
     something
 end
-function translate(source_row::SourceRow; primary = true)
+function translate(source_row::SourceRow; _primary = true)
     source_row.table_name
 end
-function translate(call::Expr; primary = true)
+function translate(call::Expr; _primary = true)
     arguments, keywords = split_call(call)
-    # TODO: figure out a way for users to pass a keyword named primary
-    translate_call(arguments...; primary = primary, keywords...)
+    translate_call(arguments...; _primary = _primary, keywords...)
 end
 
 # A 1-1 mapping between Julia functions and SQL functions
 function translate_default(location, function_type, SQL_call)
     result = :(
-        function translate_call($function_type, arguments...; primary = true)
+        function translate_call($function_type, arguments...; _primary = true)
             $SQLExpression($SQL_call, $map(
-                argument -> $translate(argument; primary = primary),
+                argument -> $translate(argument; _primary = _primary),
                 arguments
             )...)
         end
@@ -58,9 +61,9 @@ end
 
 @translate_default ::typeof(abs) :ABS
 
-function as(pair; primary = true)
+function as(pair; _primary = true)
     SQLExpression(:AS,
-        translate(pair.second.code; primary = primary),
+        translate(pair.second.code; _primary = _primary),
         pair.first
     )
 end
@@ -69,7 +72,7 @@ end
 
 @translate_default ::typeof(char) :CHAR
 
-function translate_call(::typeof(convert), ::Type{Int}, it; primary = true)
+function translate_call(::typeof(convert), ::Type{Int}, it; _primary = true)
     SQLExpression(:UNICODE, translate(it))
 end
 
@@ -81,41 +84,40 @@ end
 
 @translate_default ::typeof(QueryOperators.drop) :OFFSET
 
-function translate_call(::typeof(QueryOperators.filter), iterator, call, call_expression; primary = true)
+function translate_call(::typeof(QueryOperators.filter), iterator, call, call_expression; _primary = true)
     SQLExpression(:WHERE,
-        translate(iterator; primary = primary),
-        translate(call(model_row(iterator)).code; primary = primary)
+        translate(iterator; _primary = _primary),
+        translate(call(model_row(iterator)).code; _primary = _primary)
     )
 end
 
-function translate_call(::typeof(getproperty), source_tables::Database, table_name; primary = true)
-    translated = translate(table_name; primary = primary)
-    if primary
+function translate_call(::typeof(getproperty), source_tables::Database, table_name; _primary = true)
+    translated = translate(table_name; _primary = _primary)
+    if _primary
         SQLExpression(:FROM, translated)
     else
         translated
     end
 end
-function translate_call(::typeof(getproperty), source_row::SourceRow, column_name; primary = true)
-    translated = translate(column_name; primary = primary)
-    if primary
+function translate_call(::typeof(getproperty), source_row::SourceRow, column_name; _primary = true)
+    translated = translate(column_name; _primary = _primary)
+    if _primary
         translated
     else
         SQLExpression(:., source_row.table_name, translated)
     end
 end
 
-function translate_call(::typeof(QueryOperators.groupby), ungrouped, group_function, group_function_expression, map_selector, map_function_expression; primary = true)
-    # TODO: map_selector
+function translate_call(::typeof(QueryOperators.groupby), ungrouped, group_function, group_function_expression, map_selector, map_function_expression; _primary = true)
     model = model_row(ungrouped)
     SQLExpression(Symbol("GROUP BY"),
-        SQLExpression(:AS, SQLExpression(:FROM, translate_call(
+        nest(translate_call(
             QueryOperators.map,
             ungrouped,
             map_selector, map_function_expression,
-            primary = primary
-        )), :__TABLE__),
-        translate(group_function(model).code; primary = primary)
+            _primary = _primary
+        )),
+        translate(group_function(model).code; _primary = _primary)
     )
 end
 
@@ -131,25 +133,25 @@ end
 
 @translate_default ::typeof(ismissing) Symbol("IS NULL")
 
-function translate_call(::typeof(QueryOperators.join), source1, source2, key1, key1_expression, key2, key2_expression, combine, combine_expression; primary = true)
+function translate_call(::typeof(QueryOperators.join), source1, source2, key1, key1_expression, key2, key2_expression, combine, combine_expression; _primary = true)
     model_row_1 = model_row(source1)
     model_row_2 = model_row(source2)
     SQLExpression(:SELECT,
         SQLExpression(:ON,
             SQLExpression(Symbol("INNER JOIN"),
                 translate(source1),
-                # mark as not primary to suppress FROM
-                translate(source2; primary = false)
+                # mark as not _primary to suppress FROM
+                translate(source2; _primary = false)
             ),
-            # mark both as not primary to always be explicit about table
+            # mark both as not _primary to always be explicit about table
             SQLExpression(:(=),
-                translate(key1(model_row_1).code; primary = false),
-                translate(key2(model_row_2).code; primary = false)
+                translate(key1(model_row_1).code; _primary = false),
+                translate(key2(model_row_2).code; _primary = false)
             )
         ),
-        # mark both as not primary to always be explicit about table
+        # mark both as not _primary to always be explicit about table
         Generator(
-            pair -> as(pair; primary = false),
+            pair -> as(pair; _primary = false),
             pairs(combine(model_row_1, model_row_2))
         )...
     )
@@ -159,11 +161,15 @@ end
 
 @translate_default ::typeof(lowercase) :LOWER
 
-function translate_call(::typeof(QueryOperators.map), select_table, call, call_expression; primary = true)
+function translate_call(::typeof(QueryOperators.map), select_table, call, call_expression; _primary = true)
+    inner = translate(select_table; _primary = _primary)
+    if inner.call == :SELECT
+        inner = nest(inner)
+    end
     SQLExpression(
-        Symbol("SELECT"), translate(select_table; primary = primary),
+        :SELECT, inner,
         Generator(
-            pair -> as(pair; primary = primary),
+            pair -> as(pair; _primary = _primary),
             pairs(call(model_row(select_table)))
         )...
     )
@@ -175,48 +181,48 @@ end
 
 @translate_default ::typeof(min) :min
 
-translate_call(::typeof(occursin), needle::Regex, haystack; primary = true) =
+translate_call(::typeof(occursin), needle::Regex, haystack; _primary = true) =
     SQLExpression(
         :LIKE,
-        translate(haystack; primary = primary),
+        translate(haystack; _primary = _primary),
         # * => %, . => _
-        string('"', replace(replace(needle.pattern, r"(?<!\\)\.\*" => "%"), r"(?<!\\)\." => "_"), '"')
+        translate(replace(replace(needle.pattern, r"(?<!\\)\.\*" => "%"), r"(?<!\\)\." => "_"))
     )
 
-function translate_call(::typeof(QueryOperators.orderby), unordered, key_function, key_function_expression; primary = true)
+function translate_call(::typeof(QueryOperators.orderby), unordered, key_function, key_function_expression; _primary = true)
     SQLExpression(Symbol("ORDER BY"),
-        translate(unordered; primary = primary),
-        translate(key_function(model_row(unordered)).code; primary = primary)
+        translate(unordered; _primary = _primary),
+        translate(key_function(model_row(unordered)).code; _primary = _primary)
     )
 end
 
-function translate_call(::typeof(QueryOperators.orderby_descending), unordered, key_function, key_function_expression; primary = true)
+function translate_call(::typeof(QueryOperators.orderby_descending), unordered, key_function, key_function_expression; _primary = true)
     SQLExpression(Symbol("ORDER BY"),
-        translate(unordered; primary = primary),
+        translate(unordered; _primary = _primary),
         SQLExpression(:DESC,
-            translate(key_function(model_row(unordered)).code; primary = primary)
+            translate(key_function(model_row(unordered)).code; _primary = _primary)
         )
     )
 end
 
 @translate_default ::typeof(repr) :QUOTE
 
-function translate_call(::typeof(rand), ::Type{Int}; primary = true, digits = 0)
+function translate_call(::typeof(rand), ::Type{Int}; _primary = true, digits = 0)
     SQLExpression(:RANDOM)
 end
 
-function translate_call(::typeof(replace), it, pair; primary = true)
+function translate_call(::typeof(replace), it, pair; _primary = true)
     SQLExpression(:REPLACE,
-        translate(it; primary = primary),
-        translate(pair.first; primary = primary),
-        translate(pair.second; primary = primary)
+        translate(it; _primary = _primary),
+        translate(pair.first; _primary = _primary),
+        translate(pair.second; _primary = _primary)
     )
 end
 
-function translate_call(::typeof(round), it; primary = true, digits = 0)
+function translate_call(::typeof(round), it; _primary = true, digits = 0)
     SQLExpression(:ROUND,
-        translate(it; primary = primary),
-        translate(digits; primary = primary)
+        translate(it; _primary = _primary),
+        translate(digits; _primary = _primary)
     )
 end
 
@@ -230,18 +236,18 @@ end
 
 @translate_default ::typeof(QueryOperators.take) :LIMIT
 
-function translate_call(::typeof(QueryOperators.thenby), unordered, key_function, key_function_expression; primary = true)
-    original = translate(unordered; primary = primary)
+function translate_call(::typeof(QueryOperators.thenby), unordered, key_function, key_function_expression; _primary = true)
+    original = translate(unordered; _primary = _primary)
     SQLExpression(original.call, original.arguments...,
-        translate(key_function(model_row(unordered)).code; primary = primary)
+        translate(key_function(model_row(unordered)).code; _primary = _primary)
     )
 end
 
-function translate_call(::typeof(QueryOperators.thenby_descending), unordered, key_function, key_function_expression; primary = true)
-    original = translate(unordered; primary = primary)
+function translate_call(::typeof(QueryOperators.thenby_descending), unordered, key_function, key_function_expression; _primary = true)
+    original = translate(unordered; _primary = _primary)
     SQLExpression(original.call, original.arguments...,
         SQLExpression(:DESC,
-            translate(key_function(model_row(unordered)).code; primary = primary)
+            translate(key_function(model_row(unordered)).code; _primary = _primary)
         )
     )
 end
@@ -250,8 +256,8 @@ end
 
 @translate_default ::typeof(type_of) :TYPEOF
 
-function translate_call(::typeof(QueryOperators.unique), repeated, key_function, key_function_expression; primary = true)
-    result = translate(repeated; primary = primary)
+function translate_call(::typeof(QueryOperators.unique), repeated, key_function, key_function_expression; _primary = true)
+    result = translate(repeated; _primary = _primary)
     SQLExpression(Symbol(string(result.call, " DISTINCT")), result.arguments...)
 end