getting close

Author: bramtayl

Project.toml

@@ -3,14 +3,15 @@ uuid = "57f923c0-76be-11e9-095d-c942eaffc94b"
 version = "0.2.1-DEV"
 
 [deps]
+DataValues = "e7dc6d0d-1eca-5fa6-8ad6-5aecde8b7ea5"
+Dates = "ade2ca70-3891-5945-98fb-dc099432e06a"
 IteratorInterfaceExtensions = "82899510-4779-5014-852e-03e436cf321d"
 MacroTools = "1914dd2f-81c6-5fcd-8719-6d5c9610ff09"
 QueryOperators = "2aef5ad7-51ca-5a8f-8e88-e75cf067b44b"
 SQLite = "0aa819cd-b072-5ff4-a722-6bc24af294d9"
-TableTraits = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c"
-DataValues = "e7dc6d0d-1eca-5fa6-8ad6-5aecde8b7ea5"
-TableShowUtils = "5e66a065-1f0a-5976-b372-e0b8c017ca10"
 Statistics = "10745b16-79ce-11e8-11f9-7d13ad32a3b2"
+TableShowUtils = "5e66a065-1f0a-5976-b372-e0b8c017ca10"
+TableTraits = "3783bdb8-4a98-5b6b-af9a-565f29a5fe9c"
 
 [extras]
 Documenter = "e30172f5-a6a5-5a46-863b-614d45cd2de4"

src/QuerySQLite.jl

@@ -1,12 +1,13 @@
 module QuerySQLite
 
-import Base: !, &, |, ==, !=, *, +, %, abs, Char, coalesce, collect, eltype, getproperty, length,
+import Base: !, &, |, ==, !=, *, +, %, abs, Char, coalesce, collect, convert, eltype, getproperty, length,
 lowercase, in, isdone, isequal, isless, ismissing, iterate, IteratorSize, max, min,
-occursin, rand, show, showerror, startswith, string, strip, uppercase
+occursin, rand, replace, repr, round, show, showerror, startswith, string, strip, SubString, uppercase
 using Base: Generator, NamedTuple, RefValue, SizeUnknown, tail
 using Base.Meta: quot
 import Base.Multimedia: showable
 using DataValues: DataValue
+import Dates: Date, DateTime, Time
 import IteratorInterfaceExtensions: getiterator, isiterable
 import MacroTools
 using MacroTools: @capture

src/code_instead.jl

@@ -1,9 +1,21 @@
 # All code is attached to its underlying database source
 struct SourceCode{Source}
     source::Source
-    code::Expr
+    code::Union{Expr, Nothing}
 end
 
+"""
+    struct BySQL{Source}
+
+If you would like a statement to be evaluated by SQL, not Julia, and
+none of the arguments are SQL code, you can use BySQL to hack dispatch.
+"""
+struct BySQL{Source}
+    source::Source
+end
+
+export BySQL
+
 # Every time `SourceCode` objects are combined, check to see whether they all come from the same source
 function pop_source!(sources, something)
     something
@@ -12,18 +24,28 @@ function pop_source!(sources, source_code::SourceCode)
     push!(sources, source_code.source)
     source_code.code
 end
+function pop_source!(sources, by_sql::BySQL)
+    push!(sources, by_sql.source)
+    by_sql
+end
 function key_pop_source!(sources, (key, source_code))
-    code = pop_source!(souces, source_code)
+    code = pop_source!(sources, source_code)
     Expr(:kw, key, code)
 end
 
 function combine_sources(a_function, source_codes...; key_source_codes...)
     sources = Set(Any[])
-    codes = partial_map(pop_source!, sources, source_codes)
-    key_codes = (
+    codes = [
+        pop_source!(sources, source_code)
+        for source_code in source_codes
+    ]
+    filter!(codes) do code
+        !(code isa BySQL)
+    end
+    key_codes = [
         key_pop_source!(sources, key_source_code)
         for key_source_code in key_source_codes
-    )
+    ]
     if length(sources) != 1
         error("Expected exactly one source; got ($(sources...))")
     else
@@ -56,12 +78,12 @@ function code_instead(location, a_function, types...)
     arguments = ntuple(numbered_argument, length(types))
     keywords = Expr(:parameters, Expr(:..., :keywords))
     Expr(:function,
-        Expr(:call, a_function, keywords, map_unrolled(assert_type, arguments, types)...),
+        Expr(:call, a_function, keywords, map(assert_type, arguments, types)...),
         Expr(:block, location, Expr(:call,
             combine_sources,
             keywords,
             a_function,
-            map_unrolled(maybe_splat, arguments, types)...
+            map(maybe_splat, arguments, types)...
         ))
     )
 end
@@ -111,6 +133,14 @@ end
 
 @code_instead coalesce SourceCode Vararg{Any}
 
+@code_instead convert Type{Int} SourceCode
+
+# TODO: support dateformat
+@code_instead Date SourceCode
+
+# TODO: support dateformat
+@code_instead DateTime SourceCode
+
 @code_instead QueryOperators.drop SourceCode Integer
 
 @code_instead QueryOperators.filter SourceCode Any Expr
@@ -164,18 +194,35 @@ end
 
 @code_instead QueryOperators.orderby_descending SourceCode Any Expr
 
+@code_instead rand BySQL Type{Int}
+
+# TODO: add more methods
+@code_instead replace SourceCode Pair
+
+@code_instead repr SourceCode
+
+@code_instead round SourceCode
+
 @code_instead secondary SourceCode
 
+@code_instead strip SourceCode
+@code_instead strip SourceCode Char
+
+@code_instead SubString SourceCode Number Number
+@code_instead SubString SourceCode Number
+
+@code_instead sum SourceCode
+
 @code_instead QueryOperators.take SourceCode Any
 
 @code_instead QueryOperators.thenby SourceCode Any Expr
 
 @code_instead QueryOperators.thenby_descending SourceCode Any Expr
 
-@code_instead sum SourceCode
+# TODO: support dateformat
+@code_instead Time SourceCode
 
-@code_instead strip SourceCode
-@code_instead strip SourceCode Char
+@code_instead type_of SourceCode
 
 # TODO: add more methods
 @code_instead QueryOperators.unique SourceCode Any Expr
@@ -184,20 +231,10 @@ end
 
 # TODO: add
 # printf
-# quote
-# random
 # randomblob
-# replace
-# round
-# substr
-# typeof
-# unicode
 # zeroblob
 # group_concat
 # total
-# date
-# time
-# datetime
 # julianday
 # strftime
 

src/iterate.jl

@@ -115,8 +115,8 @@ function getiterator(source_code::SourceCode)
         sqlite3_column_count(handle)
     )
     SQLiteCursor{NamedTuple{
-        Tuple(map_unrolled(first, schema)),
-        Tuple{map_unrolled(second, schema)...}
+        Tuple(map(first, schema)),
+        Tuple{map(second, schema)...}
     }}(statement, Ref(status), Ref(0))
 end
 

src/model_row.jl

@@ -25,11 +25,12 @@ end
 function model_row_call(::typeof(getproperty), source_tables::Database, table_name)
     source = get_source(source_tables)
     column_names = get_column_names(source, table_name)
-    NamedTuple{column_names}(partial_map(
-        get_column,
-        SourceRow(source, table_name),
-        column_names
-    ))
+    source_row = SourceRow(source, table_name)
+    NamedTuple{column_names}(
+        map(column_names) do column_name
+            get_column(source_row, column_name)
+        end
+    )
 end
 
 # Map is the only function which directly modifies the model row

src/translate.jl

@@ -2,8 +2,8 @@
 # Frustratingly, primary tables are translated differently from secondary tables, so translate must propagate the `primary` keyword
 struct SQLExpression
     call::Symbol
-    arguments::Tuple
-    SQLExpression(call, arguments...) = new(call, arguments)
+    arguments::Vector{Any}
+    SQLExpression(call, arguments...) = new(call, Any[arguments...])
 end
 
 function translate(something::Union{Char, AbstractString}; primary = true)
@@ -26,7 +26,7 @@ end
 function translate_default(location, function_type, SQL_call)
     result = :(
         function translate_call($function_type, arguments...; primary = true)
-            $SQLExpression($SQL_call, $map_unrolled(
+            $SQLExpression($SQL_call, $map(
                 argument -> $translate(argument; primary = primary),
                 arguments
             )...)
@@ -65,9 +65,17 @@ function as(pair; primary = true)
     )
 end
 
+@translate_default ::typeof(coalesce) :COALESCE
+
 @translate_default ::typeof(char) :CHAR
 
-@translate_default ::typeof(coalesce) :COALESCE
+function translate_call(::typeof(convert), ::Type{Int}, it; primary = true)
+    SQLExpression(:UNICODE, translate(it))
+end
+
+@translate_default ::Type{Date} :DATE
+
+@translate_default ::Type{DateTime} :DATETIME
 
 @translate_default ::typeof(hex) :HEX
 
@@ -191,10 +199,33 @@ function translate_call(::typeof(QueryOperators.orderby_descending), unordered,
     )
 end
 
+@translate_default ::typeof(repr) :QUOTE
+
+function translate_call(::typeof(rand), ::Type{Int}; primary = true, digits = 0)
+    SQLExpression(:RANDOM)
+end
+
+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)
+    )
+end
+
+function translate_call(::typeof(round), it; primary = true, digits = 0)
+    SQLExpression(:ROUND,
+        translate(it; primary = primary),
+        translate(digits; primary = primary)
+    )
+end
+
 @translate_default ::typeof(string) :||
 
 @translate_default ::typeof(strip) :TRIM
 
+@translate_default ::Type{SubString} :SUBSTR
+
 @translate_default ::typeof(sum) :SUM
 
 @translate_default ::typeof(QueryOperators.take) :LIMIT
@@ -215,6 +246,10 @@ function translate_call(::typeof(QueryOperators.thenby_descending), unordered, k
     )
 end
 
+@translate_default ::Type{Time} :Time
+
+@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)
     SQLExpression(Symbol(string(result.call, " DISTINCT")), result.arguments...)

src/utilities.jl

@@ -1,43 +1,5 @@
-# Recursion will be more performant than iteration for small tuples. My own recursive map makes sure that there is no iteration for performance
-function map_unrolled(call, variables::Tuple{})
-    ()
-end
-function map_unrolled(call, variables)
-    (call(first(variables)), map_unrolled(call, tail(variables))...)
-end
-
-function map_unrolled(call, variables1::Tuple{}, variables2::Tuple{})
-    ()
-end
-function map_unrolled(call, variables1, variables2)
-    (
-        call(first(variables1), first(variables2)),
-        map_unrolled(call, tail(variables1), tail(variables2))...
-    )
-end
-
-# In partial map, fixed is passed each time. This avoids captures, which have performace issues
-function partial_map(call, fixed, variables::Tuple{})
-    ()
-end
-function partial_map(call, fixed, variables)
-    (
-        call(fixed, first(variables)),
-        partial_map(call, fixed, tail(variables))...
-    )
-end
-function partial_map(call, fixed, variables1::Tuple{}, variables2::Tuple{})
-    ()
-end
-function partial_map(call, fixed, variables1, variables2)
-    (
-        call(fixed, first(variables1), first(variables2)),
-        partial_map(call, fixed, tail(variables1), tail(variables2))...
-    )
-end
-
 function as_symbols(them)
-    map_unrolled(Symbol, (them...,))
+    map(Symbol, (them...,))
 end
 
 split_keyword(keyword::Expr) =