implement NullableModelRef

Author: WebFreak001

integration-tests/one-to-many/source/app.d

@@ -8,9 +8,11 @@ import std.datetime.systime;
 import std.exception;
 import std.range;
 import std.stdio;
+import std.typecons;
 
 import dorm.api.db;
 import dorm.declarative.conversion;
+import dorm.types.relations;
 
 mixin SetupDormRuntime;
 
@@ -32,10 +34,18 @@ void main()
 	db.insert(user2);
 
 	Toot toot = new Toot();
+	toot.id = 1;
 	toot.message = "Hello world!";
 	toot.author = user;
 	db.insert(toot);
 
+	Toot toot2 = new Toot();
+	toot2.id = 2;
+	toot2.message = "Hello world!";
+	toot2.author = user;
+	toot2.dmTo = ModelRef!User(user2);
+	db.insert(toot2);
+
 	Comment.Fields comment;
 	comment.replyTo = toot;
 	comment.message = "Very cool!";
@@ -48,6 +58,13 @@ void main()
 	comment2.author.foreignKey = user2.id;
 	db.insert(comment2);
 
+	auto allToots = db.select!Toot
+		.array;
+	assert(allToots.length == 2);
+	assert(allToots[0].dmTo.isNull);
+	assert(!allToots[1].dmTo.isNull);
+	assert(allToots[1].dmTo.get.foreignKey == user2.id);
+
 	auto allComments = db.select!Comment
 		.array;
 	assert(allComments.length == 2);

integration-tests/one-to-many/source/models.d

@@ -22,6 +22,7 @@ class Toot : Model
 	@autoCreateTime
 	SysTime createdAt;
 	ModelRef!User author;
+	NullableModelRef!User dmTo;
 }
 
 @DormPatch!User

source/dorm/api/db.d

@@ -9,22 +9,22 @@ import dorm.types;
 import ffi = dorm.lib.ffi;
 
 import std.algorithm : any, move;
-import std.range : chain;
 import std.conv : text, to;
 import std.datetime : Clock, Date, DateTime, DateTimeException, SysTime, TimeOfDay, UTC;
 import std.meta;
+import std.range : chain;
 import std.range.primitives;
 import std.traits;
 import std.typecons : Nullable;
 
-import mir.serde;
 import mir.algebraic;
+import mir.serde;
 
 import core.attribute;
 import core.time;
 
-public import dorm.types : DormPatch;
 public import dorm.lib.ffi : DBBackend;
+public import dorm.types : DormPatch;
 
 public import dorm.api.condition;
 
@@ -58,7 +58,7 @@ struct BareConfiguration
 T parseTomlConfig(T)(string filename)
 {
 	import mir.toml;
-	import std.file : readText, exists;
+	import std.file : exists, readText;
 
 	if (!exists(filename))
 		throw new DormException("TOML Configuration file '" ~ filename
@@ -342,7 +342,7 @@ struct DormDB
 		return RawSQLIterator(&this, null, queryString, bindParams);
 	}
 
-	/** 
+	/**
 	 * Using a `ModelRef` as an argument this queries for the value referenced
 	 * to by the foreign key. Assigns the result into the `ModelRef` field, so
 	 * `field.populated` can be called by the user afterwards to work on the
@@ -723,12 +723,15 @@ struct DormTransaction
 		return remove!T.single(instance);
 	}
 
-	/** 
+	/**
 	 * Using a `ModelRef` as an argument this queries for the value referenced
 	 * to by the foreign key. Assigns the result into the `ModelRef` field, so
 	 * `field.populated` can be called by the user afterwards to work on the
 	 * data that was queried with `populate`.
 	 *
+	 * Also supports `Nullable!ModelRef`, ignoring it if it is null, otherwise
+	 * unwrapping it.
+	 *
 	 * Params:
 	 *     field = a reference to a `ModelRef` variable or multiple by reference.
 	 */
@@ -752,6 +755,15 @@ if (isModelRef!T)
 		.findOne();
 }
 
+private void populateImpl(DB, T)(ref DB db, ref Nullable!T field) @safe
+if (isModelRef!T)
+{
+	if (!field.isNull)
+		field = db.select!(T.TSelect)
+			.condition(c => __traits(getMember, c, T.primaryKeySourceName).equals(field.get.foreignKey))
+			.findOne();
+}
+
 private void populateImpl(DB, T)(ref DB db, T*[] fields) @safe
 if (isModelRef!T)
 {
@@ -768,6 +780,24 @@ if (isModelRef!T)
 	})();
 }
 
+private void populateImpl(DB, T)(ref DB db, Nullable!T*[] fields) @safe
+if (isModelRef!T)
+{
+	import std.algorithm : filter, map;
+
+	auto q = db.select!(T.TSelect)
+		.condition(c => __traits(getMember, c, T.primaryKeySourceName).among(fields
+			.filter!"!a.isNull"
+			.map!"a.get.foreignKey"));
+
+	(() @trusted {
+		foreach (row; q.stream())
+			foreach (field; fields)
+				if (!field.foreignKey.isNull && field.foreignKey.get == mixin("row.", T.primaryKeySourceName))
+					field.opAssign(row);
+	})();
+}
+
 private string makePatchAccessPrefix(Patch, DB)()
 {
 	string ret;
@@ -2821,8 +2851,8 @@ private T extractField(alias field, T, string errInfo)(
 	scope const(char)[] columnPrefix
 ) @trusted
 {
-	import std.conv;
 	import dorm.declarative;
+	import std.conv;
 
 	scope columnName = ffi.ffi(columnPrefix.length
 		? columnPrefix ~ field.columnName
@@ -3073,8 +3103,8 @@ mixin template SetupDormRuntime(alias timeout = 10.seconds)
 
 	shared static this() @trusted
 	{
-		import dorm.lib.util : sync_call;
 		import dorm.lib.ffi : rorm_runtime_start;
+		import dorm.lib.util : sync_call;
 
 		sync_call!(rorm_runtime_start)();
 		_initializedDormRuntime = true;
@@ -3083,8 +3113,8 @@ mixin template SetupDormRuntime(alias timeout = 10.seconds)
 	shared static ~this() @trusted
 	{
 		import core.time : Duration;
-		import dorm.lib.util;
 		import dorm.lib.ffi : rorm_runtime_shutdown;
+		import dorm.lib.util;
 
 		if (_initializedDormRuntime)
 		{

source/dorm/declarative/conversion.d

@@ -1030,6 +1030,51 @@ unittest
 	]);
 }
 
+unittest
+{
+	struct Mod
+	{
+		class User : Model
+		{
+			@maxLength(255) @primaryKey
+			string username;
+		}
+
+		class Toot : Model
+		{
+			@Id long id;
+
+			NullableModelRef!(User.username) author;
+		}
+	}
+
+	static assert(DormForeignKeys!(Mod.Toot).length == 1);
+	static assert(DormForeignKeys!(Mod.Toot)[0].columnName == "author");
+
+	auto mod = processModelsToDeclarations!Mod;
+	assert(mod.models.length == 2);
+	auto m = mod.models[0];
+	assert(m.fields.length == 1);
+
+	assert(m.fields[0].columnName == "username");
+	assert(m.fields[0].annotations == [
+		DBAnnotation(maxLength(255)),
+		DBAnnotation(AnnotationFlag.primaryKey)
+	]);
+
+	m = mod.models[1];
+	assert(m.fields.length == 2);
+
+	assert(m.fields[1].columnName == "author");
+	assert(m.fields[1].annotations == [
+		DBAnnotation(maxLength(255)),
+		DBAnnotation(ForeignKeyImpl(
+			"user", "username",
+			restrict, restrict
+		))
+	]);
+}
+
 unittest
 {
 	// cyclic ref

source/dorm/types/relations.d

@@ -92,8 +92,6 @@ version(none) static struct ManyToManyField(alias idOrModel)
  * supporting proactively fetched joined data from the database. Trying to
  * access the populated data without having it populated will result in a
  * program crash through `assert(false)`.
- *
- * Bugs: `db.populate(ModelRef)` is not yet implemented
  */
 static template ModelRef(alias idOrPatch)
 {
@@ -199,6 +197,9 @@ static struct ModelRefImpl(alias id, _TModel, _TSelect)
 	}
 }
 
+/// Alias for `Nullable!(ModelRef!T)`, indicating a reference which can be null.
+alias NullableModelRef(alias T) = Nullable!(ModelRef!T);
+
 static template ModelRefOf(alias field)
 {
 	alias T = typeof(field);