use model as domain object adding fields not in db table

Author: iskyd

Project.toml

@@ -1,7 +1,7 @@
 name = "Wasabi"
 uuid = "cec542a4-22c5-46cb-8ca4-a46a7737b387"
 authors = ["Mattia <[email protected]>"]
-version = "0.3.0"
+version = "0.4.0"
 
 [deps]
 DataFrames = "a93c6f00-e57d-5684-b7b6-d8193f3e46c0"

ext/WasabiPostgreSQLExt.jl

@@ -29,7 +29,8 @@ function Wasabi.delete_schema(conn::LibPQ.Connection, m::Type{T}) where {T<:Wasa
 end
 
 function Wasabi.create_schema(conn::LibPQ.Connection, m::Type{T}) where {T<:Wasabi.Model}
-    columns = [(col, Wasabi.mapping(LibPQ.Connection, Wasabi.coltype(m, col))) for col in Wasabi.colnames(m)]
+    autoincrement_fields = Wasabi.autoincrement_fields(m)
+    columns = [(col, col in autoincrement_fields ? "SERIAL" : Wasabi.mapping(LibPQ.Connection, Wasabi.coltype(m, col))) for col in Wasabi.colnames(m) if !(col in Wasabi.exclude_fields(m))]
     query = "CREATE TABLE IF NOT EXISTS \"$(Wasabi.tablename(m))\" ($(join([String(col[1]) * " " * col[2] * (Wasabi.isnullable(m, col[1]) ? "" : " NOT NULL") for col in columns], ", "))"
 
     constraints = Wasabi.constraints(m)
@@ -85,7 +86,7 @@ function Wasabi.first(conn::LibPQ.Connection, m::Type{T}, id) where {T<:Wasabi.M
 end
 
 function Wasabi.insert!(conn::LibPQ.Connection, model::T) where {T<:Wasabi.Model}
-    columns = filter(column -> column[2] !== nothing, Wasabi.model2tuple(model))
+    columns = filter(column -> column[2] !== nothing && !(column[1] in Wasabi.exclude_fields(typeof(model))), Wasabi.model2tuple(model))
     fields = map(column -> column[1], columns)
     values = map(column -> Wasabi.to_sql_value(column[2]), columns)
 
@@ -110,7 +111,7 @@ function Wasabi.delete!(conn::LibPQ.Connection, model::T) where {T<:Wasabi.Model
 end
 
 function Wasabi.update!(conn::LibPQ.Connection, model::T) where {T<:Wasabi.Model}
-    columns = filter(column -> column[2] !== nothing, Wasabi.model2tuple(model))
+    columns = filter(column -> column[2] !== nothing && !(column[1] in Wasabi.exclude_fields(typeof(model))), Wasabi.model2tuple(model))
     fields = map(column -> column[1], columns)
     values = (map(column -> Wasabi.to_sql_value(column[2]), columns)..., Wasabi.to_sql_value(model.id))
 

ext/WasabiSQLiteExt.jl

@@ -31,7 +31,7 @@ function Wasabi.delete_schema(db::SQLite.DB, m::Type{T}) where {T<:Wasabi.Model}
 end
 
 function Wasabi.create_schema(db::SQLite.DB, m::Type{T}) where {T<:Wasabi.Model}
-    columns = [(col, Wasabi.mapping(SQLite.DB, Wasabi.coltype(m, col))) for col in Wasabi.colnames(m)]
+    columns = [(col, Wasabi.mapping(SQLite.DB, Wasabi.coltype(m, col))) for col in Wasabi.colnames(m) if !(col in Wasabi.exclude_fields(m))]
     query = "CREATE TABLE IF NOT EXISTS $(Wasabi.tablename(m)) ($(join([String(col[1]) * " " * col[2] * (Wasabi.isnullable(m, col[1]) ? "" : " NOT NULL") for col in columns], ", "))"
 
     constraints = Wasabi.constraints(m)
@@ -87,7 +87,7 @@ function Wasabi.first(db::SQLite.DB, m::Type{T}, id) where {T<:Wasabi.Model}
 end
 
 function Wasabi.insert!(db::SQLite.DB, model::T) where {T<:Wasabi.Model}
-    columns = filter(column -> column[2] !== nothing, Wasabi.model2tuple(model))
+    columns = filter(column -> column[2] !== nothing && !(column[1] in Wasabi.exclude_fields(typeof(model))), Wasabi.model2tuple(model))
     fields = map(column -> column[1], columns)
     values = map(column -> Wasabi.to_sql_value(column[2]), columns)
 
@@ -114,7 +114,7 @@ function Wasabi.delete!(db::SQLite.DB, model::T) where {T<:Wasabi.Model}
 end
 
 function Wasabi.update!(db::SQLite.DB, model::T) where {T<:Wasabi.Model}
-    columns = filter(column -> column[2] !== nothing, Wasabi.model2tuple(model))
+    columns = filter(column -> column[2] !== nothing && !(column[1] in Wasabi.exclude_fields(typeof(model))), Wasabi.model2tuple(model))
     fields = map(column -> column[1], columns)
     values = (map(column -> Wasabi.to_sql_value(column[2]), columns)..., Wasabi.to_sql_value(model.id))
 

src/QueryBuilder.jl

@@ -87,7 +87,7 @@ end
 function select(select::Union{Vector{Symbol},Nothing}=nothing)
     return function (q::Query)
         if select === nothing
-            select = Wasabi.colnames(q.source)
+            select = filter(col -> !(col in Wasabi.exclude_fields(q.source)), Wasabi.colnames(q.source))
         end
         q.select = vcat(q.select, [SelectExpr(source=q.source, field=col) for col in select])
         q

src/Wasabi.jl

@@ -11,6 +11,7 @@ export PostgreSQLConnectionConfiguration
 export Migrations
 
 abstract type Model end
+abstract type Table end
 abstract type ModelConstraint end
 abstract type ConnectionConfiguration end
 
@@ -75,12 +76,25 @@ end
 union_types(x::Union) = (x.a, union_types(x.b)...)
 union_types(x::Type) = (x,)
 
+
+"""
+    exclude_fields(m::Type{T}) where {T <: Model}
+    Returns the fields to exclude from the model when running queries.
+"""
+exclude_fields(m::Type{T}) where {T<:Wasabi.Model} = []
+    
+"""
+    autoincrement_fields(m::Type{T}) where {T <: Model}
+    Returns the fields that are autoincremented.
+"""
+autoincrement_fields(m::Type{T}) where {T<:Wasabi.Model} = [:id]
+
 """
     df2model(m::Type{T}, df::DataFrame) where {T <: Model}
     Converts the given DataFrame to the given model.
 """
 function df2model(m::Type{T}, df::DataFrame) where {T<:Wasabi.Model}
-    return [m(map(col -> row[col] !== missing ? Wasabi.from_sql_value(coltype(m, col), row[col]) : nothing, Wasabi.colnames(m))...) for row in eachrow(df)]
+    return [m(map(col -> row[col] !== missing ? Wasabi.from_sql_value(coltype(m, col), row[col]) : nothing, filter(x -> String(x) in names(df), Wasabi.colnames(m)))...) for row in eachrow(df)]
 end
 
 """

test/postgresql.jl

@@ -20,50 +20,45 @@
     @test Wasabi.mapping(LibPQ.Connection, Wasabi.AutoIncrement) == "SERIAL"
 
     Mocking.activate()
-
     patch = @patch LibPQ.execute(conn::LibPQ.Connection, query::String) = query
 
     apply(patch) do
-        @test Wasabi.delete_schema(conn, UserProfile) == "DROP TABLE IF EXISTS \"user_profile\""
         @test Wasabi.delete_schema(conn, User) == "DROP TABLE IF EXISTS \"user\""
+        @test Wasabi.delete_schema(conn, Role) == "DROP TABLE IF EXISTS \"role\""
         @test Wasabi.create_schema(conn, User) == "CREATE TABLE IF NOT EXISTS \"user\" (id SERIAL NOT NULL, name TEXT NOT NULL, created_at TIMESTAMP NOT NULL, PRIMARY KEY (id))"
-    end
-
-    apply(patch) do
-        @test Wasabi.create_schema(conn, UserProfile) == "CREATE TABLE IF NOT EXISTS \"user_profile\" (id INTEGER NOT NULL, user_id INTEGER NOT NULL, bio TEXT, PRIMARY KEY (id), FOREIGN KEY (user_id) REFERENCES \"user\" (id), UNIQUE (user_id))"
+        @test Wasabi.create_schema(conn, Role) == "CREATE TABLE IF NOT EXISTS \"role\" (id SERIAL NOT NULL, name TEXT NOT NULL, user_id INTEGER NOT NULL, PRIMARY KEY (id), FOREIGN KEY (user_id) REFERENCES \"user\" (id))"
     end
 
     patch_execute_raw_query = @patch Wasabi.execute_query(conn::LibPQ.Connection, query::Wasabi.RawQuery, params::Vector{Any}=Any[]) = query
     apply(patch_execute_raw_query) do
         query = QueryBuilder.from(User) |> QueryBuilder.select([:id, :name]) |> QueryBuilder.limit(1) |> QueryBuilder.offset(1)
         @test Wasabi.execute_query(conn, query) == rq"SELECT user_alias.id, user_alias.name FROM \"user\" user_alias LIMIT 1 OFFSET 1"
 
-        query = QueryBuilder.from(User) |> QueryBuilder.select([:id, :name]) |> QueryBuilder.join(User, UserProfile, :inner, (:id, :user_id), [:bio]) |> QueryBuilder.join(UserProfile, UserPhone, :inner, (:id, :user_profile_id), [:phone])
-        @test Wasabi.execute_query(conn, query) == rq"SELECT user_alias.id, user_alias.name, user_profile_alias.bio, user_phone_alias.phone FROM \"user\" user_alias INNER JOIN \"user_profile\" user_profile_alias ON user_alias.id = user_profile_alias.user_id INNER JOIN \"user_phone\" user_phone_alias ON user_profile_alias.id = user_phone_alias.user_profile_id"
+        query = QueryBuilder.from(User) |> QueryBuilder.select([:id, :name]) |> QueryBuilder.join(User, Role, :inner, (:id, :user_id), [:name])
+        @test Wasabi.execute_query(conn, query) == rq"SELECT user_alias.id, user_alias.name, role_alias.name FROM \"user\" user_alias INNER JOIN \"role\" role_alias ON user_alias.id = role_alias.user_id"
     end
 
     Mocking.deactivate()
 
-    Wasabi.delete_schema(conn, UserProfile)
+    Wasabi.delete_schema(conn, Role)
     Wasabi.delete_schema(conn, User)
 
     Wasabi.create_schema(conn, User)
-    Wasabi.create_schema(conn, UserProfile)
+    Wasabi.create_schema(conn, Role)
 
     dtnow = Dates.now()
     query = rq"INSERT INTO \"user\" (name, created_at) VALUES ($1, $2)"
     Wasabi.execute_query(conn, query, Any["John Doe", dtnow])
 
     query = rq"SELECT * FROM \"user\""
     result = Wasabi.execute_query(conn, query)
-
     @test length(result[!, :id]) == 1
     @test result[!, :id][1] == 1
     @test result[!, :name][1] == "John Doe"
     @test result[!, :created_at][1] == dtnow
 
     user = Wasabi.df2model(User, result)[1]
-    @test user.id == AutoIncrement(1)
+    @test user.id == 1
     @test user.name == "John Doe"
     @test user.created_at == dtnow
 
@@ -82,10 +77,10 @@
 
     users = Wasabi.df2model(User, result)
     @test length(users) == 2
-    @test users[1].id == AutoIncrement(1)
+    @test users[1].id == 1
     @test users[1].name == "John Doe"
     @test users[1].created_at == dtnow
-    @test users[2].id == AutoIncrement(2)
+    @test users[2].id == 2
     @test users[2].name == "Jane Doe"
     @test users[2].created_at == dtnow
 
@@ -107,29 +102,29 @@
     result = Wasabi.execute_query(conn, query)
     @test length(result[!, :id]) == 3
 
-    query == rq"SELECT user.id, user.name, user_profile.bio, user_phone.phone FROM \"user\" user INNER JOIN \"user_profile\" user_profile ON user.id = user_profile.user_id INNER JOIN \"user_phone\" user_phone ON user_profile.id = user_phone.user_profile_id"
-    Wasabi.execute_query(conn, query)
-
     user = Wasabi.first(conn, User, 1)
-    @test user.id == AutoIncrement(1)
+    @test user.id == 1
     @test user.name == "John Doe"
 
     user = Wasabi.first(conn, User, 10)
     @test user === nothing
 
     new_user = User("John Doe", dtnow)
-    Wasabi.insert!(conn, new_user)
+    keys = Wasabi.insert!(conn, new_user)
+    @test keys[1, 1] == 5 # This is because even if we have only 3 users postgresql assign the id to the rollbacked user
 
     user = Wasabi.first(conn, User, 5)
-    @test user.id == AutoIncrement(5)
+    @test user.id == 5
     @test user.name == "John Doe"
+    @test user.created_at == dtnow
 
     user.name = "Jane Doe"
     Wasabi.update!(conn, user)
 
     user = Wasabi.first(conn, User, 5)
-    @test user.id == AutoIncrement(5)
+    @test user.id == 5
     @test user.name == "Jane Doe"
+    @test user.created_at == dtnow
 
     Wasabi.delete!(conn, user)
 
@@ -143,7 +138,7 @@
     users = Wasabi.execute_query(conn, qb)
     @test length(users[!, :id]) == 1
     user = Wasabi.df2model(User, users)[1]
-    @test user.id == AutoIncrement(2)
+    @test user.id == 2
     @test user.name == "Jane Doe"
     @test user.created_at == dtnow
 
@@ -163,8 +158,5 @@
     Wasabi.delete_all!(conn, User)
     @test length(Wasabi.all(conn, User)) == 0
 
-    Wasabi.delete_schema(conn, UserProfile)
-    Wasabi.delete_schema(conn, User)
-
     Wasabi.disconnect(conn)
 end

test/runtests.jl

@@ -8,34 +8,46 @@ using Mocking
 
 Random.seed!(42)
 
+mutable struct Role <: Wasabi.Model
+    id::Union{Nothing, Int}
+    name::String
+    user_id::Int
+
+    Role(name::String, user_id::Int) = new(nothing, name, user_id)
+end
+
 mutable struct User <: Wasabi.Model
-    id::Union{Nothing, AutoIncrement}
+    id::Union{Nothing, Int}
     name::String
     created_at::DateTime
+    roles::Vector{Role}
 
-    User(name::String, created_at::DateTime) = new(nothing, name, created_at)
-    User(id::AutoIncrement, name::String, created_at::DateTime) = new(id, name, created_at)
+    User(name::String, created_at::DateTime, roles::Vector{Role} = Role[]) = new(nothing, name, created_at, roles)
+    User(id::Number, name::String, created_at::DateTime, roles::Vector{Role} = Role[]) = new(id, name, created_at, roles)
 end
 
-struct UserProfile <: Wasabi.Model
-    id::Int
-    user_id::Int
-    bio::Union{String,Nothing}
-end
+# struct UserProfile <: Wasabi.Model
+#     id::Int
+#     user_id::Int
+#     bio::Union{String,Nothing}
+# end
 
-struct UserPhone <: Wasabi.Model
-    id::Int
-    user_profile_id::Int
-    phone::String
-end
+# struct UserPhone <: Wasabi.Model
+#     id::Int
+#     user_profile_id::Int
+#     phone::String
+# end
 
 Wasabi.primary_key(m::Type{User}) = Wasabi.PrimaryKeyConstraint(Symbol[:id])
-Wasabi.primary_key(m::Type{UserProfile}) = Wasabi.PrimaryKeyConstraint(Symbol[:id])
+Wasabi.primary_key(m::Type{Role}) = Wasabi.PrimaryKeyConstraint(Symbol[:id])
+Wasabi.foreign_keys(m::Type{Role}) = [Wasabi.ForeignKeyConstraint(Symbol[:user_id], :user, Symbol[:id])]
+Wasabi.exclude_fields(m::Type{User}) = [:roles]
+
+# Wasabi.primary_key(m::Type{UserProfile}) = Wasabi.PrimaryKeyConstraint(Symbol[:id])
 
-Wasabi.foreign_keys(m::Type{UserProfile}) = [Wasabi.ForeignKeyConstraint(Symbol[:user_id], :user, Symbol[:id])]
-Wasabi.foreign_keys(m::Type{UserPhone}) = [Wasabi.ForeignKeyConstraint(Symbol[:user_profile_id], :user_profile, Symbol[:id])]
+# Wasabi.foreign_keys(m::Type{UserPhone}) = [Wasabi.ForeignKeyConstraint(Symbol[:user_profile_id], :user_profile, Symbol[:id])]
 
-Wasabi.unique_constraints(m::Type{UserProfile}) = [Wasabi.UniqueConstraint(Symbol[:user_id])]
+# Wasabi.unique_constraints(m::Type{UserProfile}) = [Wasabi.UniqueConstraint(Symbol[:user_id])]
 
 enabled_tests = lowercase.(ARGS)
 function addtests(fname)

test/sqlite.jl

@@ -18,30 +18,27 @@
 
     apply(patch) do
         @test Wasabi.delete_schema(conn, User) == "DROP TABLE IF EXISTS user"
-        @test Wasabi.delete_schema(conn, UserProfile) == "DROP TABLE IF EXISTS user_profile"
+        @test Wasabi.delete_schema(conn, Role) == "DROP TABLE IF EXISTS role"
         @test Wasabi.create_schema(conn, User) == "CREATE TABLE IF NOT EXISTS user (id INTEGER NOT NULL, name TEXT NOT NULL, created_at TEXT NOT NULL, PRIMARY KEY (id))"
-    end
-
-    apply(patch) do
-        @test Wasabi.create_schema(conn, UserProfile) == "CREATE TABLE IF NOT EXISTS user_profile (id INTEGER NOT NULL, user_id INTEGER NOT NULL, bio TEXT, PRIMARY KEY (id), FOREIGN KEY (user_id) REFERENCES user (id), UNIQUE (user_id))"
+        @test Wasabi.create_schema(conn, Role) == "CREATE TABLE IF NOT EXISTS role (id INTEGER NOT NULL, name TEXT NOT NULL, user_id INTEGER NOT NULL, PRIMARY KEY (id), FOREIGN KEY (user_id) REFERENCES user (id))"
     end
 
     patch_execute_raw_query = @patch Wasabi.execute_query(db::SQLite.DB, query::Wasabi.RawQuery, params::Vector{Any}=Any[]) = query
     apply(patch_execute_raw_query) do
         query = QueryBuilder.from(User) |> QueryBuilder.select([:id, :name]) |> QueryBuilder.limit(1) |> QueryBuilder.offset(1)
         @test Wasabi.execute_query(conn, query) == rq"SELECT user_alias.id, user_alias.name FROM \"user\" user_alias LIMIT 1 OFFSET 1"
 
-        query = QueryBuilder.from(User) |> QueryBuilder.select([:id, :name]) |> QueryBuilder.join(User, UserProfile, :inner, (:id, :user_id), [:bio]) |> QueryBuilder.join(UserProfile, UserPhone, :inner, (:id, :user_profile_id), [:phone])
-        @test Wasabi.execute_query(conn, query) == rq"SELECT user_alias.id, user_alias.name, user_profile_alias.bio, user_phone_alias.phone FROM \"user\" user_alias INNER JOIN \"user_profile\" user_profile_alias ON user_alias.id = user_profile_alias.user_id INNER JOIN \"user_phone\" user_phone_alias ON user_profile_alias.id = user_phone_alias.user_profile_id"
+        query = QueryBuilder.from(User) |> QueryBuilder.select([:id, :name]) |> QueryBuilder.join(User, Role, :inner, (:id, :user_id), [:name])
+        @test Wasabi.execute_query(conn, query) == rq"SELECT user_alias.id, user_alias.name, role_alias.name FROM \"user\" user_alias INNER JOIN \"role\" role_alias ON user_alias.id = role_alias.user_id"
     end
 
     Mocking.deactivate()
 
     Wasabi.delete_schema(conn, User)
-    Wasabi.delete_schema(conn, UserProfile)
+    Wasabi.delete_schema(conn, Role)
 
     Wasabi.create_schema(conn, User)
-    Wasabi.create_schema(conn, UserProfile)
+    Wasabi.create_schema(conn, Role)
 
     dtnow = Dates.now()
     query = rq"INSERT INTO user (name, created_at) VALUES (?, ?)"
@@ -55,7 +52,7 @@
     @test result[!, :created_at][1] == dtnow
 
     user = Wasabi.df2model(User, result)[1]
-    @test user.id == AutoIncrement(1)
+    @test user.id == 1
     @test user.name == "John Doe"
     @test user.created_at == dtnow
 
@@ -74,10 +71,10 @@
 
     users = Wasabi.df2model(User, result)
     @test length(users) == 2
-    @test users[1].id == AutoIncrement(1)
+    @test users[1].id == 1
     @test users[1].name == "John Doe"
     @test users[1].created_at == dtnow
-    @test users[2].id == AutoIncrement(2)
+    @test users[2].id == 2
     @test users[2].name == "Jane Doe"
     @test users[2].created_at == dtnow
 
@@ -100,7 +97,7 @@
     @test length(result[!, :id]) == 3
 
     user = Wasabi.first(conn, User, 1)
-    @test user.id == AutoIncrement(1)
+    @test user.id == 1
     @test user.name == "John Doe"
 
     user = Wasabi.first(conn, User, 10)
@@ -111,15 +108,15 @@
     @test keys[1, 1] == 4
 
     user = Wasabi.first(conn, User, 4)
-    @test user.id == AutoIncrement(4)
+    @test user.id == 4
     @test user.name == "John Doe"
     @test user.created_at == dtnow
 
     user.name = "Jane Doe"
     Wasabi.update!(conn, user)
 
     user = Wasabi.first(conn, User, 4)
-    @test user.id == AutoIncrement(4)
+    @test user.id == 4
     @test user.name == "Jane Doe"
     @test user.created_at == dtnow
 
@@ -135,7 +132,7 @@
     users = Wasabi.execute_query(conn, qb)
     @test length(users[!, :id]) == 1
     user = Wasabi.df2model(User, users)[1]
-    @test user.id == AutoIncrement(2)
+    @test user.id == 2
     @test user.name == "Jane Doe"
     @test user.created_at == dtnow