nix flake, things nix

1 files changed, 931 insertions, 0 deletions

diff --git a/src/ext_depends/d2sqlite3/source/tests.d b/src/ext_depends/d2sqlite3/source/tests.d
new file mode 100644
index 0000000..ff20af1
--- /dev/null
+++ b/src/ext_depends/d2sqlite3/source/tests.d
@@ -0,0 +1,931 @@
+module tests.d;
+
+version (unittest):
+
+import d2sqlite3;
+import std.algorithm;
+import std.exception : assertThrown, assertNotThrown;
+import std.string : format;
+import std.typecons : Nullable;
+import std.conv : hexString;
+
+unittest // Test version of SQLite library
+{
+    import std.string : startsWith;
+    assert(versionString.startsWith("3."));
+    assert(versionNumber >= 3_008_007);
+}
+
+unittest // COV
+{
+    auto ts = threadSafe;
+}
+
+unittest // Configuration logging and db.close()
+{
+    static extern (C) void loggerCallback(void* arg, int code, const(char)* msg) nothrow
+    {
+        ++*(cast(int*) arg);
+    }
+
+    int marker = 42;
+
+    shutdown();
+    config(SQLITE_CONFIG_MULTITHREAD);
+    config(SQLITE_CONFIG_LOG, &loggerCallback, &marker);
+    initialize();
+
+    {
+        auto db = Database(":memory:");
+        try
+        {
+            db.run("DROP TABLE wtf");
+        }
+        catch (Exception e)
+        {
+        }
+        db.close();
+    }
+    assert(marker == 43);
+
+    shutdown();
+    config(SQLITE_CONFIG_LOG, null, null);
+    initialize();
+
+    {
+        auto db = Database(":memory:");
+        try
+        {
+            db.run("DROP TABLE wtf");
+        }
+        catch (Exception e)
+        {
+        }
+    }
+    assert(marker == 43);
+}
+
+unittest // Database.tableColumnMetadata()
+{
+    auto db = Database(":memory:");
+    db.run("CREATE TABLE test (id INTEGER PRIMARY KEY AUTOINCREMENT,
+            val FLOAT NOT NULL)");
+    assert(db.tableColumnMetadata("test", "id") ==
+            TableColumnMetadata("INTEGER", "BINARY", false, true, true));
+    assert(db.tableColumnMetadata("test", "val") ==
+            TableColumnMetadata("FLOAT", "BINARY", true, false, false));
+}
+
+unittest // Database.run()
+{
+    auto db = Database(":memory:");
+    int i;
+    db.run(`SELECT 1; SELECT 2;`, (ResultRange r) { i = r.oneValue!int; return false; });
+    assert(i == 1);
+}
+
+unittest // Database.errorCode()
+{
+    auto db = Database(":memory:");
+    db.run(`SELECT 1;`);
+    assert(db.errorCode == SQLITE_OK);
+    try
+        db.run(`DROP TABLE non_existent`);
+    catch (SqliteException e)
+        assert(db.errorCode == SQLITE_ERROR);
+}
+
+unittest // Database.config
+{
+    auto db = Database(":memory:");
+    db.run(`
+        CREATE TABLE test (val INTEGER);
+        CREATE TRIGGER test_trig BEFORE INSERT ON test
+        BEGIN
+            SELECT RAISE(FAIL, 'Test failed');
+        END;
+    `);
+    int res = 42;
+    db.config(SQLITE_DBCONFIG_ENABLE_TRIGGER, 0, &res);
+    assert(res == 0);
+    db.execute("INSERT INTO test (val) VALUES (1)");
+}
+
+unittest // Database.createFunction(ColumnData[]...)
+{
+    string myList(ColumnData[] args...)
+    {
+        import std.array : appender;
+        import std.string : format, join;
+
+        auto app = appender!(string[]);
+        foreach (arg; args)
+        {
+            if (arg.type == SqliteType.TEXT)
+                app.put(`"%s"`.format(arg));
+            else
+                app.put("%s".format(arg));
+        }
+        return app.data.join(", ");
+    }
+    auto db = Database(":memory:");
+    db.createFunction("my_list", &myList);
+    auto list = db.execute("SELECT my_list(42, 3.14, 'text', x'00FF', NULL)").oneValue!string;
+    assert(list == `42, 3.14, "text", [0, 255], null`, list);
+}
+
+unittest // Database.createFunction() exceptions
+{
+    import std.exception : assertThrown;
+
+    int myFun(int a, int b = 1)
+    {
+        return a * b;
+    }
+
+    auto db = Database(":memory:");
+    db.createFunction("myFun", &myFun);
+    assertThrown!SqliteException(db.execute("SELECT myFun()"));
+    assertThrown!SqliteException(db.execute("SELECT myFun(1, 2, 3)"));
+    assert(db.execute("SELECT myFun(5)").oneValue!int == 5);
+    assert(db.execute("SELECT myFun(5, 2)").oneValue!int == 10);
+
+    db.createFunction("myFun", null);
+    assertThrown!SqliteException(db.execute("SELECT myFun(5)"));
+    assertThrown!SqliteException(db.execute("SELECT myFun(5, 2)"));
+}
+
+unittest // Database.setUpdateHook()
+{
+    int i;
+    auto db = Database(":memory:");
+    db.setUpdateHook((int type, string dbName, string tableName, long rowid) {
+        assert(type == SQLITE_INSERT);
+        assert(dbName == "main");
+        assert(tableName == "test");
+        assert(rowid == 1);
+        i = 42;
+    });
+    db.run("CREATE TABLE test (val INTEGER);
+            INSERT INTO test VALUES (100)");
+    assert(i == 42);
+    db.setUpdateHook(null);
+}
+
+unittest // Database commit and rollback hooks
+{
+    int i;
+    auto db = Database(":memory:");
+    db.setCommitHook({ i = 42; return SQLITE_OK; });
+    db.setRollbackHook({ i = 666; });
+    db.begin();
+    db.execute("CREATE TABLE test (val INTEGER)");
+    db.rollback();
+    assert(i == 666);
+    db.begin();
+    db.execute("CREATE TABLE test (val INTEGER)");
+    db.commit();
+    assert(i == 42);
+    db.setCommitHook(null);
+    db.setRollbackHook(null);
+}
+
+unittest // Miscellaneous functions
+{
+    auto db = Database(":memory:");
+    assert(db.attachedFilePath("main") is null);
+    assert(!db.isReadOnly);
+    db.close();
+}
+
+unittest // Execute an SQL statement
+{
+    auto db = Database(":memory:");
+    db.run("");
+    db.run("-- This is a comment!");
+    db.run(";");
+    db.run("ANALYZE; VACUUM;");
+}
+
+unittest // Unexpected multiple statements
+{
+    auto db = Database(":memory:");
+    db.execute("BEGIN; CREATE TABLE test (val INTEGER); ROLLBACK;");
+    assertThrown(db.execute("DROP TABLE test"));
+
+    db.execute("CREATE TABLE test (val INTEGER); DROP TABLE test;");
+    assertNotThrown(db.execute("DROP TABLE test"));
+
+    db.execute("SELECT 1; CREATE TABLE test (val INTEGER); DROP TABLE test;");
+    assertThrown(db.execute("DROP TABLE test"));
+}
+
+unittest // Multiple statements with callback
+{
+    import std.array : appender;
+    auto db = Database(":memory:");
+    auto test = appender!string;
+    db.run("SELECT 1, 2, 3; SELECT 'A', 'B', 'C';", (ResultRange r) {
+        foreach (col; r.front)
+            test.put(col.as!string);
+        return true;
+    });
+    assert(test.data == "123ABC");
+}
+
+unittest // Different arguments and result types with createFunction
+{
+    auto db = Database(":memory:");
+
+    T display(T)(T value)
+    {
+        return value;
+    }
+
+    db.createFunction("display_integer", &display!int);
+    db.createFunction("display_float", &display!double);
+    db.createFunction("display_text", &display!string);
+    db.createFunction("display_blob", &display!Blob);
+
+    assert(db.execute("SELECT display_integer(42)").oneValue!int == 42);
+    assert(db.execute("SELECT display_float(3.14)").oneValue!double == 3.14);
+    assert(db.execute("SELECT display_text('ABC')").oneValue!string == "ABC");
+    assert(db.execute("SELECT display_blob(x'ABCD')").oneValue!Blob == cast(Blob) hexString!"ABCD");
+
+    assert(db.execute("SELECT display_integer(NULL)").oneValue!int == 0);
+    assert(db.execute("SELECT display_float(NULL)").oneValue!double == 0.0);
+    assert(db.execute("SELECT display_text(NULL)").oneValue!string is null);
+    assert(db.execute("SELECT display_blob(NULL)").oneValue!(Blob) is null);
+}
+
+unittest // Different Nullable argument types with createFunction
+{
+    auto db = Database(":memory:");
+
+    auto display(T : Nullable!U, U...)(T value)
+    {
+        if (value.isNull)
+            return T.init;
+        return value;
+    }
+
+    db.createFunction("display_integer", &display!(Nullable!int));
+    db.createFunction("display_float", &display!(Nullable!double));
+    db.createFunction("display_text", &display!(Nullable!string));
+    db.createFunction("display_blob", &display!(Nullable!Blob));
+
+    assert(db.execute("SELECT display_integer(42)").oneValue!(Nullable!int) == 42);
+    assert(db.execute("SELECT display_float(3.14)").oneValue!(Nullable!double) == 3.14);
+    assert(db.execute("SELECT display_text('ABC')").oneValue!(Nullable!string) == "ABC");
+    assert(db.execute("SELECT display_blob(x'ABCD')").oneValue!(Nullable!Blob) == cast(Blob) hexString!"ABCD");
+
+    assert(db.execute("SELECT display_integer(NULL)").oneValue!(Nullable!int).isNull);
+    assert(db.execute("SELECT display_float(NULL)").oneValue!(Nullable!double).isNull);
+    assert(db.execute("SELECT display_text(NULL)").oneValue!(Nullable!string).isNull);
+    assert(db.execute("SELECT display_blob(NULL)").oneValue!(Nullable!Blob).isNull);
+}
+
+unittest // Callable struct with createFunction
+{
+    import std.functional : toDelegate;
+
+    struct Fun
+    {
+        int factor;
+
+        this(int factor)
+        {
+            this.factor = factor;
+        }
+
+        int opCall(int value)
+        {
+            return value * factor;
+        }
+    }
+
+    auto f = Fun(2);
+    auto db = Database(":memory:");
+    db.createFunction("my_fun", toDelegate(f));
+    assert(db.execute("SELECT my_fun(4)").oneValue!int == 8);
+}
+
+unittest // Callbacks
+{
+    bool wasTraced = false;
+    bool wasProfiled = false;
+    bool hasProgressed = false;
+
+    auto db = Database(":memory:");
+    db.setTraceCallback((string s) { wasTraced = true; });
+    db.execute("SELECT * FROM sqlite_master;");
+    assert(wasTraced);
+    db.setProfileCallback((string s, ulong t) { wasProfiled = true; });
+    db.execute("SELECT * FROM sqlite_master;");
+    assert(wasProfiled);
+
+    db.setProgressHandler(1, { hasProgressed = true; return 0; });
+    db.execute("SELECT * FROM sqlite_master;");
+    assert(hasProgressed);
+}
+
+unittest // Statement.oneValue()
+{
+    Statement statement;
+    {
+        auto db = Database(":memory:");
+        statement = db.prepare(" SELECT 42 ");
+    }
+    assert(statement.execute.oneValue!int == 42);
+}
+
+unittest // Statement.finalize()
+{
+    auto db = Database(":memory:");
+    auto statement = db.prepare(" SELECT 42 ");
+    statement.finalize();
+}
+
+unittest // Simple parameters binding
+{
+    auto db = Database(":memory:");
+    db.execute("CREATE TABLE test (val INTEGER)");
+
+    auto statement = db.prepare("INSERT INTO test (val) VALUES (?)");
+    statement.bind(1, 36);
+    statement.clearBindings();
+    statement.bind(1, 42);
+    statement.execute();
+    statement.reset();
+    statement.bind(1, 42);
+    statement.execute();
+
+    assert(db.lastInsertRowid == 2);
+    assert(db.changes == 1);
+    assert(db.totalChanges == 2);
+
+    auto results = db.execute("SELECT * FROM test");
+    foreach (row; results)
+        assert(row.peek!int(0) == 42);
+}
+
+unittest // Multiple parameters binding
+{
+    auto db = Database(":memory:");
+    db.execute("CREATE TABLE test (i INTEGER, f FLOAT, t TEXT)");
+    auto statement = db.prepare("INSERT INTO test (i, f, t) VALUES (:i, @f, $t)");
+
+    assert(statement.parameterCount == 3);
+    assert(statement.parameterName(2) == "@f");
+    assert(statement.parameterIndex("$t") == 3);
+    assert(statement.parameterIndex(":foo") == 0);
+
+    statement.bind("$t", "TEXT");
+    statement.bind(":i", 42);
+    statement.bind("@f", 3.14);
+    statement.execute();
+    statement.reset();
+    statement.bind(1, 42);
+    statement.bind(2, 3.14);
+    statement.bind(3, "TEXT");
+    statement.execute();
+
+    auto results = db.execute("SELECT * FROM test");
+    foreach (row; results)
+    {
+        assert(row.length == 3);
+        assert(row.peek!int("i") == 42);
+        assert(row.peek!double("f") == 3.14);
+        assert(row.peek!string("t") == "TEXT");
+    }
+}
+
+// Binding/peeking structs with `toString` and `fromString`
+unittest
+{
+    auto db = Database(":memory:");
+    db.execute("CREATE TABLE test (val TEXT)");
+
+    static struct ToStringSink {
+        string value;
+        void toString(scope void delegate(in char[]) sink) const
+        {
+            sink(this.value);
+        }
+    }
+
+    static struct ToStringMethod {
+        string value;
+        string toString() const
+        {
+            return this.value;
+        }
+    }
+
+    auto statement = db.prepare("INSERT INTO test (val) VALUES (?)");
+    statement.bind(1, ToStringMethod("oldmethod"));
+    statement.clearBindings();
+    statement.bind(1, ToStringMethod("method"));
+    statement.execute();
+    statement.reset();
+    statement.bind(1, ToStringSink("sink"));
+    statement.execute();
+
+    assert(db.lastInsertRowid == 2);
+    assert(db.changes == 1);
+    assert(db.totalChanges == 2);
+
+    auto results = db.execute("SELECT * FROM test");
+    results.equal!((a, b) => a.peek!string(0) == b)(["method", "sink"]);
+}
+
+unittest // Multiple parameters binding: tuples
+{
+    auto db = Database(":memory:");
+    db.execute("CREATE TABLE test (i INTEGER, f FLOAT, t TEXT)");
+    auto statement = db.prepare("INSERT INTO test (i, f, t) VALUES (?, ?, ?)");
+    statement.bindAll(42, 3.14, "TEXT");
+    statement.execute();
+
+    auto results = db.execute("SELECT * FROM test");
+    foreach (row; results)
+    {
+        assert(row.length == 3);
+        assert(row.peek!int(0) == 42);
+        assert(row.peek!double(1) == 3.14);
+        assert(row.peek!string(2) == "TEXT");
+    }
+}
+
+unittest // Binding/peeking integral values
+{
+    auto db = Database(":memory:");
+    db.run("CREATE TABLE test (val INTEGER)");
+
+    auto statement = db.prepare("INSERT INTO test (val) VALUES (?)");
+    statement.inject(cast(byte) 42);
+    statement.inject(42U);
+    statement.inject(42UL);
+    statement.inject('\x2A');
+
+    auto results = db.execute("SELECT * FROM test");
+    foreach (row; results)
+        assert(row.peek!long(0) == 42);
+}
+
+void foobar() // Binding/peeking floating point values
+{
+    auto db = Database(":memory:");
+    db.run("CREATE TABLE test (val FLOAT)");
+
+    auto statement = db.prepare("INSERT INTO test (val) VALUES (?)");
+    statement.inject(42.0F);
+    statement.inject(42.0);
+    statement.inject(42.0L);
+    statement.inject("42");
+
+    auto results = db.execute("SELECT * FROM test");
+    foreach (row; results)
+        assert(row.peek!double(0) == 42.0);
+}
+
+unittest // Binding/peeking text values
+{
+    auto db = Database(":memory:");
+    db.run("CREATE TABLE test (val TEXT);
+            INSERT INTO test (val) VALUES ('I am a text.')");
+
+    auto results = db.execute("SELECT * FROM test");
+    assert(results.front.peek!(string, PeekMode.slice)(0) == "I am a text.");
+    assert(results.front.peek!(string, PeekMode.copy)(0) == "I am a text.");
+
+    import std.exception : assertThrown;
+    import std.variant : VariantException;
+    assertThrown!VariantException(results.front[0].as!Blob);
+}
+
+unittest // Binding/peeking blob values
+{
+    auto db = Database(":memory:");
+    db.execute("CREATE TABLE test (val BLOB)");
+
+    auto statement = db.prepare("INSERT INTO test (val) VALUES (?)");
+    auto array = cast(Blob) [1, 2, 3];
+    statement.inject(array);
+    ubyte[3] sarray = [1, 2, 3];
+    statement.inject(sarray);
+
+    auto results = db.execute("SELECT * FROM test");
+    foreach (row; results)
+    {
+        assert(row.peek!(Blob, PeekMode.slice)(0) ==  [1, 2, 3]);
+        assert(row[0].as!Blob == [1, 2, 3]);
+    }
+}
+
+unittest // Struct injecting
+{
+    static struct Test
+    {
+        int i;
+        double f;
+        string t;
+    }
+
+    auto db = Database(":memory:");
+    db.execute("CREATE TABLE test (i INTEGER, f FLOAT, t TEXT)");
+    auto statement = db.prepare("INSERT INTO test (i, f, t) VALUES (?, ?, ?)");
+    auto test = Test(42, 3.14, "TEXT");
+    statement.inject(test);
+    statement.inject(Test(42, 3.14, "TEXT"));
+    auto itest = cast(immutable) Test(42, 3.14, "TEXT");
+    statement.inject(itest);
+
+    auto results = db.execute("SELECT * FROM test");
+    assert(!results.empty);
+    foreach (row; results)
+    {
+        assert(row.length == 3);
+        assert(row.peek!int(0) == 42);
+        assert(row.peek!double(1) == 3.14);
+        assert(row.peek!string(2) == "TEXT");
+    }
+}
+
+unittest // Iterable struct injecting
+{
+    import std.range : iota;
+
+    auto db = Database(":memory:");
+    db.execute("CREATE TABLE test (a INTEGER, b INTEGER, c INTEGER)");
+    auto statement = db.prepare("INSERT INTO test (a, b, c) VALUES (?, ?, ?)");
+    statement.inject(iota(0, 3));
+
+    auto results = db.execute("SELECT * FROM test");
+    assert(!results.empty);
+    foreach (row; results)
+    {
+        assert(row.length == 3);
+        assert(row.peek!int(0) == 0);
+        assert(row.peek!int(1) == 1);
+        assert(row.peek!int(2) == 2);
+    }
+}
+
+unittest // Injecting nullable
+{
+    import std.array : array;
+
+    auto db = Database(":memory:");
+    db.execute("CREATE TABLE test (i INTEGER, s TEXT)");
+    auto statement = db.prepare("INSERT INTO test (i, s) VALUES (?, ?)");
+    statement.inject(Nullable!int(1), "one");
+    statement = db.prepare("INSERT INTO test (i) VALUES (?)");
+    statement.inject(Nullable!int.init);
+
+    auto results = db.execute("SELECT i FROM test ORDER BY rowid");
+    assert(results.equal!((a, b) => a.peek!(Nullable!int)(0) == b)(
+               [ Nullable!int(1), Nullable!int.init ] ));
+}
+
+unittest // Injecting tuple
+{
+    import std.typecons : tuple;
+
+    auto db = Database(":memory:");
+    db.execute("CREATE TABLE test (i INTEGER, f FLOAT, t TEXT)");
+    auto statement = db.prepare("INSERT INTO test (i, f, t) VALUES (?, ?, ?)");
+    statement.inject(tuple(42, 3.14, "TEXT"));
+
+    auto results = db.execute("SELECT * FROM test");
+    foreach (row; results)
+    {
+        assert(row.length == 3);
+        assert(row.peek!int(0) == 42);
+        assert(row.peek!double(1) == 3.14);
+        assert(row.peek!string(2) == "TEXT");
+    }
+}
+
+unittest // Injecting dict
+{
+    auto db = Database(":memory:");
+    db.execute("CREATE TABLE test (a TEXT, b TEXT, c TEXT)");
+    auto statement = db.prepare("INSERT INTO test (c, b, a) VALUES (:c, :b, :a)");
+    statement.inject([":a":"a", ":b":"b", ":c":"c"]);
+
+    auto results = db.execute("SELECT * FROM test");
+    foreach (row; results)
+    {
+        assert(row.length == 3);
+        assert(row.peek!string(0) == "a");
+        assert(row.peek!string(1) == "b");
+        assert(row.peek!string(2) == "c");
+    }
+}
+
+unittest // Binding Nullable
+{
+    auto db = Database(":memory:");
+    db.execute("CREATE TABLE test (a, b, c, d, e);");
+
+    auto statement = db.prepare("INSERT INTO test (a,b,c,d,e) VALUES (?,?,?,?,?)");
+    statement.bind(1, Nullable!int(123));
+    statement.bind(2, Nullable!int());
+    statement.bind(3, Nullable!(uint, 0)(42));
+    statement.bind(4, Nullable!(uint, 0)());
+    statement.bind(5, Nullable!bool(false));
+    statement.execute();
+
+    auto results = db.execute("SELECT * FROM test");
+    foreach (row; results)
+    {
+        assert(row.length == 5);
+        assert(row.peek!int(0) == 123);
+        assert(row.columnType(1) == SqliteType.NULL);
+        assert(row.peek!int(2) == 42);
+        assert(row.columnType(3) == SqliteType.NULL);
+        assert(!row.peek!bool(4));
+    }
+}
+
+unittest // Peeking Nullable
+{
+    auto db = Database(":memory:");
+    auto results = db.execute("SELECT 1, NULL, 8.5, NULL");
+    foreach (row; results)
+    {
+        assert(row.length == 4);
+        assert(row.peek!(Nullable!double)(2).get == 8.5);
+        assert(row.peek!(Nullable!double)(3).isNull);
+        assert(row.peek!(Nullable!(int, 0))(0).get == 1);
+        assert(row.peek!(Nullable!(int, 0))(1).isNull);
+    }
+}
+
+unittest // GC anchoring test
+{
+    import core.memory : GC;
+
+    auto db = Database(":memory:");
+    auto stmt = db.prepare("SELECT ?");
+
+    auto str = ("I am test string").dup;
+    stmt.bind(1, str);
+    str = null;
+
+    foreach (_; 0..3)
+    {
+        GC.collect();
+        GC.minimize();
+    }
+
+    ResultRange results = stmt.execute();
+    foreach(row; results)
+    {
+        assert(row.length == 1);
+        assert(row.peek!string(0) == "I am test string");
+    }
+}
+
+version (unittest) // ResultRange is an input range of Row
+{
+    import std.range.primitives : isInputRange, ElementType;
+    static assert(isInputRange!ResultRange);
+    static assert(is(ElementType!ResultRange == Row));
+}
+
+unittest // Statement error
+{
+    auto db = Database(":memory:");
+    db.execute("CREATE TABLE test (val INTEGER NOT NULL)");
+    auto stmt = db.prepare("INSERT INTO test (val) VALUES (?)");
+    stmt.bind(1, null);
+    import std.exception : assertThrown;
+    assertThrown!SqliteException(stmt.execute());
+}
+
+version (unittest) // Row is a random access range of ColumnData
+{
+    import std.range.primitives : isRandomAccessRange, ElementType;
+    static assert(isRandomAccessRange!Row);
+    static assert(is(ElementType!Row == ColumnData));
+}
+
+unittest // Row.init
+{
+    import core.exception : AssertError;
+
+    Row row;
+    assert(row.empty);
+    assertThrown!AssertError(row.front);
+    assertThrown!AssertError(row.back);
+    assertThrown!AssertError(row.popFront);
+    assertThrown!AssertError(row.popBack);
+    assertThrown!AssertError(row[""]);
+    assertThrown!AssertError(row.peek!long(0));
+}
+
+unittest // Peek
+{
+    auto db = Database(":memory:");
+    db.run("CREATE TABLE test (value);
+            INSERT INTO test VALUES (NULL);
+            INSERT INTO test VALUES (42);
+            INSERT INTO test VALUES (3.14);
+            INSERT INTO test VALUES ('ABC');
+            INSERT INTO test VALUES (x'DEADBEEF');");
+
+    import std.math : isNaN;
+    auto results = db.execute("SELECT * FROM test");
+    auto row = results.front;
+    assert(row.peek!long(0) == 0);
+    assert(row.peek!double(0) == 0);
+    assert(row.peek!string(0) is null);
+    assert(row.peek!Blob(0) is null);
+    results.popFront();
+    row = results.front;
+    assert(row.peek!long(0) == 42);
+    assert(row.peek!double(0) == 42);
+    assert(row.peek!string(0) == "42");
+    assert(row.peek!Blob(0) == cast(Blob) "42");
+    results.popFront();
+    row = results.front;
+    assert(row.peek!long(0) == 3);
+    assert(row.peek!double(0) == 3.14);
+    assert(row.peek!string(0) == "3.14");
+    assert(row.peek!Blob(0) == cast(Blob) "3.14");
+    results.popFront();
+    row = results.front;
+    assert(row.peek!long(0) == 0);
+    assert(row.peek!double(0) == 0.0);
+    assert(row.peek!string(0) == "ABC");
+    assert(row.peek!Blob(0) == cast(Blob) "ABC");
+    results.popFront();
+    row = results.front;
+    assert(row.peek!long(0) == 0);
+    assert(row.peek!double(0) == 0.0);
+    assert(row.peek!string(0) == hexString!"DEADBEEF");
+    assert(row.peek!Blob(0) == cast(Blob) hexString!"DEADBEEF");
+}
+
+unittest // Peeking NULL values
+{
+    auto db = Database(":memory:");
+    db.run("CREATE TABLE test (val TEXT);
+            INSERT INTO test (val) VALUES (NULL)");
+
+    auto results = db.execute("SELECT * FROM test");
+    assert(results.front.peek!bool(0) == false);
+    assert(results.front.peek!long(0) == 0);
+    assert(results.front.peek!double(0) == 0);
+    assert(results.front.peek!string(0) is null);
+    assert(results.front.peek!Blob(0) is null);
+}
+
+unittest // Row life-time
+{
+    auto db = Database(":memory:");
+    auto row = db.execute("SELECT 1 AS one").front;
+    assert(row[0].as!long == 1);
+    assert(row["one"].as!long == 1);
+}
+
+unittest // PeekMode
+{
+    auto db = Database(":memory:");
+    db.run("CREATE TABLE test (value);
+            INSERT INTO test VALUES (x'01020304');
+            INSERT INTO test VALUES (x'0A0B0C0D');");
+
+    auto results = db.execute("SELECT * FROM test");
+    auto row = results.front;
+    auto b1 = row.peek!(Blob, PeekMode.copy)(0);
+    auto b2 = row.peek!(Blob, PeekMode.slice)(0);
+    results.popFront();
+    row = results.front;
+    auto b3 = row.peek!(Blob, PeekMode.slice)(0);
+    auto b4 = row.peek!(Nullable!Blob, PeekMode.copy)(0);
+    assert(b1 == cast(Blob) hexString!"01020304");
+    // assert(b2 != cast(Blob) x"01020304"); // PASS if SQLite reuses internal buffer
+    // assert(b2 == cast(Blob) x"0A0B0C0D"); // PASS (idem)
+    assert(b3 == cast(Blob) hexString!"0A0B0C0D");
+    assert(!b4.isNull && b4 == cast(Blob) hexString!"0A0B0C0D");
+}
+
+unittest // Row random-access range interface
+{
+    import std.array : front, popFront;
+
+    auto db = Database(":memory:");
+    db.run("CREATE TABLE test (a INTEGER, b INTEGER, c INTEGER, d INTEGER);
+        INSERT INTO test VALUES (1, 2, 3, 4);
+        INSERT INTO test VALUES (5, 6, 7, 8);");
+
+    {
+        auto results = db.execute("SELECT * FROM test");
+        auto values = [1, 2, 3, 4, 5, 6, 7, 8];
+        foreach (row; results)
+        {
+            while (!row.empty)
+            {
+                assert(row.front.as!int == values.front);
+                row.popFront();
+                values.popFront();
+            }
+        }
+    }
+
+    {
+        auto results = db.execute("SELECT * FROM test");
+        auto values = [4, 3, 2, 1, 8, 7, 6, 5];
+        foreach (row; results)
+        {
+            while (!row.empty)
+            {
+                assert(row.back.as!int == values.front);
+                row.popBack();
+                values.popFront();
+            }
+        }
+    }
+
+    {
+        auto row = db.execute("SELECT * FROM test").front;
+        row.popFront();
+        auto copy = row.save();
+        row.popFront();
+        assert(row.front.as!int == 3);
+        assert(copy.front.as!int == 2);
+    }
+}
+
+unittest // ColumnData.init
+{
+    import core.exception : AssertError;
+    ColumnData data;
+    assertThrown!AssertError(data.type);
+    assertThrown!AssertError(data.as!string);
+}
+
+unittest // ColumnData-compatible types
+{
+    import std.meta : AliasSeq;
+
+    alias AllCases = AliasSeq!(bool, true, int, int.max, float, float.epsilon,
+        real, 42.0L, string, "おはよう！", const(ubyte)[], [0x00, 0xFF],
+        string, "", Nullable!byte, 42);
+
+    void test(Cases...)()
+    {
+        auto cd = ColumnData(Cases[1]);
+        assert(cd.as!(Cases[0]) == Cases[1]);
+        static if (Cases.length > 2)
+            test!(Cases[2..$])();
+    }
+
+    test!AllCases();
+}
+
+unittest // ColumnData.toString
+{
+    auto db = Database(":memory:");
+    auto rc = db.execute("SELECT 42, 3.14, 'foo_bar', x'00FF', NULL").cached;
+    assert("%(%s%)".format(rc) == "[42, 3.14, foo_bar, [0, 255], null]");
+}
+
+unittest // CachedResults copies
+{
+    auto db = Database(":memory:");
+    db.run("CREATE TABLE test (msg TEXT);
+            INSERT INTO test (msg) VALUES ('ABC')");
+
+    static getdata(Database db)
+    {
+        return db.execute("SELECT * FROM test").cached;
+    }
+
+    auto data = getdata(db);
+    assert(data.length == 1);
+    assert(data[0][0].as!string == "ABC");
+}
+
+unittest // UTF-8
+{
+    auto db = Database(":memory:");
+    bool ran = false;
+    db.run("SELECT '\u2019\u2019';", (ResultRange r) {
+        assert(r.oneValue!string == "\u2019\u2019");
+        ran = true;
+        return true;
+    });
+    assert(ran);
+}
+
+unittest // loadExtension failure test
+{
+    import std.exception : collectExceptionMsg;
+    auto db = Database(":memory:");
+    auto msg = collectExceptionMsg(db.loadExtension("foobar"));
+    assert(msg.canFind("(not authorized)"));
+}