Format all code with clang-format

7 files changed, 2446 insertions, 2432 deletions

diff --git a/src/sord.c b/src/sord.c
index b870e1a..45881a3 100644
--- a/src/sord.c
+++ b/src/sord.c
@@ -37,67 +37,73 @@
 #include <string.h>
 
 #ifdef __GNUC__
-#    define SORD_LOG_FUNC(fmt, arg1) __attribute__((format(printf, fmt, arg1)))
+#  define SORD_LOG_FUNC(fmt, arg1) __attribute__((format(printf, fmt, arg1)))
 #else
-#    define SORD_LOG_FUNC(fmt, arg1)
+#  define SORD_LOG_FUNC(fmt, arg1)
 #endif
 
 #define SORD_LOG(prefix, ...) fprintf(stderr, "[Sord::" prefix "] " __VA_ARGS__)
 
 #ifdef SORD_DEBUG_ITER
-#    define SORD_ITER_LOG(...) SORD_LOG("iter", __VA_ARGS__)
+#  define SORD_ITER_LOG(...) SORD_LOG("iter", __VA_ARGS__)
 #else
-#    define SORD_ITER_LOG(...)
+#  define SORD_ITER_LOG(...)
 #endif
 #ifdef SORD_DEBUG_SEARCH
-#    define SORD_FIND_LOG(...) SORD_LOG("search", __VA_ARGS__)
+#  define SORD_FIND_LOG(...) SORD_LOG("search", __VA_ARGS__)
 #else
-#    define SORD_FIND_LOG(...)
+#  define SORD_FIND_LOG(...)
 #endif
 #ifdef SORD_DEBUG_WRITE
-#    define SORD_WRITE_LOG(...) SORD_LOG("write", __VA_ARGS__)
+#  define SORD_WRITE_LOG(...) SORD_LOG("write", __VA_ARGS__)
 #else
-#    define SORD_WRITE_LOG(...)
+#  define SORD_WRITE_LOG(...)
 #endif
 
-#define NUM_ORDERS          12
-#define STATEMENT_LEN       3
-#define TUP_LEN             (STATEMENT_LEN + 1)
-#define DEFAULT_ORDER       SPO
+#define NUM_ORDERS 12
+#define STATEMENT_LEN 3
+#define TUP_LEN (STATEMENT_LEN + 1)
+#define DEFAULT_ORDER SPO
 #define DEFAULT_GRAPH_ORDER GSPO
 
-#define TUP_FMT         "(%s %s %s %s)"
+#define TUP_FMT "(%s %s %s %s)"
 #define TUP_FMT_ELEM(e) ((e) ? sord_node_get_string(e) : (const uint8_t*)"*")
-#define TUP_FMT_ARGS(t) \
-	TUP_FMT_ELEM((t)[0]), \
-	TUP_FMT_ELEM((t)[1]), \
-	TUP_FMT_ELEM((t)[2]), \
-	TUP_FMT_ELEM((t)[3])
+#define TUP_FMT_ARGS(t)                                             \
+  TUP_FMT_ELEM((t)[0]), TUP_FMT_ELEM((t)[1]), TUP_FMT_ELEM((t)[2]), \
+    TUP_FMT_ELEM((t)[3])
 
 #define TUP_G 3
 
 /** Triple ordering */
 typedef enum {
-	SPO,   ///<         Subject,   Predicate, Object
-	SOP,   ///<         Subject,   Object,    Predicate
-	OPS,   ///<         Object,    Predicate, Subject
-	OSP,   ///<         Object,    Subject,   Predicate
-	PSO,   ///<         Predicate, Subject,   Object
-	POS,   ///<         Predicate, Object,    Subject
-	GSPO,  ///< Graph,  Subject,   Predicate, Object
-	GSOP,  ///< Graph,  Subject,   Object,    Predicate
-	GOPS,  ///< Graph,  Object,    Predicate, Subject
-	GOSP,  ///< Graph,  Object,    Subject,   Predicate
-	GPSO,  ///< Graph,  Predicate, Subject,   Object
-	GPOS   ///< Graph,  Predicate, Object,    Subject
+  SPO,  ///<         Subject,   Predicate, Object
+  SOP,  ///<         Subject,   Object,    Predicate
+  OPS,  ///<         Object,    Predicate, Subject
+  OSP,  ///<         Object,    Subject,   Predicate
+  PSO,  ///<         Predicate, Subject,   Object
+  POS,  ///<         Predicate, Object,    Subject
+  GSPO, ///< Graph,  Subject,   Predicate, Object
+  GSOP, ///< Graph,  Subject,   Object,    Predicate
+  GOPS, ///< Graph,  Object,    Predicate, Subject
+  GOSP, ///< Graph,  Object,    Subject,   Predicate
+  GPSO, ///< Graph,  Predicate, Subject,   Object
+  GPOS  ///< Graph,  Predicate, Object,    Subject
 } SordOrder;
 
 #ifdef SORD_DEBUG_SEARCH
 /** String name of each ordering (array indexed by SordOrder) */
-static const char* const order_names[NUM_ORDERS] = {
-	"spo",  "sop",  "ops",  "osp",  "pso",  "pos",
-	"gspo", "gsop", "gops", "gosp", "gpso", "gpos"
-};
+static const char* const order_names[NUM_ORDERS] = {"spo",
+                                                    "sop",
+                                                    "ops",
+                                                    "osp",
+                                                    "pso",
+                                                    "pos",
+                                                    "gspo",
+                                                    "gsop",
+                                                    "gops",
+                                                    "gosp",
+                                                    "gpso",
+                                                    "gpos"};
 #endif
 
 /**
@@ -105,128 +111,134 @@ static const char* const order_names[NUM_ORDERS] = {
    (array indexed by SordOrder)
 */
 static const int orderings[NUM_ORDERS][TUP_LEN] = {
-	{ 0, 1, 2, 3 }, { 0, 2, 1, 3 },  // SPO, SOP
-	{ 2, 1, 0, 3 }, { 2, 0, 1, 3 },  // OPS, OSP
-	{ 1, 0, 2, 3 }, { 1, 2, 0, 3 },  // PSO, POS
-	{ 3, 0, 1, 2 }, { 3, 0, 2, 1 },  // GSPO, GSOP
-	{ 3, 2, 1, 0 }, { 3, 2, 0, 1 },  // GOPS, GOSP
-	{ 3, 1, 0, 2 }, { 3, 1, 2, 0 }   // GPSO, GPOS
+  {0, 1, 2, 3}, // SPO
+  {0, 2, 1, 3}, // SOP
+  {2, 1, 0, 3}, // OPS
+  {2, 0, 1, 3}, // OSP
+  {1, 0, 2, 3}, // PSO
+  {1, 2, 0, 3}, // POS
+  {3, 0, 1, 2}, // GSPO
+  {3, 0, 2, 1}, // GSOP
+  {3, 2, 1, 0}, // GOPS
+  {3, 2, 0, 1}, // GOSP
+  {3, 1, 0, 2}, // GPSO
+  {3, 1, 2, 0}  // GPOS
 };
 
 /** World */
 struct SordWorldImpl {
-	ZixHash*      nodes;
-	SerdErrorSink error_sink;
-	void*         error_handle;
+  ZixHash*      nodes;
+  SerdErrorSink error_sink;
+  void*         error_handle;
 };
 
 /** Store */
 struct SordModelImpl {
-	SordWorld* world;
+  SordWorld* world;
 
-	/** Index for each possible triple ordering (may or may not exist).
-	 * Each index is a tree of SordQuad with the appropriate ordering.
-	 */
-	ZixBTree* indices[NUM_ORDERS];
+  /** Index for each possible triple ordering (may or may not exist).
+   * Each index is a tree of SordQuad with the appropriate ordering.
+   */
+  ZixBTree* indices[NUM_ORDERS];
 
-	size_t n_quads;
-	size_t n_iters;
+  size_t n_quads;
+  size_t n_iters;
 };
 
 /** Mode for searching or iteration */
 typedef enum {
-	ALL,           ///< Iterate over entire store
-	SINGLE,        ///< Iteration over a single element (exact search)
-	RANGE,         ///< Iterate over range with equal prefix
-	FILTER_RANGE,  ///< Iterate over range with equal prefix, filtering
-	FILTER_ALL     ///< Iterate to end of store, filtering
+  ALL,          ///< Iterate over entire store
+  SINGLE,       ///< Iteration over a single element (exact search)
+  RANGE,        ///< Iterate over range with equal prefix
+  FILTER_RANGE, ///< Iterate over range with equal prefix, filtering
+  FILTER_ALL    ///< Iterate to end of store, filtering
 } SearchMode;
 
 /** Iterator over some range of a store */
 struct SordIterImpl {
-	const SordModel* sord;               ///< Model being iterated over
-	ZixBTreeIter*    cur;                ///< Current DB cursor
-	SordQuad         pat;                ///< Pattern (in ordering order)
-	SordOrder        order;              ///< Store order (which index)
-	SearchMode       mode;               ///< Iteration mode
-	int              n_prefix;           ///< Prefix for RANGE and FILTER_RANGE
-	bool             end;                ///< True iff reached end
-	bool             skip_graphs;        ///< Iteration should ignore graphs
+  const SordModel* sord;        ///< Model being iterated over
+  ZixBTreeIter*    cur;         ///< Current DB cursor
+  SordQuad         pat;         ///< Pattern (in ordering order)
+  SordOrder        order;       ///< Store order (which index)
+  SearchMode       mode;        ///< Iteration mode
+  int              n_prefix;    ///< Prefix for RANGE and FILTER_RANGE
+  bool             end;         ///< True iff reached end
+  bool             skip_graphs; ///< Iteration should ignore graphs
 };
 
 static uint32_t
 sord_node_hash(const void* n)
 {
-	const SordNode* node = (const SordNode*)n;
-	uint32_t        hash = zix_digest_start();
-	hash = zix_digest_add(hash, node->node.buf, node->node.n_bytes);
-	hash = zix_digest_add(hash, &node->node.type, sizeof(node->node.type));
-	if (node->node.type == SERD_LITERAL) {
-		hash = zix_digest_add(hash, &node->meta.lit, sizeof(node->meta.lit));
-	}
-	return hash;
+  const SordNode* node = (const SordNode*)n;
+  uint32_t        hash = zix_digest_start();
+  hash = zix_digest_add(hash, node->node.buf, node->node.n_bytes);
+  hash = zix_digest_add(hash, &node->node.type, sizeof(node->node.type));
+  if (node->node.type == SERD_LITERAL) {
+    hash = zix_digest_add(hash, &node->meta.lit, sizeof(node->meta.lit));
+  }
+  return hash;
 }
 
 static bool
 sord_node_hash_equal(const void* a, const void* b)
 {
-	const SordNode* a_node = (const SordNode*)a;
-	const SordNode* b_node = (const SordNode*)b;
-	return (a_node == b_node)
-		|| ((a_node->node.type == b_node->node.type) &&
-		    (a_node->node.type != SERD_LITERAL ||
-		     (a_node->meta.lit.datatype == b_node->meta.lit.datatype &&
-		      !strncmp(a_node->meta.lit.lang,
-		               b_node->meta.lit.lang,
-		               sizeof(a_node->meta.lit.lang)))) &&
-		    (serd_node_equals(&a_node->node, &b_node->node)));
+  const SordNode* a_node = (const SordNode*)a;
+  const SordNode* b_node = (const SordNode*)b;
+  return (a_node == b_node) ||
+         ((a_node->node.type == b_node->node.type) &&
+          (a_node->node.type != SERD_LITERAL ||
+           (a_node->meta.lit.datatype == b_node->meta.lit.datatype &&
+            !strncmp(a_node->meta.lit.lang,
+                     b_node->meta.lit.lang,
+                     sizeof(a_node->meta.lit.lang)))) &&
+          (serd_node_equals(&a_node->node, &b_node->node)));
 }
 
 SORD_LOG_FUNC(3, 4)
 static void
 error(SordWorld* world, SerdStatus st, const char* fmt, ...)
 {
-	va_list args;
-	va_start(args, fmt);
-	const SerdError e = { st, NULL, 0, 0, fmt, &args };
-	if (world->error_sink) {
-		world->error_sink(world->error_handle, &e);
-	} else {
-		fprintf(stderr, "error: ");
-		vfprintf(stderr, fmt, args);
-	}
-	va_end(args);
+  va_list args;
+  va_start(args, fmt);
+  const SerdError e = {st, NULL, 0, 0, fmt, &args};
+  if (world->error_sink) {
+    world->error_sink(world->error_handle, &e);
+  } else {
+    fprintf(stderr, "error: ");
+    vfprintf(stderr, fmt, args);
+  }
+  va_end(args);
 }
 
 SordWorld*
 sord_world_new(void)
 {
-	SordWorld* world = (SordWorld*)malloc(sizeof(SordWorld));
-	world->error_sink   = NULL;
-	world->error_handle = NULL;
+  SordWorld* world    = (SordWorld*)malloc(sizeof(SordWorld));
+  world->error_sink   = NULL;
+  world->error_handle = NULL;
 
-	world->nodes = zix_hash_new(
-		sord_node_hash, sord_node_hash_equal, sizeof(SordNode));
+  world->nodes =
+    zix_hash_new(sord_node_hash, sord_node_hash_equal, sizeof(SordNode));
 
-	return world;
+  return world;
 }
 
 static void
 free_node_entry(void* value, void* user_data)
 {
-	SordNode* node = (SordNode*)value;
-	if (node->node.type == SERD_LITERAL) {
-		sord_node_free((SordWorld*)user_data, node->meta.lit.datatype);
-	}
-	free((uint8_t*)node->node.buf);
+  SordNode* node = (SordNode*)value;
+  if (node->node.type == SERD_LITERAL) {
+    sord_node_free((SordWorld*)user_data, node->meta.lit.datatype);
+  }
+  free((uint8_t*)node->node.buf);
 }
 
 void
 sord_world_free(SordWorld* world)
 {
-	zix_hash_foreach(world->nodes, free_node_entry, world);
-	zix_hash_free(world->nodes);
-	free(world);
+  zix_hash_foreach(world->nodes, free_node_entry, world);
+  zix_hash_free(world->nodes);
+  free(world);
 }
 
 void
@@ -234,96 +246,94 @@ sord_world_set_error_sink(SordWorld*    world,
                           SerdErrorSink error_sink,
                           void*         handle)
 {
-	world->error_sink   = error_sink;
-	world->error_handle = handle;
+  world->error_sink   = error_sink;
+  world->error_handle = handle;
 }
 
 static inline int
 sord_node_compare_literal(const SordNode* a, const SordNode* b)
 {
-	const int cmp = strcmp((const char*)sord_node_get_string(a),
-	                       (const char*)sord_node_get_string(b));
-	if (cmp != 0) {
-		return cmp;
-	}
-
-	const bool a_has_lang     = a->meta.lit.lang[0];
-	const bool b_has_lang     = b->meta.lit.lang[0];
-	const bool a_has_datatype = a->meta.lit.datatype;
-	const bool b_has_datatype = b->meta.lit.datatype;
-	const bool a_has_meta     = a_has_lang || a_has_datatype;
-	const bool b_has_meta     = b_has_lang || b_has_datatype;
-
-	assert(!(a_has_lang && a_has_datatype));
-	assert(!(b_has_lang && b_has_datatype));
-
-	if (!a_has_meta && !b_has_meta) {
-		return 0;
-	} else if (!a_has_meta || (a_has_lang && b_has_datatype)) {
-		return -1;
-	} else if (!b_has_meta || (a_has_datatype && b_has_lang)) {
-		return 1;
-	} else if (a_has_lang) {
-		assert(b_has_lang);
-		return strcmp(a->meta.lit.lang, b->meta.lit.lang);
-	}
-
-	assert(a_has_datatype);
-	assert(b_has_datatype);
-	return strcmp((const char*)a->meta.lit.datatype->node.buf,
-	              (const char*)b->meta.lit.datatype->node.buf);
+  const int cmp = strcmp((const char*)sord_node_get_string(a),
+                         (const char*)sord_node_get_string(b));
+  if (cmp != 0) {
+    return cmp;
+  }
+
+  const bool a_has_lang     = a->meta.lit.lang[0];
+  const bool b_has_lang     = b->meta.lit.lang[0];
+  const bool a_has_datatype = a->meta.lit.datatype;
+  const bool b_has_datatype = b->meta.lit.datatype;
+  const bool a_has_meta     = a_has_lang || a_has_datatype;
+  const bool b_has_meta     = b_has_lang || b_has_datatype;
+
+  assert(!(a_has_lang && a_has_datatype));
+  assert(!(b_has_lang && b_has_datatype));
+
+  if (!a_has_meta && !b_has_meta) {
+    return 0;
+  } else if (!a_has_meta || (a_has_lang && b_has_datatype)) {
+    return -1;
+  } else if (!b_has_meta || (a_has_datatype && b_has_lang)) {
+    return 1;
+  } else if (a_has_lang) {
+    assert(b_has_lang);
+    return strcmp(a->meta.lit.lang, b->meta.lit.lang);
+  }
+
+  assert(a_has_datatype);
+  assert(b_has_datatype);
+  return strcmp((const char*)a->meta.lit.datatype->node.buf,
+                (const char*)b->meta.lit.datatype->node.buf);
 }
 
 /** Compare nodes, considering NULL a wildcard match. */
 static inline int
 sord_node_compare(const SordNode* a, const SordNode* b)
 {
-	if (a == b || !a || !b) {
-		return 0;  // Exact or wildcard match
-	} else if (a->node.type != b->node.type) {
-		return (a->node.type < b->node.type) ? -1 : 1;
-	}
-
-	int cmp = 0;
-	switch (a->node.type) {
-	case SERD_URI:
-	case SERD_BLANK:
-		return strcmp((const char*)a->node.buf, (const char*)b->node.buf);
-	case SERD_LITERAL:
-		cmp = sord_node_compare_literal(a, b);
-		break;
-	default:
-		break;
-	}
-	return cmp;
+  if (a == b || !a || !b) {
+    return 0; // Exact or wildcard match
+  } else if (a->node.type != b->node.type) {
+    return (a->node.type < b->node.type) ? -1 : 1;
+  }
+
+  int cmp = 0;
+  switch (a->node.type) {
+  case SERD_URI:
+  case SERD_BLANK:
+    return strcmp((const char*)a->node.buf, (const char*)b->node.buf);
+  case SERD_LITERAL:
+    cmp = sord_node_compare_literal(a, b);
+    break;
+  default:
+    break;
+  }
+  return cmp;
 }
 
 bool
 sord_node_equals(const SordNode* a, const SordNode* b)
 {
-	return a == b;  // Nodes are interned
+  return a == b; // Nodes are interned
 }
 
 /** Return true iff IDs are equivalent, or one is a wildcard */
 static inline bool
 sord_id_match(const SordNode* a, const SordNode* b)
 {
-	return !a || !b || (a == b);
+  return !a || !b || (a == b);
 }
 
 static inline bool
 sord_quad_match_inline(const SordQuad x, const SordQuad y)
 {
-	return sord_id_match(x[0], y[0])
-		&& sord_id_match(x[1], y[1])
-		&& sord_id_match(x[2], y[2])
-		&& sord_id_match(x[3], y[3]);
+  return sord_id_match(x[0], y[0]) && sord_id_match(x[1], y[1]) &&
+         sord_id_match(x[2], y[2]) && sord_id_match(x[3], y[3]);
 }
 
 bool
 sord_quad_match(const SordQuad x, const SordQuad y)
 {
-	return sord_quad_match_inline(x, y);
+  return sord_quad_match_inline(x, y);
 }
 
 /**
@@ -334,44 +344,44 @@ sord_quad_match(const SordQuad x, const SordQuad y)
 static int
 sord_quad_compare(const void* x_ptr, const void* y_ptr, const void* user_data)
 {
-	const int* const           ordering = (const int*)user_data;
-	const SordNode*const*const x        = (const SordNode*const*)x_ptr;
-	const SordNode*const*const y        = (const SordNode*const*)y_ptr;
+  const int* const             ordering = (const int*)user_data;
+  const SordNode* const* const x        = (const SordNode* const*)x_ptr;
+  const SordNode* const* const y        = (const SordNode* const*)y_ptr;
 
-	for (int i = 0; i < TUP_LEN; ++i) {
-		const int idx = ordering[i];
-		const int cmp = sord_node_compare(x[idx], y[idx]);
-		if (cmp) {
-			return cmp;
-		}
-	}
+  for (int i = 0; i < TUP_LEN; ++i) {
+    const int idx = ordering[i];
+    const int cmp = sord_node_compare(x[idx], y[idx]);
+    if (cmp) {
+      return cmp;
+    }
+  }
 
-	return 0;
+  return 0;
 }
 
 static inline bool
 sord_iter_forward(SordIter* iter)
 {
-	if (!iter->skip_graphs) {
-		zix_btree_iter_increment(iter->cur);
-		return zix_btree_iter_is_end(iter->cur);
-	}
+  if (!iter->skip_graphs) {
+    zix_btree_iter_increment(iter->cur);
+    return zix_btree_iter_is_end(iter->cur);
+  }
 
-	SordNode**     key     = (SordNode**)zix_btree_get(iter->cur);
-	const SordQuad initial = { key[0], key[1], key[2], key[3] };
-	zix_btree_iter_increment(iter->cur);
-	while (!zix_btree_iter_is_end(iter->cur)) {
-		key = (SordNode**)zix_btree_get(iter->cur);
-		for (int i = 0; i < 3; ++i) {
-			if (key[i] != initial[i]) {
-				return false;
-			}
-		}
+  SordNode**     key     = (SordNode**)zix_btree_get(iter->cur);
+  const SordQuad initial = {key[0], key[1], key[2], key[3]};
+  zix_btree_iter_increment(iter->cur);
+  while (!zix_btree_iter_is_end(iter->cur)) {
+    key = (SordNode**)zix_btree_get(iter->cur);
+    for (int i = 0; i < 3; ++i) {
+      if (key[i] != initial[i]) {
+        return false;
+      }
+    }
 
-		zix_btree_iter_increment(iter->cur);
-	}
+    zix_btree_iter_increment(iter->cur);
+  }
 
-	return true;
+  return true;
 }
 
 /**
@@ -381,15 +391,14 @@ sord_iter_forward(SordIter* iter)
 static inline bool
 sord_iter_seek_match(SordIter* iter)
 {
-	for (iter->end = true;
-	     !zix_btree_iter_is_end(iter->cur);
-	     sord_iter_forward(iter)) {
-		const SordNode** const key = (const SordNode**)zix_btree_get(iter->cur);
-		if (sord_quad_match_inline(key, iter->pat)) {
-			return (iter->end = false);
-		}
-	}
-	return true;
+  for (iter->end = true; !zix_btree_iter_is_end(iter->cur);
+       sord_iter_forward(iter)) {
+    const SordNode** const key = (const SordNode**)zix_btree_get(iter->cur);
+    if (sord_quad_match_inline(key, iter->pat)) {
+      return (iter->end = false);
+    }
+  }
+  return true;
 }
 
 /**
@@ -400,178 +409,183 @@ sord_iter_seek_match(SordIter* iter)
 static inline bool
 sord_iter_seek_match_range(SordIter* iter)
 {
-	assert(!iter->end);
+  assert(!iter->end);
 
-	do {
-		const SordNode** key = (const SordNode**)zix_btree_get(iter->cur);
+  do {
+    const SordNode** key = (const SordNode**)zix_btree_get(iter->cur);
 
-		if (sord_quad_match_inline(key, iter->pat)) {
-			return false;  // Found match
-		}
+    if (sord_quad_match_inline(key, iter->pat)) {
+      return false; // Found match
+    }
 
-		for (int i = 0; i < iter->n_prefix; ++i) {
-			const int idx = orderings[iter->order][i];
-			if (!sord_id_match(key[idx], iter->pat[idx])) {
-				iter->end = true;  // Reached end of valid range
-				return true;
-			}
-		}
-	} while (!sord_iter_forward(iter));
+    for (int i = 0; i < iter->n_prefix; ++i) {
+      const int idx = orderings[iter->order][i];
+      if (!sord_id_match(key[idx], iter->pat[idx])) {
+        iter->end = true; // Reached end of valid range
+        return true;
+      }
+    }
+  } while (!sord_iter_forward(iter));
 
-	return (iter->end = true);  // Reached end
+  return (iter->end = true); // Reached end
 }
 
 static SordIter*
-sord_iter_new(const SordModel* sord, ZixBTreeIter* cur, const SordQuad pat,
-              SordOrder order, SearchMode mode, int n_prefix)
-{
-	SordIter* iter = (SordIter*)malloc(sizeof(SordIter));
-	iter->sord        = sord;
-	iter->cur         = cur;
-	iter->order       = order;
-	iter->mode        = mode;
-	iter->n_prefix    = n_prefix;
-	iter->end         = false;
-	iter->skip_graphs = order < GSPO;
-	for (int i = 0; i < TUP_LEN; ++i) {
-		iter->pat[i] = pat[i];
-	}
-
-	switch (iter->mode) {
-	case ALL:
-	case SINGLE:
-	case RANGE:
-		assert(
-			sord_quad_match_inline((const SordNode**)zix_btree_get(iter->cur),
-			                       iter->pat));
-		break;
-	case FILTER_RANGE:
-		sord_iter_seek_match_range(iter);
-		break;
-	case FILTER_ALL:
-		sord_iter_seek_match(iter);
-		break;
-	}
+sord_iter_new(const SordModel* sord,
+              ZixBTreeIter*    cur,
+              const SordQuad   pat,
+              SordOrder        order,
+              SearchMode       mode,
+              int              n_prefix)
+{
+  SordIter* iter    = (SordIter*)malloc(sizeof(SordIter));
+  iter->sord        = sord;
+  iter->cur         = cur;
+  iter->order       = order;
+  iter->mode        = mode;
+  iter->n_prefix    = n_prefix;
+  iter->end         = false;
+  iter->skip_graphs = order < GSPO;
+  for (int i = 0; i < TUP_LEN; ++i) {
+    iter->pat[i] = pat[i];
+  }
+
+  switch (iter->mode) {
+  case ALL:
+  case SINGLE:
+  case RANGE:
+    assert(sord_quad_match_inline((const SordNode**)zix_btree_get(iter->cur),
+                                  iter->pat));
+    break;
+  case FILTER_RANGE:
+    sord_iter_seek_match_range(iter);
+    break;
+  case FILTER_ALL:
+    sord_iter_seek_match(iter);
+    break;
+  }
 
 #ifdef SORD_DEBUG_ITER
-	SordQuad value;
-	sord_iter_get(iter, value);
-	SORD_ITER_LOG("New %p pat=" TUP_FMT " cur=" TUP_FMT " end=%d skip=%d\n",
-	              (void*)iter, TUP_FMT_ARGS(pat), TUP_FMT_ARGS(value),
-	              iter->end, iter->skip_graphs);
+  SordQuad value;
+  sord_iter_get(iter, value);
+  SORD_ITER_LOG("New %p pat=" TUP_FMT " cur=" TUP_FMT " end=%d skip=%d\n",
+                (void*)iter,
+                TUP_FMT_ARGS(pat),
+                TUP_FMT_ARGS(value),
+                iter->end,
+                iter->skip_graphs);
 #endif
 
-	++((SordModel*)sord)->n_iters;
-	return iter;
+  ++((SordModel*)sord)->n_iters;
+  return iter;
 }
 
 const SordModel*
 sord_iter_get_model(SordIter* iter)
 {
-	return iter->sord;
+  return iter->sord;
 }
 
 void
 sord_iter_get(const SordIter* iter, SordQuad tup)
 {
-	SordNode** key = (SordNode**)zix_btree_get(iter->cur);
-	for (int i = 0; i < TUP_LEN; ++i) {
-		tup[i] = key[i];
-	}
+  SordNode** key = (SordNode**)zix_btree_get(iter->cur);
+  for (int i = 0; i < TUP_LEN; ++i) {
+    tup[i] = key[i];
+  }
 }
 
 const SordNode*
 sord_iter_get_node(const SordIter* iter, SordQuadIndex index)
 {
-	return (!sord_iter_end(iter)
-	        ? ((SordNode**)zix_btree_get(iter->cur))[index]
-	        : NULL);
+  return (!sord_iter_end(iter) ? ((SordNode**)zix_btree_get(iter->cur))[index]
+                               : NULL);
 }
 
 static bool
 sord_iter_scan_next(SordIter* iter)
 {
-	if (iter->end) {
-		return true;
-	}
-
-	const SordNode** key;
-	if (!iter->end) {
-		switch (iter->mode) {
-		case ALL:
-			// At the end if the cursor is (assigned above)
-			break;
-		case SINGLE:
-			iter->end = true;
-			SORD_ITER_LOG("%p reached single end\n", (void*)iter);
-			break;
-		case RANGE:
-			SORD_ITER_LOG("%p range next\n", (void*)iter);
-			// At the end if the MSNs no longer match
-			key = (const SordNode**)zix_btree_get(iter->cur);
-			assert(key);
-			for (int i = 0; i < iter->n_prefix; ++i) {
-				const int idx = orderings[iter->order][i];
-				if (!sord_id_match(key[idx], iter->pat[idx])) {
-					iter->end = true;
-					SORD_ITER_LOG("%p reached non-match end\n", (void*)iter);
-					break;
-				}
-			}
-			break;
-		case FILTER_RANGE:
-			// Seek forward to next match, stopping if prefix changes
-			sord_iter_seek_match_range(iter);
-			break;
-		case FILTER_ALL:
-			// Seek forward to next match
-			sord_iter_seek_match(iter);
-			break;
-		}
-	} else {
-		SORD_ITER_LOG("%p reached index end\n", (void*)iter);
-	}
-
-	if (iter->end) {
-		SORD_ITER_LOG("%p Reached end\n", (void*)iter);
-		return true;
-	} else {
+  if (iter->end) {
+    return true;
+  }
+
+  const SordNode** key;
+  if (!iter->end) {
+    switch (iter->mode) {
+    case ALL:
+      // At the end if the cursor is (assigned above)
+      break;
+    case SINGLE:
+      iter->end = true;
+      SORD_ITER_LOG("%p reached single end\n", (void*)iter);
+      break;
+    case RANGE:
+      SORD_ITER_LOG("%p range next\n", (void*)iter);
+      // At the end if the MSNs no longer match
+      key = (const SordNode**)zix_btree_get(iter->cur);
+      assert(key);
+      for (int i = 0; i < iter->n_prefix; ++i) {
+        const int idx = orderings[iter->order][i];
+        if (!sord_id_match(key[idx], iter->pat[idx])) {
+          iter->end = true;
+          SORD_ITER_LOG("%p reached non-match end\n", (void*)iter);
+          break;
+        }
+      }
+      break;
+    case FILTER_RANGE:
+      // Seek forward to next match, stopping if prefix changes
+      sord_iter_seek_match_range(iter);
+      break;
+    case FILTER_ALL:
+      // Seek forward to next match
+      sord_iter_seek_match(iter);
+      break;
+    }
+  } else {
+    SORD_ITER_LOG("%p reached index end\n", (void*)iter);
+  }
+
+  if (iter->end) {
+    SORD_ITER_LOG("%p Reached end\n", (void*)iter);
+    return true;
+  } else {
 #ifdef SORD_DEBUG_ITER
-		SordQuad tup;
-		sord_iter_get(iter, tup);
-		SORD_ITER_LOG("%p Increment to " TUP_FMT "\n",
-		              (void*)iter, TUP_FMT_ARGS(tup));
+    SordQuad tup;
+    sord_iter_get(iter, tup);
+    SORD_ITER_LOG(
+      "%p Increment to " TUP_FMT "\n", (void*)iter, TUP_FMT_ARGS(tup));
 #endif
-		return false;
-	}
+    return false;
+  }
 }
 
 bool
 sord_iter_next(SordIter* iter)
 {
-	if (iter->end) {
-		return true;
-	}
+  if (iter->end) {
+    return true;
+  }
 
-	iter->end = sord_iter_forward(iter);
-	return sord_iter_scan_next(iter);
+  iter->end = sord_iter_forward(iter);
+  return sord_iter_scan_next(iter);
 }
 
 bool
 sord_iter_end(const SordIter* iter)
 {
-	return !iter || iter->end;
+  return !iter || iter->end;
 }
 
 void
 sord_iter_free(SordIter* iter)
 {
-	SORD_ITER_LOG("%p Free\n", (void*)iter);
-	if (iter) {
-		--((SordModel*)iter->sord)->n_iters;
-		zix_btree_iter_free(iter->cur);
-		free(iter);
-	}
+  SORD_ITER_LOG("%p Free\n", (void*)iter);
+  if (iter) {
+    --((SordModel*)iter->sord)->n_iters;
+    zix_btree_iter_free(iter->cur);
+    free(iter);
+  }
 }
 
 /**
@@ -582,12 +596,12 @@ sord_iter_free(SordIter* iter)
 static inline bool
 sord_has_index(SordModel* model, SordOrder* order, int* n_prefix, bool graphs)
 {
-	if (graphs) {
-		*order     = (SordOrder)(*order + GSPO);
-		*n_prefix += 1;
-	}
+  if (graphs) {
+    *order = (SordOrder)(*order + GSPO);
+    *n_prefix += 1;
+  }
 
-	return model->indices[*order];
+  return model->indices[*order];
 }
 
 /**
@@ -603,284 +617,286 @@ sord_best_index(SordModel*     sord,
                 SearchMode*    mode,
                 int*           n_prefix)
 {
-	const bool graph_search = (pat[TUP_G] != 0);
+  const bool graph_search = (pat[TUP_G] != 0);
 
-	const unsigned sig
-		= (pat[0] ? 1 : 0) * 0x100
-		+ (pat[1] ? 1 : 0) * 0x010
-		+ (pat[2] ? 1 : 0) * 0x001;
+  const unsigned sig = (pat[0] ? 1 : 0) * 0x100 + (pat[1] ? 1 : 0) * 0x010 +
+                       (pat[2] ? 1 : 0) * 0x001;
 
-	SordOrder good[2] = { (SordOrder)-1, (SordOrder)-1 };
+  SordOrder good[2] = {(SordOrder)-1, (SordOrder)-1};
 
 #define PAT_CASE(sig, m, g0, g1, np) \
-	case sig: \
-		*mode     = m; \
-		good[0]   = g0; \
-		good[1]   = g1; \
-		*n_prefix = np; \
-		break
-
-	// Good orderings that don't require filtering
-	*mode     = RANGE;
-	*n_prefix = 0;
-	switch (sig) {
-	case 0x000:
-		assert(graph_search);
-		*mode     = RANGE;
-		*n_prefix = 1;
-		return DEFAULT_GRAPH_ORDER;
-	case 0x111:
-		*mode = SINGLE;
-		return graph_search ? DEFAULT_GRAPH_ORDER : DEFAULT_ORDER;
-
-		PAT_CASE(0x001, RANGE, OPS, OSP, 1);
-		PAT_CASE(0x010, RANGE, POS, PSO, 1);
-		PAT_CASE(0x011, RANGE, OPS, POS, 2);
-		PAT_CASE(0x100, RANGE, SPO, SOP, 1);
-		PAT_CASE(0x101, RANGE, SOP, OSP, 2);
-		PAT_CASE(0x110, RANGE, SPO, PSO, 2);
-	}
-
-	if (*mode == RANGE) {
-		if (sord_has_index(sord, &good[0], n_prefix, graph_search)) {
-			return good[0];
-		} else if (sord_has_index(sord, &good[1], n_prefix, graph_search)) {
-			return good[1];
-		}
-	}
-
-	// Not so good orderings that require filtering, but can
-	// still be constrained to a range
-	switch (sig) {
-		PAT_CASE(0x011, FILTER_RANGE, OSP, PSO, 1);
-		PAT_CASE(0x101, FILTER_RANGE, SPO, OPS, 1);
-		// SPO is always present, so 0x110 is never reached here
-	default: break;
-	}
-
-	if (*mode == FILTER_RANGE) {
-		if (sord_has_index(sord, &good[0], n_prefix, graph_search)) {
-			return good[0];
-		} else if (sord_has_index(sord, &good[1], n_prefix, graph_search)) {
-			return good[1];
-		}
-	}
-
-	if (graph_search) {
-		*mode = FILTER_RANGE;
-		*n_prefix = 1;
-		return DEFAULT_GRAPH_ORDER;
-	} else {
-		*mode = FILTER_ALL;
-		return DEFAULT_ORDER;
-	}
+  case sig:                          \
+    *mode     = m;                   \
+    good[0]   = g0;                  \
+    good[1]   = g1;                  \
+    *n_prefix = np;                  \
+    break
+
+  // Good orderings that don't require filtering
+  *mode     = RANGE;
+  *n_prefix = 0;
+  switch (sig) {
+  case 0x000:
+    assert(graph_search);
+    *mode     = RANGE;
+    *n_prefix = 1;
+    return DEFAULT_GRAPH_ORDER;
+  case 0x111:
+    *mode = SINGLE;
+    return graph_search ? DEFAULT_GRAPH_ORDER : DEFAULT_ORDER;
+
+    PAT_CASE(0x001, RANGE, OPS, OSP, 1);
+    PAT_CASE(0x010, RANGE, POS, PSO, 1);
+    PAT_CASE(0x011, RANGE, OPS, POS, 2);
+    PAT_CASE(0x100, RANGE, SPO, SOP, 1);
+    PAT_CASE(0x101, RANGE, SOP, OSP, 2);
+    PAT_CASE(0x110, RANGE, SPO, PSO, 2);
+  }
+
+  if (*mode == RANGE) {
+    if (sord_has_index(sord, &good[0], n_prefix, graph_search)) {
+      return good[0];
+    } else if (sord_has_index(sord, &good[1], n_prefix, graph_search)) {
+      return good[1];
+    }
+  }
+
+  // Not so good orderings that require filtering, but can
+  // still be constrained to a range
+  switch (sig) {
+    PAT_CASE(0x011, FILTER_RANGE, OSP, PSO, 1);
+    PAT_CASE(0x101, FILTER_RANGE, SPO, OPS, 1);
+    // SPO is always present, so 0x110 is never reached here
+  default:
+    break;
+  }
+
+  if (*mode == FILTER_RANGE) {
+    if (sord_has_index(sord, &good[0], n_prefix, graph_search)) {
+      return good[0];
+    } else if (sord_has_index(sord, &good[1], n_prefix, graph_search)) {
+      return good[1];
+    }
+  }
+
+  if (graph_search) {
+    *mode     = FILTER_RANGE;
+    *n_prefix = 1;
+    return DEFAULT_GRAPH_ORDER;
+  } else {
+    *mode = FILTER_ALL;
+    return DEFAULT_ORDER;
+  }
 }
 
 SordModel*
 sord_new(SordWorld* world, unsigned indices, bool graphs)
 {
-	SordModel* model = (SordModel*)malloc(sizeof(struct SordModelImpl));
-	model->world   = world;
-	model->n_quads = 0;
-	model->n_iters = 0;
-
-	for (unsigned i = 0; i < (NUM_ORDERS / 2); ++i) {
-		const int* const ordering   = orderings[i];
-		const int* const g_ordering = orderings[i + (NUM_ORDERS / 2)];
-
-		if (indices & (1 << i)) {
-			model->indices[i] = zix_btree_new(
-				sord_quad_compare, (void*)ordering, NULL);
-			if (graphs) {
-				model->indices[i + (NUM_ORDERS / 2)] = zix_btree_new(
-					sord_quad_compare, (void*)g_ordering, NULL);
-			} else {
-				model->indices[i + (NUM_ORDERS / 2)] = NULL;
-			}
-		} else {
-			model->indices[i] = NULL;
-			model->indices[i + (NUM_ORDERS / 2)] = NULL;
-		}
-	}
-
-	if (!model->indices[DEFAULT_ORDER]) {
-		model->indices[DEFAULT_ORDER] = zix_btree_new(
-			sord_quad_compare, (void*)orderings[DEFAULT_ORDER], NULL);
-	}
-	if (graphs && !model->indices[DEFAULT_GRAPH_ORDER]) {
-		model->indices[DEFAULT_GRAPH_ORDER] = zix_btree_new(
-			sord_quad_compare, (void*)orderings[DEFAULT_GRAPH_ORDER], NULL);
-	}
-
-	return model;
+  SordModel* model = (SordModel*)malloc(sizeof(struct SordModelImpl));
+  model->world     = world;
+  model->n_quads   = 0;
+  model->n_iters   = 0;
+
+  for (unsigned i = 0; i < (NUM_ORDERS / 2); ++i) {
+    const int* const ordering   = orderings[i];
+    const int* const g_ordering = orderings[i + (NUM_ORDERS / 2)];
+
+    if (indices & (1 << i)) {
+      model->indices[i] =
+        zix_btree_new(sord_quad_compare, (void*)ordering, NULL);
+      if (graphs) {
+        model->indices[i + (NUM_ORDERS / 2)] =
+          zix_btree_new(sord_quad_compare, (void*)g_ordering, NULL);
+      } else {
+        model->indices[i + (NUM_ORDERS / 2)] = NULL;
+      }
+    } else {
+      model->indices[i]                    = NULL;
+      model->indices[i + (NUM_ORDERS / 2)] = NULL;
+    }
+  }
+
+  if (!model->indices[DEFAULT_ORDER]) {
+    model->indices[DEFAULT_ORDER] =
+      zix_btree_new(sord_quad_compare, (void*)orderings[DEFAULT_ORDER], NULL);
+  }
+  if (graphs && !model->indices[DEFAULT_GRAPH_ORDER]) {
+    model->indices[DEFAULT_GRAPH_ORDER] = zix_btree_new(
+      sord_quad_compare, (void*)orderings[DEFAULT_GRAPH_ORDER], NULL);
+  }
+
+  return model;
 }
 
 static void
 sord_node_free_internal(SordWorld* world, SordNode* node)
 {
-	assert(node->refs == 0);
+  assert(node->refs == 0);
 
-	// If you hit this, the world has probably been destroyed too early
-	assert(world);
+  // If you hit this, the world has probably been destroyed too early
+  assert(world);
 
-	// Cache pointer to buffer to free after node removal and destruction
-	const uint8_t* const buf = node->node.buf;
+  // Cache pointer to buffer to free after node removal and destruction
+  const uint8_t* const buf = node->node.buf;
 
-	// Remove node from hash (which frees the node)
-	if (zix_hash_remove(world->nodes, node)) {
-		error(world, SERD_ERR_INTERNAL, "failed to remove node from hash\n");
-	}
+  // Remove node from hash (which frees the node)
+  if (zix_hash_remove(world->nodes, node)) {
+    error(world, SERD_ERR_INTERNAL, "failed to remove node from hash\n");
+  }
 
-	// Free buffer
-	free((uint8_t*)buf);
+  // Free buffer
+  free((uint8_t*)buf);
 }
 
 static void
 sord_add_quad_ref(SordModel* model, const SordNode* node, SordQuadIndex i)
 {
-	if (node) {
-		assert(node->refs > 0);
-		++((SordNode*)node)->refs;
-		if (node->node.type != SERD_LITERAL && i == SORD_OBJECT) {
-			++((SordNode*)node)->meta.res.refs_as_obj;
-		}
-	}
+  if (node) {
+    assert(node->refs > 0);
+    ++((SordNode*)node)->refs;
+    if (node->node.type != SERD_LITERAL && i == SORD_OBJECT) {
+      ++((SordNode*)node)->meta.res.refs_as_obj;
+    }
+  }
 }
 
 static void
 sord_drop_quad_ref(SordModel* model, const SordNode* node, SordQuadIndex i)
 {
-	if (!node) {
-		return;
-	}
+  if (!node) {
+    return;
+  }
 
-	assert(node->refs > 0);
-	if (node->node.type != SERD_LITERAL && i == SORD_OBJECT) {
-		assert(node->meta.res.refs_as_obj > 0);
-		--((SordNode*)node)->meta.res.refs_as_obj;
-	}
-	if (--((SordNode*)node)->refs == 0) {
-		sord_node_free_internal(sord_get_world(model), (SordNode*)node);
-	}
+  assert(node->refs > 0);
+  if (node->node.type != SERD_LITERAL && i == SORD_OBJECT) {
+    assert(node->meta.res.refs_as_obj > 0);
+    --((SordNode*)node)->meta.res.refs_as_obj;
+  }
+  if (--((SordNode*)node)->refs == 0) {
+    sord_node_free_internal(sord_get_world(model), (SordNode*)node);
+  }
 }
 
 void
 sord_free(SordModel* model)
 {
-	if (!model) {
-		return;
-	}
-
-	// Free nodes
-	SordQuad tup;
-	SordIter* i = sord_begin(model);
-	for (; !sord_iter_end(i); sord_iter_next(i)) {
-		sord_iter_get(i, tup);
-		for (int t = 0; t < TUP_LEN; ++t) {
-			sord_drop_quad_ref(model, tup[t], (SordQuadIndex)t);
-		}
-	}
-	sord_iter_free(i);
-
-	// Free quads
-	ZixBTreeIter* t = zix_btree_begin(model->indices[DEFAULT_ORDER]);
-	for (; !zix_btree_iter_is_end(t); zix_btree_iter_increment(t)) {
-		free(zix_btree_get(t));
-	}
-	zix_btree_iter_free(t);
-
-	// Free indices
-	for (unsigned o = 0; o < NUM_ORDERS; ++o) {
-		if (model->indices[o]) {
-			zix_btree_free(model->indices[o]);
-		}
-	}
-
-	free(model);
+  if (!model) {
+    return;
+  }
+
+  // Free nodes
+  SordQuad  tup;
+  SordIter* i = sord_begin(model);
+  for (; !sord_iter_end(i); sord_iter_next(i)) {
+    sord_iter_get(i, tup);
+    for (int t = 0; t < TUP_LEN; ++t) {
+      sord_drop_quad_ref(model, tup[t], (SordQuadIndex)t);
+    }
+  }
+  sord_iter_free(i);
+
+  // Free quads
+  ZixBTreeIter* t = zix_btree_begin(model->indices[DEFAULT_ORDER]);
+  for (; !zix_btree_iter_is_end(t); zix_btree_iter_increment(t)) {
+    free(zix_btree_get(t));
+  }
+  zix_btree_iter_free(t);
+
+  // Free indices
+  for (unsigned o = 0; o < NUM_ORDERS; ++o) {
+    if (model->indices[o]) {
+      zix_btree_free(model->indices[o]);
+    }
+  }
+
+  free(model);
 }
 
 SordWorld*
 sord_get_world(SordModel* model)
 {
-	return model->world;
+  return model->world;
 }
 
 size_t
 sord_num_quads(const SordModel* model)
 {
-	return model->n_quads;
+  return model->n_quads;
 }
 
 size_t
 sord_num_nodes(const SordWorld* world)
 {
-	return zix_hash_size(world->nodes);
+  return zix_hash_size(world->nodes);
 }
 
 SordIter*
 sord_begin(const SordModel* model)
 {
-	if (sord_num_quads(model) == 0) {
-		return NULL;
-	} else {
-		ZixBTreeIter* cur = zix_btree_begin(model->indices[DEFAULT_ORDER]);
-		SordQuad      pat = { 0, 0, 0, 0 };
-		return sord_iter_new(model, cur, pat, DEFAULT_ORDER, ALL, 0);
-	}
+  if (sord_num_quads(model) == 0) {
+    return NULL;
+  } else {
+    ZixBTreeIter* cur = zix_btree_begin(model->indices[DEFAULT_ORDER]);
+    SordQuad      pat = {0, 0, 0, 0};
+    return sord_iter_new(model, cur, pat, DEFAULT_ORDER, ALL, 0);
+  }
 }
 
 SordIter*
 sord_find(SordModel* model, const SordQuad pat)
 {
-	if (!pat[0] && !pat[1] && !pat[2] && !pat[3]) {
-		return sord_begin(model);
-	}
-
-	SearchMode      mode;
-	int             n_prefix;
-	const SordOrder index_order = sord_best_index(model, pat, &mode, &n_prefix);
-
-	SORD_FIND_LOG("Find " TUP_FMT "  index=%s  mode=%u  n_prefix=%d\n",
-	              TUP_FMT_ARGS(pat), order_names[index_order], mode, n_prefix);
-
-	if (pat[0] && pat[1] && pat[2] && pat[3]) {
-		mode = SINGLE;  // No duplicate quads (Sord is a set)
-	}
-
-	ZixBTree* const db  = model->indices[index_order];
-	ZixBTreeIter*   cur = NULL;
-
-	if (mode == FILTER_ALL) {
-		// No prefix shared with an index at all, linear search (worst case)
-		cur = zix_btree_begin(db);
-	} else if (mode == FILTER_RANGE) {
-		/* Some prefix, but filtering still required.  Build a search pattern
-		   with only the prefix to find the lower bound in log time. */
-		SordQuad         prefix_pat = { NULL, NULL, NULL, NULL };
-		const int* const ordering   = orderings[index_order];
-		for (int i = 0; i < n_prefix; ++i) {
-			prefix_pat[ordering[i]] = pat[ordering[i]];
-		}
-		zix_btree_lower_bound(db, prefix_pat, &cur);
-	} else {
-		// Ideal case, pattern matches an index with no filtering required
-		zix_btree_lower_bound(db, pat, &cur);
-	}
-
-	if (zix_btree_iter_is_end(cur)) {
-		SORD_FIND_LOG("No match found\n");
-		zix_btree_iter_free(cur);
-		return NULL;
-	}
-	const SordNode** const key = (const SordNode**)zix_btree_get(cur);
-	if (!key || ( (mode == RANGE || mode == SINGLE)
-	              && !sord_quad_match_inline(pat, key) )) {
-		SORD_FIND_LOG("No match found\n");
-		zix_btree_iter_free(cur);
-		return NULL;
-	}
-
-	return sord_iter_new(model, cur, pat, index_order, mode, n_prefix);
+  if (!pat[0] && !pat[1] && !pat[2] && !pat[3]) {
+    return sord_begin(model);
+  }
+
+  SearchMode      mode;
+  int             n_prefix;
+  const SordOrder index_order = sord_best_index(model, pat, &mode, &n_prefix);
+
+  SORD_FIND_LOG("Find " TUP_FMT "  index=%s  mode=%u  n_prefix=%d\n",
+                TUP_FMT_ARGS(pat),
+                order_names[index_order],
+                mode,
+                n_prefix);
+
+  if (pat[0] && pat[1] && pat[2] && pat[3]) {
+    mode = SINGLE; // No duplicate quads (Sord is a set)
+  }
+
+  ZixBTree* const db  = model->indices[index_order];
+  ZixBTreeIter*   cur = NULL;
+
+  if (mode == FILTER_ALL) {
+    // No prefix shared with an index at all, linear search (worst case)
+    cur = zix_btree_begin(db);
+  } else if (mode == FILTER_RANGE) {
+    /* Some prefix, but filtering still required.  Build a search pattern
+       with only the prefix to find the lower bound in log time. */
+    SordQuad         prefix_pat = {NULL, NULL, NULL, NULL};
+    const int* const ordering   = orderings[index_order];
+    for (int i = 0; i < n_prefix; ++i) {
+      prefix_pat[ordering[i]] = pat[ordering[i]];
+    }
+    zix_btree_lower_bound(db, prefix_pat, &cur);
+  } else {
+    // Ideal case, pattern matches an index with no filtering required
+    zix_btree_lower_bound(db, pat, &cur);
+  }
+
+  if (zix_btree_iter_is_end(cur)) {
+    SORD_FIND_LOG("No match found\n");
+    zix_btree_iter_free(cur);
+    return NULL;
+  }
+  const SordNode** const key = (const SordNode**)zix_btree_get(cur);
+  if (!key || ((mode == RANGE || mode == SINGLE) &&
+               !sord_quad_match_inline(pat, key))) {
+    SORD_FIND_LOG("No match found\n");
+    zix_btree_iter_free(cur);
+    return NULL;
+  }
+
+  return sord_iter_new(model, cur, pat, index_order, mode, n_prefix);
 }
 
 SordIter*
@@ -890,8 +906,8 @@ sord_search(SordModel*      model,
             const SordNode* o,
             const SordNode* g)
 {
-	SordQuad pat = { s, p, o, g };
-	return sord_find(model, pat);
+  SordQuad pat = {s, p, o, g};
+  return sord_find(model, pat);
 }
 
 SordNode*
@@ -901,22 +917,22 @@ sord_get(SordModel*      model,
          const SordNode* o,
          const SordNode* g)
 {
-	if ((bool)s + (bool)p + (bool)o != 2) {
-		return NULL;
-	}
+  if ((bool)s + (bool)p + (bool)o != 2) {
+    return NULL;
+  }
 
-	SordIter* i   = sord_search(model, s, p, o, g);
-	SordNode* ret = NULL;
-	if (!s) {
-		ret = sord_node_copy(sord_iter_get_node(i, SORD_SUBJECT));
-	} else if (!p) {
-		ret = sord_node_copy(sord_iter_get_node(i, SORD_PREDICATE));
-	} else if (!o) {
-		ret = sord_node_copy(sord_iter_get_node(i, SORD_OBJECT));
-	}
+  SordIter* i   = sord_search(model, s, p, o, g);
+  SordNode* ret = NULL;
+  if (!s) {
+    ret = sord_node_copy(sord_iter_get_node(i, SORD_SUBJECT));
+  } else if (!p) {
+    ret = sord_node_copy(sord_iter_get_node(i, SORD_PREDICATE));
+  } else if (!o) {
+    ret = sord_node_copy(sord_iter_get_node(i, SORD_OBJECT));
+  }
 
-	sord_iter_free(i);
-	return ret;
+  sord_iter_free(i);
+  return ret;
 }
 
 bool
@@ -926,8 +942,8 @@ sord_ask(SordModel*      model,
          const SordNode* o,
          const SordNode* g)
 {
-	SordQuad pat = { s, p, o, g };
-	return sord_contains(model, pat);
+  SordQuad pat = {s, p, o, g};
+  return sord_contains(model, pat);
 }
 
 uint64_t
@@ -937,57 +953,57 @@ sord_count(SordModel*      model,
            const SordNode* o,
            const SordNode* g)
 {
-	SordIter* i = sord_search(model, s, p, o, g);
-	uint64_t  n = 0;
-	for (; !sord_iter_end(i); sord_iter_next(i)) {
-		++n;
-	}
-	sord_iter_free(i);
-	return n;
+  SordIter* i = sord_search(model, s, p, o, g);
+  uint64_t  n = 0;
+  for (; !sord_iter_end(i); sord_iter_next(i)) {
+    ++n;
+  }
+  sord_iter_free(i);
+  return n;
 }
 
 bool
 sord_contains(SordModel* model, const SordQuad pat)
 {
-	SordIter* iter = sord_find(model, pat);
-	bool      ret  = (iter != NULL);
-	sord_iter_free(iter);
-	return ret;
+  SordIter* iter = sord_find(model, pat);
+  bool      ret  = (iter != NULL);
+  sord_iter_free(iter);
+  return ret;
 }
 
 static uint8_t*
 sord_strndup(const uint8_t* str, size_t len)
 {
-	uint8_t* dup = (uint8_t*)malloc(len + 1);
-	memcpy(dup, str, len + 1);
-	return dup;
+  uint8_t* dup = (uint8_t*)malloc(len + 1);
+  memcpy(dup, str, len + 1);
+  return dup;
 }
 
 SordNodeType
 sord_node_get_type(const SordNode* node)
 {
-	switch (node->node.type) {
-	case SERD_URI:
-		return SORD_URI;
-	case SERD_BLANK:
-		return SORD_BLANK;
-	default:
-		return SORD_LITERAL;
-	}
-	SORD_UNREACHABLE();
+  switch (node->node.type) {
+  case SERD_URI:
+    return SORD_URI;
+  case SERD_BLANK:
+    return SORD_BLANK;
+  default:
+    return SORD_LITERAL;
+  }
+  SORD_UNREACHABLE();
 }
 
 const uint8_t*
 sord_node_get_string(const SordNode* node)
 {
-	return node->node.buf;
+  return node->node.buf;
 }
 
 const uint8_t*
 sord_node_get_string_counted(const SordNode* node, size_t* bytes)
 {
-	*bytes = node->node.n_bytes;
-	return node->node.buf;
+  *bytes = node->node.n_bytes;
+  return node->node.buf;
 }
 
 const uint8_t*
@@ -995,91 +1011,91 @@ sord_node_get_string_measured(const SordNode* node,
                               size_t*         bytes,
                               size_t*         chars)
 {
-	*bytes = node->node.n_bytes;
-	*chars = node->node.n_chars;
-	return node->node.buf;
+  *bytes = node->node.n_bytes;
+  *chars = node->node.n_chars;
+  return node->node.buf;
 }
 
 const char*
 sord_node_get_language(const SordNode* node)
 {
-	if (node->node.type != SERD_LITERAL || !node->meta.lit.lang[0]) {
-		return NULL;
-	}
-	return node->meta.lit.lang;
+  if (node->node.type != SERD_LITERAL || !node->meta.lit.lang[0]) {
+    return NULL;
+  }
+  return node->meta.lit.lang;
 }
 
 SordNode*
 sord_node_get_datatype(const SordNode* node)
 {
-	return (node->node.type == SERD_LITERAL) ? node->meta.lit.datatype : NULL;
+  return (node->node.type == SERD_LITERAL) ? node->meta.lit.datatype : NULL;
 }
 
 SerdNodeFlags
 sord_node_get_flags(const SordNode* node)
 {
-	return node->node.flags;
+  return node->node.flags;
 }
 
 bool
 sord_node_is_inline_object(const SordNode* node)
 {
-	return (node->node.type == SERD_BLANK) && (node->meta.res.refs_as_obj == 1);
+  return (node->node.type == SERD_BLANK) && (node->meta.res.refs_as_obj == 1);
 }
 
 static SordNode*
 sord_insert_node(SordWorld* world, const SordNode* key, bool copy)
 {
-	SordNode* node = NULL;
-	ZixStatus st   = zix_hash_insert(world->nodes, key, (void**)&node);
-	switch (st) {
-	case ZIX_STATUS_EXISTS:
-		++node->refs;
-		break;
-	case ZIX_STATUS_SUCCESS:
-		assert(node->refs == 1);
-		if (copy) {
-			node->node.buf = sord_strndup(node->node.buf, node->node.n_bytes);
-		}
-		if (node->node.type == SERD_LITERAL) {
-			node->meta.lit.datatype = sord_node_copy(node->meta.lit.datatype);
-		}
-		return node;
-	default:
-		error(world, SERD_ERR_INTERNAL,
-		      "error inserting node `%s'\n", key->node.buf);
-	}
-
-	if (!copy) {
-		// Free the buffer we would have copied if a new node was created
-		free((uint8_t*)key->node.buf);
-	}
-
-	return node;
+  SordNode* node = NULL;
+  ZixStatus st   = zix_hash_insert(world->nodes, key, (void**)&node);
+  switch (st) {
+  case ZIX_STATUS_EXISTS:
+    ++node->refs;
+    break;
+  case ZIX_STATUS_SUCCESS:
+    assert(node->refs == 1);
+    if (copy) {
+      node->node.buf = sord_strndup(node->node.buf, node->node.n_bytes);
+    }
+    if (node->node.type == SERD_LITERAL) {
+      node->meta.lit.datatype = sord_node_copy(node->meta.lit.datatype);
+    }
+    return node;
+  default:
+    error(
+      world, SERD_ERR_INTERNAL, "error inserting node `%s'\n", key->node.buf);
+  }
+
+  if (!copy) {
+    // Free the buffer we would have copied if a new node was created
+    free((uint8_t*)key->node.buf);
+  }
+
+  return node;
 }
 
 static SordNode*
-sord_new_uri_counted(SordWorld* world, const uint8_t* str,
-                     size_t n_bytes, size_t n_chars, bool copy)
+sord_new_uri_counted(SordWorld*     world,
+                     const uint8_t* str,
+                     size_t         n_bytes,
+                     size_t         n_chars,
+                     bool           copy)
 {
-	if (!serd_uri_string_has_scheme(str)) {
-		error(world, SERD_ERR_BAD_ARG,
-		      "attempt to map invalid URI `%s'\n", str);
-		return NULL;  // Can't intern relative URIs
-	}
+  if (!serd_uri_string_has_scheme(str)) {
+    error(world, SERD_ERR_BAD_ARG, "attempt to map invalid URI `%s'\n", str);
+    return NULL; // Can't intern relative URIs
+  }
 
-	const SordNode key = {
-		{ str, n_bytes, n_chars, 0, SERD_URI }, 1, { { 0 } }
-	};
+  const SordNode key = {{str, n_bytes, n_chars, 0, SERD_URI}, 1, {{0}}};
 
-	return sord_insert_node(world, &key, copy);
+  return sord_insert_node(world, &key, copy);
 }
 
 SordNode*
 sord_new_uri(SordWorld* world, const uint8_t* uri)
 {
-	const SerdNode node = serd_node_from_string(SERD_URI, uri);
-	return sord_new_uri_counted(world, uri, node.n_bytes, node.n_chars, true);
+  const SerdNode node = serd_node_from_string(SERD_URI, uri);
+  return sord_new_uri_counted(world, uri, node.n_bytes, node.n_chars, true);
 }
 
 SordNode*
@@ -1087,36 +1103,36 @@ sord_new_relative_uri(SordWorld*     world,
                       const uint8_t* uri,
                       const uint8_t* base_uri)
 {
-	if (serd_uri_string_has_scheme(uri)) {
-		return sord_new_uri(world, uri);
-	}
-	SerdURI  buri = SERD_URI_NULL;
-	SerdNode base = serd_node_new_uri_from_string(base_uri, NULL, &buri);
-	SerdNode node = serd_node_new_uri_from_string(uri, &buri, NULL);
+  if (serd_uri_string_has_scheme(uri)) {
+    return sord_new_uri(world, uri);
+  }
+  SerdURI  buri = SERD_URI_NULL;
+  SerdNode base = serd_node_new_uri_from_string(base_uri, NULL, &buri);
+  SerdNode node = serd_node_new_uri_from_string(uri, &buri, NULL);
 
-	SordNode* ret = sord_new_uri_counted(
-		world, node.buf, node.n_bytes, node.n_chars, false);
+  SordNode* ret =
+    sord_new_uri_counted(world, node.buf, node.n_bytes, node.n_chars, false);
 
-	serd_node_free(&base);
-	return ret;
+  serd_node_free(&base);
+  return ret;
 }
 
 static SordNode*
-sord_new_blank_counted(SordWorld* world, const uint8_t* str,
-                       size_t n_bytes, size_t n_chars)
+sord_new_blank_counted(SordWorld*     world,
+                       const uint8_t* str,
+                       size_t         n_bytes,
+                       size_t         n_chars)
 {
-	const SordNode key = {
-		{ str, n_bytes, n_chars, 0, SERD_BLANK }, 1, { { 0 } }
-	};
+  const SordNode key = {{str, n_bytes, n_chars, 0, SERD_BLANK}, 1, {{0}}};
 
-	return sord_insert_node(world, &key, true);
+  return sord_insert_node(world, &key, true);
 }
 
 SordNode*
 sord_new_blank(SordWorld* world, const uint8_t* str)
 {
-	const SerdNode node = serd_node_from_string(SERD_URI, str);
-	return sord_new_blank_counted(world, str, node.n_bytes, node.n_chars);
+  const SerdNode node = serd_node_from_string(SERD_URI, str);
+  return sord_new_blank_counted(world, str, node.n_bytes, node.n_chars);
 }
 
 static SordNode*
@@ -1128,28 +1144,27 @@ sord_new_literal_counted(SordWorld*     world,
                          SerdNodeFlags  flags,
                          const char*    lang)
 {
-	SordNode key = {
-		{ str, n_bytes, n_chars, flags, SERD_LITERAL }, 1, { { 0 } }
-	};
-	key.meta.lit.datatype = sord_node_copy(datatype);
-	memset(key.meta.lit.lang, 0, sizeof(key.meta.lit.lang));
-	if (lang) {
-		strncpy(key.meta.lit.lang, lang, sizeof(key.meta.lit.lang) - 1);
-	}
+  SordNode key = {{str, n_bytes, n_chars, flags, SERD_LITERAL}, 1, {{0}}};
+  key.meta.lit.datatype = sord_node_copy(datatype);
+  memset(key.meta.lit.lang, 0, sizeof(key.meta.lit.lang));
+  if (lang) {
+    strncpy(key.meta.lit.lang, lang, sizeof(key.meta.lit.lang) - 1);
+  }
 
-	return sord_insert_node(world, &key, true);
+  return sord_insert_node(world, &key, true);
 }
 
 SordNode*
-sord_new_literal(SordWorld* world, SordNode* datatype,
-                 const uint8_t* str, const char* lang)
+sord_new_literal(SordWorld*     world,
+                 SordNode*      datatype,
+                 const uint8_t* str,
+                 const char*    lang)
 {
-	SerdNodeFlags flags   = 0;
-	size_t        n_bytes = 0;
-	size_t        n_chars = serd_strlen(str, &n_bytes, &flags);
-	return sord_new_literal_counted(world, datatype,
-	                                str, n_bytes, n_chars, flags,
-	                                lang);
+  SerdNodeFlags flags   = 0;
+  size_t        n_bytes = 0;
+  size_t        n_chars = serd_strlen(str, &n_bytes, &flags);
+  return sord_new_literal_counted(
+    world, datatype, str, n_bytes, n_chars, flags, lang);
 }
 
 SordNode*
@@ -1159,195 +1174,195 @@ sord_node_from_serd_node(SordWorld*      world,
                          const SerdNode* datatype,
                          const SerdNode* lang)
 {
-	if (!node) {
-		return NULL;
-	}
-
-	SordNode* datatype_node = NULL;
-	SordNode* ret           = NULL;
-	switch (node->type) {
-	case SERD_NOTHING:
-		return NULL;
-	case SERD_LITERAL:
-		datatype_node = sord_node_from_serd_node(
-			world, env, datatype, NULL, NULL);
-		ret = sord_new_literal_counted(
-			world,
-			datatype_node,
-			node->buf,
-			node->n_bytes,
-			node->n_chars,
-			node->flags,
-			lang ? (const char*)lang->buf : NULL);
-		sord_node_free(world, datatype_node);
-		return ret;
-	case SERD_URI:
-		if (serd_uri_string_has_scheme(node->buf)) {
-			return sord_new_uri_counted(
-				world, node->buf, node->n_bytes, node->n_chars, true);
-		} else {
-			SerdURI base_uri;
-			serd_env_get_base_uri(env, &base_uri);
-			SerdURI  abs_uri;
-			SerdNode abs_uri_node = serd_node_new_uri_from_node(
-				node, &base_uri, &abs_uri);
-			ret = sord_new_uri_counted(world,
-			                           abs_uri_node.buf,
-			                           abs_uri_node.n_bytes,
-			                           abs_uri_node.n_chars,
-			                           true);
-			serd_node_free(&abs_uri_node);
-			return ret;
-		}
-	case SERD_CURIE: {
-		SerdChunk uri_prefix;
-		SerdChunk uri_suffix;
-		if (serd_env_expand(env, node, &uri_prefix, &uri_suffix)) {
-			error(world, SERD_ERR_BAD_CURIE,
-			      "failed to expand CURIE `%s'\n", node->buf);
-			return NULL;
-		}
-		const size_t uri_len = uri_prefix.len + uri_suffix.len;
-		uint8_t*     buf     = (uint8_t*)malloc(uri_len + 1);
-		memcpy(buf,                  uri_prefix.buf, uri_prefix.len);
-		memcpy(buf + uri_prefix.len, uri_suffix.buf, uri_suffix.len);
-		buf[uri_len] = '\0';
-		ret = sord_new_uri_counted(
-			world, buf, uri_len, serd_strlen(buf, NULL, NULL), false);
-		return ret;
-	}
-	case SERD_BLANK:
-		return sord_new_blank_counted(
-			world, node->buf, node->n_bytes, node->n_chars);
-	}
-	return NULL;
+  if (!node) {
+    return NULL;
+  }
+
+  SordNode* datatype_node = NULL;
+  SordNode* ret           = NULL;
+  switch (node->type) {
+  case SERD_NOTHING:
+    return NULL;
+  case SERD_LITERAL:
+    datatype_node = sord_node_from_serd_node(world, env, datatype, NULL, NULL);
+    ret           = sord_new_literal_counted(world,
+                                   datatype_node,
+                                   node->buf,
+                                   node->n_bytes,
+                                   node->n_chars,
+                                   node->flags,
+                                   lang ? (const char*)lang->buf : NULL);
+    sord_node_free(world, datatype_node);
+    return ret;
+  case SERD_URI:
+    if (serd_uri_string_has_scheme(node->buf)) {
+      return sord_new_uri_counted(
+        world, node->buf, node->n_bytes, node->n_chars, true);
+    } else {
+      SerdURI base_uri;
+      serd_env_get_base_uri(env, &base_uri);
+      SerdURI  abs_uri;
+      SerdNode abs_uri_node =
+        serd_node_new_uri_from_node(node, &base_uri, &abs_uri);
+      ret = sord_new_uri_counted(world,
+                                 abs_uri_node.buf,
+                                 abs_uri_node.n_bytes,
+                                 abs_uri_node.n_chars,
+                                 true);
+      serd_node_free(&abs_uri_node);
+      return ret;
+    }
+  case SERD_CURIE: {
+    SerdChunk uri_prefix;
+    SerdChunk uri_suffix;
+    if (serd_env_expand(env, node, &uri_prefix, &uri_suffix)) {
+      error(
+        world, SERD_ERR_BAD_CURIE, "failed to expand CURIE `%s'\n", node->buf);
+      return NULL;
+    }
+    const size_t uri_len = uri_prefix.len + uri_suffix.len;
+    uint8_t*     buf     = (uint8_t*)malloc(uri_len + 1);
+    memcpy(buf, uri_prefix.buf, uri_prefix.len);
+    memcpy(buf + uri_prefix.len, uri_suffix.buf, uri_suffix.len);
+    buf[uri_len] = '\0';
+    ret          = sord_new_uri_counted(
+      world, buf, uri_len, serd_strlen(buf, NULL, NULL), false);
+    return ret;
+  }
+  case SERD_BLANK:
+    return sord_new_blank_counted(
+      world, node->buf, node->n_bytes, node->n_chars);
+  }
+  return NULL;
 }
 
 const SerdNode*
 sord_node_to_serd_node(const SordNode* node)
 {
-	return node ? &node->node : &SERD_NODE_NULL;
+  return node ? &node->node : &SERD_NODE_NULL;
 }
 
 void
 sord_node_free(SordWorld* world, SordNode* node)
 {
-	if (!node) {
-		return;
-	} else if (node->refs == 0) {
-		error(world, SERD_ERR_BAD_ARG, "attempt to free garbage node\n");
-	} else if (--node->refs == 0) {
-		sord_node_free_internal(world, node);
-	}
+  if (!node) {
+    return;
+  } else if (node->refs == 0) {
+    error(world, SERD_ERR_BAD_ARG, "attempt to free garbage node\n");
+  } else if (--node->refs == 0) {
+    sord_node_free_internal(world, node);
+  }
 }
 
 SordNode*
 sord_node_copy(const SordNode* node)
 {
-	SordNode* copy = (SordNode*)node;
-	if (copy) {
-		++copy->refs;
-	}
-	return copy;
+  SordNode* copy = (SordNode*)node;
+  if (copy) {
+    ++copy->refs;
+  }
+  return copy;
 }
 
 static inline bool
 sord_add_to_index(SordModel* model, const SordNode** tup, SordOrder order)
 {
-	return !zix_btree_insert(model->indices[order], tup);
+  return !zix_btree_insert(model->indices[order], tup);
 }
 
 bool
 sord_add(SordModel* model, const SordQuad tup)
 {
-	SORD_WRITE_LOG("Add " TUP_FMT "\n", TUP_FMT_ARGS(tup));
-	if (!tup[0] || !tup[1] || !tup[2]) {
-		error(model->world, SERD_ERR_BAD_ARG,
-		      "attempt to add quad with NULL field\n");
-		return false;
-	} else if (model->n_iters > 0) {
-		error(model->world, SERD_ERR_BAD_ARG, "added tuple during iteration\n");
-	}
+  SORD_WRITE_LOG("Add " TUP_FMT "\n", TUP_FMT_ARGS(tup));
+  if (!tup[0] || !tup[1] || !tup[2]) {
+    error(
+      model->world, SERD_ERR_BAD_ARG, "attempt to add quad with NULL field\n");
+    return false;
+  } else if (model->n_iters > 0) {
+    error(model->world, SERD_ERR_BAD_ARG, "added tuple during iteration\n");
+  }
 
-	const SordNode** quad = (const SordNode**)malloc(sizeof(SordQuad));
-	memcpy(quad, tup, sizeof(SordQuad));
+  const SordNode** quad = (const SordNode**)malloc(sizeof(SordQuad));
+  memcpy(quad, tup, sizeof(SordQuad));
 
-	for (unsigned i = 0; i < NUM_ORDERS; ++i) {
-		if (model->indices[i] && (i < GSPO || tup[3])) {
-			if (!sord_add_to_index(model, quad, (SordOrder)i)) {
-				assert(i == 0);  // Assuming index coherency
-				free(quad);
-				return false;  // Quad already stored, do nothing
-			}
-		}
-	}
+  for (unsigned i = 0; i < NUM_ORDERS; ++i) {
+    if (model->indices[i] && (i < GSPO || tup[3])) {
+      if (!sord_add_to_index(model, quad, (SordOrder)i)) {
+        assert(i == 0); // Assuming index coherency
+        free(quad);
+        return false; // Quad already stored, do nothing
+      }
+    }
+  }
 
-	for (int i = 0; i < TUP_LEN; ++i) {
-		sord_add_quad_ref(model, tup[i], (SordQuadIndex)i);
-	}
+  for (int i = 0; i < TUP_LEN; ++i) {
+    sord_add_quad_ref(model, tup[i], (SordQuadIndex)i);
+  }
 
-	++model->n_quads;
-	return true;
+  ++model->n_quads;
+  return true;
 }
 
 void
 sord_remove(SordModel* model, const SordQuad tup)
 {
-	SORD_WRITE_LOG("Remove " TUP_FMT "\n", TUP_FMT_ARGS(tup));
-	if (model->n_iters > 0) {
-		error(model->world, SERD_ERR_BAD_ARG, "remove with iterator\n");
-	}
+  SORD_WRITE_LOG("Remove " TUP_FMT "\n", TUP_FMT_ARGS(tup));
+  if (model->n_iters > 0) {
+    error(model->world, SERD_ERR_BAD_ARG, "remove with iterator\n");
+  }
 
-	SordNode* quad = NULL;
-	for (unsigned i = 0; i < NUM_ORDERS; ++i) {
-		if (model->indices[i] && (i < GSPO || tup[3])) {
-			if (zix_btree_remove(model->indices[i], tup, (void**)&quad, NULL)) {
-				assert(i == 0);  // Assuming index coherency
-				return;  // Quad not found, do nothing
-			}
-		}
-	}
+  SordNode* quad = NULL;
+  for (unsigned i = 0; i < NUM_ORDERS; ++i) {
+    if (model->indices[i] && (i < GSPO || tup[3])) {
+      if (zix_btree_remove(model->indices[i], tup, (void**)&quad, NULL)) {
+        assert(i == 0); // Assuming index coherency
+        return;         // Quad not found, do nothing
+      }
+    }
+  }
 
-	free(quad);
+  free(quad);
 
-	for (int i = 0; i < TUP_LEN; ++i) {
-		sord_drop_quad_ref(model, tup[i], (SordQuadIndex)i);
-	}
+  for (int i = 0; i < TUP_LEN; ++i) {
+    sord_drop_quad_ref(model, tup[i], (SordQuadIndex)i);
+  }
 
-	--model->n_quads;
+  --model->n_quads;
 }
 
 SerdStatus
 sord_erase(SordModel* model, SordIter* iter)
 {
-	if (model->n_iters > 1) {
-		error(model->world, SERD_ERR_BAD_ARG, "erased with many iterators\n");
-		return SERD_ERR_BAD_ARG;
-	}
-
-	SordQuad tup;
-	sord_iter_get(iter, tup);
-
-	SORD_WRITE_LOG("Remove " TUP_FMT "\n", TUP_FMT_ARGS(tup));
-
-	SordNode* quad = NULL;
-	for (unsigned i = 0; i < NUM_ORDERS; ++i) {
-		if (model->indices[i] && (i < GSPO || tup[3])) {
-			if (zix_btree_remove(model->indices[i], tup, (void**)&quad,
-			                     i == iter->order ? &iter->cur : NULL)) {
-				return (i == 0) ? SERD_ERR_NOT_FOUND : SERD_ERR_INTERNAL;
-			}
-		}
-	}
-	iter->end = zix_btree_iter_is_end(iter->cur);
-	sord_iter_scan_next(iter);
-
-	free(quad);
-
-	for (int i = 0; i < TUP_LEN; ++i) {
-		sord_drop_quad_ref(model, tup[i], (SordQuadIndex)i);
-	}
-
-	--model->n_quads;
-	return SERD_SUCCESS;
+  if (model->n_iters > 1) {
+    error(model->world, SERD_ERR_BAD_ARG, "erased with many iterators\n");
+    return SERD_ERR_BAD_ARG;
+  }
+
+  SordQuad tup;
+  sord_iter_get(iter, tup);
+
+  SORD_WRITE_LOG("Remove " TUP_FMT "\n", TUP_FMT_ARGS(tup));
+
+  SordNode* quad = NULL;
+  for (unsigned i = 0; i < NUM_ORDERS; ++i) {
+    if (model->indices[i] && (i < GSPO || tup[3])) {
+      if (zix_btree_remove(model->indices[i],
+                           tup,
+                           (void**)&quad,
+                           i == iter->order ? &iter->cur : NULL)) {
+        return (i == 0) ? SERD_ERR_NOT_FOUND : SERD_ERR_INTERNAL;
+      }
+    }
+  }
+  iter->end = zix_btree_iter_is_end(iter->cur);
+  sord_iter_scan_next(iter);
+
+  free(quad);
+
+  for (int i = 0; i < TUP_LEN; ++i) {
+    sord_drop_quad_ref(model, tup[i], (SordQuadIndex)i);
+  }
+
+  --model->n_quads;
+  return SERD_SUCCESS;
 }
diff --git a/src/sord_internal.h b/src/sord_internal.h
index 872b1c1..0b74bcd 100644
--- a/src/sord_internal.h
+++ b/src/sord_internal.h
@@ -23,31 +23,31 @@
 #include <stddef.h>
 
 #if defined(__GNUC__) && __GNUC__ > 4
-#    define SORD_UNREACHABLE() __builtin_unreachable()
+#  define SORD_UNREACHABLE() __builtin_unreachable()
 #else
-#    include <assert.h>
-#    define SORD_UNREACHABLE() assert(0)
+#  include <assert.h>
+#  define SORD_UNREACHABLE() assert(0)
 #endif
 
 /** Resource node metadata */
 typedef struct {
-	size_t refs_as_obj;  ///< References as a quad object
+  size_t refs_as_obj; ///< References as a quad object
 } SordResourceMetadata;
 
 /** Literal node metadata */
 typedef struct {
-	SordNode* datatype;  ///< Optional literal data type URI
-	char      lang[16];  ///< Optional language tag
+  SordNode* datatype; ///< Optional literal data type URI
+  char      lang[16]; ///< Optional language tag
 } SordLiteralMetadata;
 
 /** Node */
 struct SordNodeImpl {
-	SerdNode node;  ///< Serd node
-	size_t   refs;  ///< Reference count (# of containing quads)
-	union {
-		SordResourceMetadata res;
-		SordLiteralMetadata  lit;
-	} meta;
+  SerdNode node; ///< Serd node
+  size_t   refs; ///< Reference count (# of containing quads)
+  union {
+    SordResourceMetadata res;
+    SordLiteralMetadata  lit;
+  } meta;
 };
 
 #endif /* SORD_SORD_INTERNAL_H */
diff --git a/src/sord_test.c b/src/sord_test.c
index 828acf8..d8a0d6c 100644
--- a/src/sord_test.c
+++ b/src/sord_test.c
@@ -26,9 +26,9 @@
 #include <string.h>
 
 #ifdef __GNUC__
-#    define SORD_LOG_FUNC(fmt, arg1) __attribute__((format(printf, fmt, arg1)))
+#  define SORD_LOG_FUNC(fmt, arg1) __attribute__((format(printf, fmt, arg1)))
 #else
-#    define SORD_LOG_FUNC(fmt, arg1)
+#  define SORD_LOG_FUNC(fmt, arg1)
 #endif
 
 static const int      DIGITS        = 3;
@@ -37,8 +37,8 @@ static const unsigned n_objects_per = 2;
 static int n_expected_errors = 0;
 
 typedef struct {
-	SordQuad query;
-	int      expected_num_results;
+  SordQuad query;
+  int      expected_num_results;
 } QueryTest;
 
 #define USTR(s) ((const uint8_t*)(s))
@@ -46,724 +46,722 @@ typedef struct {
 static SordNode*
 uri(SordWorld* world, int num)
 {
-	if (num == 0) {
-		return 0;
-	}
-
-	char  str[]   = "eg:000";
-	char* uri_num = str + 3;  // First `0'
-	snprintf(uri_num, DIGITS + 1, "%0*d", DIGITS, num);
-	return sord_new_uri(world, (const uint8_t*)str);
+  if (num == 0) {
+    return 0;
+  }
+
+  char  str[]   = "eg:000";
+  char* uri_num = str + 3; // First `0'
+  snprintf(uri_num, DIGITS + 1, "%0*d", DIGITS, num);
+  return sord_new_uri(world, (const uint8_t*)str);
 }
 
 SORD_LOG_FUNC(1, 2)
 static int
 test_fail(const char* fmt, ...)
 {
-	va_list args;
-	va_start(args, fmt);
-	fprintf(stderr, "error: ");
-	vfprintf(stderr, fmt, args);
-	va_end(args);
-	return 1;
+  va_list args;
+  va_start(args, fmt);
+  fprintf(stderr, "error: ");
+  vfprintf(stderr, fmt, args);
+  va_end(args);
+  return 1;
 }
 
 static int
-generate(SordWorld* world,
-         SordModel* sord,
-         size_t     n_quads,
-         SordNode*  graph)
+generate(SordWorld* world, SordModel* sord, size_t n_quads, SordNode* graph)
 {
-	fprintf(stderr, "Generating %zu (S P *) quads with %u objects each\n",
-	        n_quads, n_objects_per);
-
-	for (size_t i = 0; i < n_quads; ++i) {
-		int num = (i * n_objects_per) + 1;
-
-		SordNode* ids[2 + n_objects_per];
-		for (unsigned j = 0; j < 2 + n_objects_per; ++j) {
-			ids[j] = uri(world, num++);
-		}
-
-		for (unsigned j = 0; j < n_objects_per; ++j) {
-			SordQuad tup = { ids[0], ids[1], ids[2 + j], graph };
-			if (!sord_add(sord, tup)) {
-				return test_fail("Fail: Failed to add quad\n");
-			}
-		}
-
-		for (unsigned j = 0; j < 2 + n_objects_per; ++j) {
-			sord_node_free(world, ids[j]);
-		}
-	}
-
-	// Add some literals
-
-	// (98 4 "hello") and (98 4 "hello"^^<5>)
-	SordQuad tup = { 0, 0, 0, 0 };
-	tup[0] = uri(world, 98);
-	tup[1] = uri(world, 4);
-	tup[2] = sord_new_literal(world, 0, USTR("hello"), NULL);
-	tup[3] = graph;
-	sord_add(sord, tup);
-	sord_node_free(world, (SordNode*)tup[2]);
-	tup[2] = sord_new_literal(world, uri(world, 5), USTR("hello"), NULL);
-	if (!sord_add(sord, tup)) {
-		return test_fail("Failed to add typed literal\n");
-	}
-
-	// (96 4 "hello"^^<4>) and (96 4 "hello"^^<5>)
-	tup[0] = uri(world, 96);
-	tup[1] = uri(world, 4);
-	tup[2] = sord_new_literal(world, uri(world, 4), USTR("hello"), NULL);
-	tup[3] = graph;
-	sord_add(sord, tup);
-	sord_node_free(world, (SordNode*)tup[2]);
-	tup[2] = sord_new_literal(world, uri(world, 5), USTR("hello"), NULL);
-	if (!sord_add(sord, tup)) {
-		return test_fail("Failed to add typed literal\n");
-	}
-
-	// (94 5 "hello") and (94 5 "hello"@en-gb)
-	tup[0] = uri(world, 94);
-	tup[1] = uri(world, 5);
-	tup[2] = sord_new_literal(world, 0, USTR("hello"), NULL);
-	tup[3] = graph;
-	sord_add(sord, tup);
-	sord_node_free(world, (SordNode*)tup[2]);
-	tup[2] = sord_new_literal(world, NULL, USTR("hello"), "en-gb");
-	if (!sord_add(sord, tup)) {
-		return test_fail("Failed to add literal with language\n");
-	}
-
-	// (92 6 "hello"@en-us) and (92 5 "hello"@en-gb)
-	tup[0] = uri(world, 92);
-	tup[1] = uri(world, 6);
-	tup[2] = sord_new_literal(world, 0, USTR("hello"), "en-us");
-	tup[3] = graph;
-	sord_add(sord, tup);
-	sord_node_free(world, (SordNode*)tup[2]);
-	tup[2] = sord_new_literal(world, NULL, USTR("hello"), "en-gb");
-	if (!sord_add(sord, tup)) {
-		return test_fail("Failed to add literal with language\n");
-	}
-
-	sord_node_free(world, (SordNode*)tup[0]);
-	sord_node_free(world, (SordNode*)tup[2]);
-	tup[0] = uri(world, 14);
-	tup[2] = sord_new_literal(world, 0, USTR("bonjour"), "fr");
-	sord_add(sord, tup);
-	sord_node_free(world, (SordNode*)tup[2]);
-	tup[2] = sord_new_literal(world, 0, USTR("salut"), "fr");
-	sord_add(sord, tup);
-
-	// Attempt to add some duplicates
-	if (sord_add(sord, tup)) {
-		return test_fail("Fail: Successfully added duplicate quad\n");
-	}
-	if (sord_add(sord, tup)) {
-		return test_fail("Fail: Successfully added duplicate quad\n");
-	}
-
-	// Add a blank node subject
-	sord_node_free(world, (SordNode*)tup[0]);
-	tup[0] = sord_new_blank(world, USTR("ablank"));
-	sord_add(sord, tup);
-
-	sord_node_free(world, (SordNode*)tup[1]);
-	sord_node_free(world, (SordNode*)tup[2]);
-	tup[1] = uri(world, 6);
-	tup[2] = uri(world, 7);
-	sord_add(sord, tup);
-	sord_node_free(world, (SordNode*)tup[0]);
-	sord_node_free(world, (SordNode*)tup[1]);
-	sord_node_free(world, (SordNode*)tup[2]);
-
-	return EXIT_SUCCESS;
+  fprintf(stderr,
+          "Generating %zu (S P *) quads with %u objects each\n",
+          n_quads,
+          n_objects_per);
+
+  for (size_t i = 0; i < n_quads; ++i) {
+    int num = (i * n_objects_per) + 1;
+
+    SordNode* ids[2 + n_objects_per];
+    for (unsigned j = 0; j < 2 + n_objects_per; ++j) {
+      ids[j] = uri(world, num++);
+    }
+
+    for (unsigned j = 0; j < n_objects_per; ++j) {
+      SordQuad tup = {ids[0], ids[1], ids[2 + j], graph};
+      if (!sord_add(sord, tup)) {
+        return test_fail("Fail: Failed to add quad\n");
+      }
+    }
+
+    for (unsigned j = 0; j < 2 + n_objects_per; ++j) {
+      sord_node_free(world, ids[j]);
+    }
+  }
+
+  // Add some literals
+
+  // (98 4 "hello") and (98 4 "hello"^^<5>)
+  SordQuad tup = {0, 0, 0, 0};
+  tup[0]       = uri(world, 98);
+  tup[1]       = uri(world, 4);
+  tup[2]       = sord_new_literal(world, 0, USTR("hello"), NULL);
+  tup[3]       = graph;
+  sord_add(sord, tup);
+  sord_node_free(world, (SordNode*)tup[2]);
+  tup[2] = sord_new_literal(world, uri(world, 5), USTR("hello"), NULL);
+  if (!sord_add(sord, tup)) {
+    return test_fail("Failed to add typed literal\n");
+  }
+
+  // (96 4 "hello"^^<4>) and (96 4 "hello"^^<5>)
+  tup[0] = uri(world, 96);
+  tup[1] = uri(world, 4);
+  tup[2] = sord_new_literal(world, uri(world, 4), USTR("hello"), NULL);
+  tup[3] = graph;
+  sord_add(sord, tup);
+  sord_node_free(world, (SordNode*)tup[2]);
+  tup[2] = sord_new_literal(world, uri(world, 5), USTR("hello"), NULL);
+  if (!sord_add(sord, tup)) {
+    return test_fail("Failed to add typed literal\n");
+  }
+
+  // (94 5 "hello") and (94 5 "hello"@en-gb)
+  tup[0] = uri(world, 94);
+  tup[1] = uri(world, 5);
+  tup[2] = sord_new_literal(world, 0, USTR("hello"), NULL);
+  tup[3] = graph;
+  sord_add(sord, tup);
+  sord_node_free(world, (SordNode*)tup[2]);
+  tup[2] = sord_new_literal(world, NULL, USTR("hello"), "en-gb");
+  if (!sord_add(sord, tup)) {
+    return test_fail("Failed to add literal with language\n");
+  }
+
+  // (92 6 "hello"@en-us) and (92 5 "hello"@en-gb)
+  tup[0] = uri(world, 92);
+  tup[1] = uri(world, 6);
+  tup[2] = sord_new_literal(world, 0, USTR("hello"), "en-us");
+  tup[3] = graph;
+  sord_add(sord, tup);
+  sord_node_free(world, (SordNode*)tup[2]);
+  tup[2] = sord_new_literal(world, NULL, USTR("hello"), "en-gb");
+  if (!sord_add(sord, tup)) {
+    return test_fail("Failed to add literal with language\n");
+  }
+
+  sord_node_free(world, (SordNode*)tup[0]);
+  sord_node_free(world, (SordNode*)tup[2]);
+  tup[0] = uri(world, 14);
+  tup[2] = sord_new_literal(world, 0, USTR("bonjour"), "fr");
+  sord_add(sord, tup);
+  sord_node_free(world, (SordNode*)tup[2]);
+  tup[2] = sord_new_literal(world, 0, USTR("salut"), "fr");
+  sord_add(sord, tup);
+
+  // Attempt to add some duplicates
+  if (sord_add(sord, tup)) {
+    return test_fail("Fail: Successfully added duplicate quad\n");
+  }
+  if (sord_add(sord, tup)) {
+    return test_fail("Fail: Successfully added duplicate quad\n");
+  }
+
+  // Add a blank node subject
+  sord_node_free(world, (SordNode*)tup[0]);
+  tup[0] = sord_new_blank(world, USTR("ablank"));
+  sord_add(sord, tup);
+
+  sord_node_free(world, (SordNode*)tup[1]);
+  sord_node_free(world, (SordNode*)tup[2]);
+  tup[1] = uri(world, 6);
+  tup[2] = uri(world, 7);
+  sord_add(sord, tup);
+  sord_node_free(world, (SordNode*)tup[0]);
+  sord_node_free(world, (SordNode*)tup[1]);
+  sord_node_free(world, (SordNode*)tup[2]);
+
+  return EXIT_SUCCESS;
 }
 
 #define TUP_FMT "(%6s %6s %6s)"
-#define TUP_FMT_ARGS(t) \
-	((t)[0] ? sord_node_get_string((t)[0]) : USTR("*")), \
-		((t)[1] ? sord_node_get_string((t)[1]) : USTR("*")), \
-		((t)[2] ? sord_node_get_string((t)[2]) : USTR("*"))
+#define TUP_FMT_ARGS(t)                                  \
+  ((t)[0] ? sord_node_get_string((t)[0]) : USTR("*")),   \
+    ((t)[1] ? sord_node_get_string((t)[1]) : USTR("*")), \
+    ((t)[2] ? sord_node_get_string((t)[2]) : USTR("*"))
 
 static int
-test_read(SordWorld* world, SordModel* sord, SordNode* g,
-          const size_t n_quads)
+test_read(SordWorld* world, SordModel* sord, SordNode* g, const size_t n_quads)
 {
-	int ret = EXIT_SUCCESS;
+  int ret = EXIT_SUCCESS;
 
-	SordQuad id;
+  SordQuad id;
 
-	SordIter* iter = sord_begin(sord);
-	if (sord_iter_get_model(iter) != sord) {
-		return test_fail("Fail: Iterator has incorrect sord pointer\n");
-	}
+  SordIter* iter = sord_begin(sord);
+  if (sord_iter_get_model(iter) != sord) {
+    return test_fail("Fail: Iterator has incorrect sord pointer\n");
+  }
 
-	for (; !sord_iter_end(iter); sord_iter_next(iter)) {
-		sord_iter_get(iter, id);
-	}
+  for (; !sord_iter_end(iter); sord_iter_next(iter)) {
+    sord_iter_get(iter, id);
+  }
 
-	// Attempt to increment past end
-	if (!sord_iter_next(iter)) {
-		return test_fail("Fail: Successfully incremented past end\n");
-	}
+  // Attempt to increment past end
+  if (!sord_iter_next(iter)) {
+    return test_fail("Fail: Successfully incremented past end\n");
+  }
 
-	sord_iter_free(iter);
+  sord_iter_free(iter);
 
-	const uint8_t* s = USTR("hello");
-	SordNode* plain_hello = sord_new_literal(world, 0, s, NULL);
-	SordNode* type4_hello = sord_new_literal(world, uri(world, 4), s, NULL);
-	SordNode* type5_hello = sord_new_literal(world, uri(world, 5), s, NULL);
-	SordNode* gb_hello    = sord_new_literal(world, NULL, s, "en-gb");
-	SordNode* us_hello    = sord_new_literal(world, NULL, s, "en-us");
+  const uint8_t* s           = USTR("hello");
+  SordNode*      plain_hello = sord_new_literal(world, 0, s, NULL);
+  SordNode*      type4_hello = sord_new_literal(world, uri(world, 4), s, NULL);
+  SordNode*      type5_hello = sord_new_literal(world, uri(world, 5), s, NULL);
+  SordNode*      gb_hello    = sord_new_literal(world, NULL, s, "en-gb");
+  SordNode*      us_hello    = sord_new_literal(world, NULL, s, "en-us");
 
 #define NUM_PATTERNS 18
 
-	QueryTest patterns[NUM_PATTERNS] = {
-		{ { 0, 0, 0 }, (int)(n_quads * n_objects_per) + 12 },
-		{ { uri(world, 1), 0, 0 }, 2 },
-		{ { uri(world, 9), uri(world, 9), uri(world, 9) }, 0 },
-		{ { uri(world, 1), uri(world, 2), uri(world, 4) }, 1 },
-		{ { uri(world, 3), uri(world, 4), uri(world, 0) }, 2 },
-		{ { uri(world, 0), uri(world, 2), uri(world, 4) }, 1 },
-		{ { uri(world, 0), uri(world, 0), uri(world, 4) }, 1 },
-		{ { uri(world, 1), uri(world, 0), uri(world, 0) }, 2 },
-		{ { uri(world, 1), uri(world, 0), uri(world, 4) }, 1 },
-		{ { uri(world, 0), uri(world, 2), uri(world, 0) }, 2 },
-		{ { uri(world, 98), uri(world, 4), plain_hello  }, 1 },
-		{ { uri(world, 98), uri(world, 4), type5_hello  }, 1 },
-		{ { uri(world, 96), uri(world, 4), type4_hello  }, 1 },
-		{ { uri(world, 96), uri(world, 4), type5_hello  }, 1 },
-		{ { uri(world, 94), uri(world, 5), plain_hello  }, 1 },
-		{ { uri(world, 94), uri(world, 5), gb_hello     }, 1 },
-		{ { uri(world, 92), uri(world, 6), gb_hello     }, 1 },
-		{ { uri(world, 92), uri(world, 6), us_hello     }, 1 } };
-
-	SordQuad match = { uri(world, 1), uri(world, 2), uri(world, 4), g };
-	if (!sord_contains(sord, match)) {
-		return test_fail("Fail: No match for " TUP_FMT "\n",
-		                 TUP_FMT_ARGS(match));
-	}
-
-	SordQuad nomatch = { uri(world, 1), uri(world, 2), uri(world, 9), g };
-	if (sord_contains(sord, nomatch)) {
-		return test_fail("Fail: False match for " TUP_FMT "\n",
-		                 TUP_FMT_ARGS(nomatch));
-	}
-
-	if (sord_get(sord, NULL, NULL, uri(world, 3), g)) {
-		return test_fail("Fail: Get *,*,3 succeeded\n");
-	} else if (!sord_node_equals(
-		           sord_get(sord, uri(world, 1), uri(world, 2), NULL, g),
-		           uri(world, 3))) {
-		return test_fail("Fail: Get 1,2,* != 3\n");
-	} else if (!sord_node_equals(
-		           sord_get(sord, uri(world, 1), NULL, uri(world, 3), g),
-		           uri(world, 2))) {
-		return test_fail("Fail: Get 1,*,3 != 2\n");
-	} else if (!sord_node_equals(
-		           sord_get(sord, NULL, uri(world, 2), uri(world, 3), g),
-		           uri(world, 1))) {
-		return test_fail("Fail: Get *,2,3 != 1\n");
-	}
-
-	for (unsigned i = 0; i < NUM_PATTERNS; ++i) {
-		QueryTest test = patterns[i];
-		SordQuad  pat = { test.query[0], test.query[1], test.query[2], g };
-		fprintf(stderr, "Query " TUP_FMT "... ", TUP_FMT_ARGS(pat));
-
-		iter = sord_find(sord, pat);
-		int num_results = 0;
-		for (; !sord_iter_end(iter); sord_iter_next(iter)) {
-			sord_iter_get(iter, id);
-			++num_results;
-			if (!sord_quad_match(pat, id)) {
-				sord_iter_free(iter);
-				return test_fail(
-					"Fail: Query result " TUP_FMT " does not match pattern\n",
-					TUP_FMT_ARGS(id));
-			}
-		}
-		sord_iter_free(iter);
-		if (num_results != test.expected_num_results) {
-			return test_fail("Fail: Expected %d results, got %d\n",
-			                 test.expected_num_results, num_results);
-		}
-		fprintf(stderr, "OK (%i matches)\n", test.expected_num_results);
-	}
-
-	// Query blank node subject
-	SordQuad pat = { sord_new_blank(world, USTR("ablank")), 0, 0 };
-	if (!pat[0]) {
-		return test_fail("Blank node subject lost\n");
-	}
-	fprintf(stderr, "Query " TUP_FMT "... ", TUP_FMT_ARGS(pat));
-	iter = sord_find(sord, pat);
-	int num_results = 0;
-	for (; !sord_iter_end(iter); sord_iter_next(iter)) {
-		sord_iter_get(iter, id);
-		++num_results;
-		if (!sord_quad_match(pat, id)) {
-			sord_iter_free(iter);
-			return test_fail(
-				"Fail: Query result " TUP_FMT " does not match pattern\n",
-				TUP_FMT_ARGS(id));
-		}
-	}
-	fprintf(stderr, "OK\n");
-	sord_node_free(world, (SordNode*)pat[0]);
-	sord_iter_free(iter);
-	if (num_results != 2) {
-		return test_fail("Blank node subject query failed\n");
-	}
-
-	// Test nested queries
-	fprintf(stderr, "Nested Queries... ");
-	const SordNode* last_subject = 0;
-	iter = sord_search(sord, NULL, NULL, NULL, NULL);
-	for (; !sord_iter_end(iter); sord_iter_next(iter)) {
-		sord_iter_get(iter, id);
-		if (id[0] == last_subject) {
-			continue;
-		}
-
-		SordQuad  subpat          = { id[0], 0, 0 };
-		SordIter* subiter         = sord_find(sord, subpat);
-		unsigned  num_sub_results = 0;
-		if (sord_iter_get_node(subiter, SORD_SUBJECT) != id[0]) {
-			return test_fail("Fail: Incorrect initial submatch\n");
-		}
-		for (; !sord_iter_end(subiter); sord_iter_next(subiter)) {
-			SordQuad subid;
-			sord_iter_get(subiter, subid);
-			if (!sord_quad_match(subpat, subid)) {
-				sord_iter_free(iter);
-				sord_iter_free(subiter);
-				return test_fail(
-					"Fail: Nested query result does not match pattern\n");
-			}
-			++num_sub_results;
-		}
-		sord_iter_free(subiter);
-		if (num_sub_results != n_objects_per) {
-			return test_fail(
-				"Fail: Nested query " TUP_FMT " failed"
-				" (%u results, expected %u)\n",
-				TUP_FMT_ARGS(subpat), num_sub_results, n_objects_per);
-		}
-
-		uint64_t count = sord_count(sord, id[0], 0, 0, 0);
-		if (count != num_sub_results) {
-			return test_fail("Fail: Query " TUP_FMT " sord_count() %" PRIu64
-			                 "does not match result count %u\n",
-			                 TUP_FMT_ARGS(subpat), count, num_sub_results);
-		}
-
-		last_subject = id[0];
-	}
-	fprintf(stderr, "OK\n\n");
-	sord_iter_free(iter);
-
-	return ret;
+  QueryTest patterns[NUM_PATTERNS] = {
+    {{0, 0, 0}, (int)(n_quads * n_objects_per) + 12},
+    {{uri(world, 1), 0, 0}, 2},
+    {{uri(world, 9), uri(world, 9), uri(world, 9)}, 0},
+    {{uri(world, 1), uri(world, 2), uri(world, 4)}, 1},
+    {{uri(world, 3), uri(world, 4), uri(world, 0)}, 2},
+    {{uri(world, 0), uri(world, 2), uri(world, 4)}, 1},
+    {{uri(world, 0), uri(world, 0), uri(world, 4)}, 1},
+    {{uri(world, 1), uri(world, 0), uri(world, 0)}, 2},
+    {{uri(world, 1), uri(world, 0), uri(world, 4)}, 1},
+    {{uri(world, 0), uri(world, 2), uri(world, 0)}, 2},
+    {{uri(world, 98), uri(world, 4), plain_hello}, 1},
+    {{uri(world, 98), uri(world, 4), type5_hello}, 1},
+    {{uri(world, 96), uri(world, 4), type4_hello}, 1},
+    {{uri(world, 96), uri(world, 4), type5_hello}, 1},
+    {{uri(world, 94), uri(world, 5), plain_hello}, 1},
+    {{uri(world, 94), uri(world, 5), gb_hello}, 1},
+    {{uri(world, 92), uri(world, 6), gb_hello}, 1},
+    {{uri(world, 92), uri(world, 6), us_hello}, 1}};
+
+  SordQuad match = {uri(world, 1), uri(world, 2), uri(world, 4), g};
+  if (!sord_contains(sord, match)) {
+    return test_fail("Fail: No match for " TUP_FMT "\n", TUP_FMT_ARGS(match));
+  }
+
+  SordQuad nomatch = {uri(world, 1), uri(world, 2), uri(world, 9), g};
+  if (sord_contains(sord, nomatch)) {
+    return test_fail("Fail: False match for " TUP_FMT "\n",
+                     TUP_FMT_ARGS(nomatch));
+  }
+
+  if (sord_get(sord, NULL, NULL, uri(world, 3), g)) {
+    return test_fail("Fail: Get *,*,3 succeeded\n");
+  } else if (!sord_node_equals(
+               sord_get(sord, uri(world, 1), uri(world, 2), NULL, g),
+               uri(world, 3))) {
+    return test_fail("Fail: Get 1,2,* != 3\n");
+  } else if (!sord_node_equals(
+               sord_get(sord, uri(world, 1), NULL, uri(world, 3), g),
+               uri(world, 2))) {
+    return test_fail("Fail: Get 1,*,3 != 2\n");
+  } else if (!sord_node_equals(
+               sord_get(sord, NULL, uri(world, 2), uri(world, 3), g),
+               uri(world, 1))) {
+    return test_fail("Fail: Get *,2,3 != 1\n");
+  }
+
+  for (unsigned i = 0; i < NUM_PATTERNS; ++i) {
+    QueryTest test = patterns[i];
+    SordQuad  pat  = {test.query[0], test.query[1], test.query[2], g};
+    fprintf(stderr, "Query " TUP_FMT "... ", TUP_FMT_ARGS(pat));
+
+    iter            = sord_find(sord, pat);
+    int num_results = 0;
+    for (; !sord_iter_end(iter); sord_iter_next(iter)) {
+      sord_iter_get(iter, id);
+      ++num_results;
+      if (!sord_quad_match(pat, id)) {
+        sord_iter_free(iter);
+        return test_fail("Fail: Query result " TUP_FMT
+                         " does not match pattern\n",
+                         TUP_FMT_ARGS(id));
+      }
+    }
+    sord_iter_free(iter);
+    if (num_results != test.expected_num_results) {
+      return test_fail("Fail: Expected %d results, got %d\n",
+                       test.expected_num_results,
+                       num_results);
+    }
+    fprintf(stderr, "OK (%i matches)\n", test.expected_num_results);
+  }
+
+  // Query blank node subject
+  SordQuad pat = {sord_new_blank(world, USTR("ablank")), 0, 0};
+  if (!pat[0]) {
+    return test_fail("Blank node subject lost\n");
+  }
+  fprintf(stderr, "Query " TUP_FMT "... ", TUP_FMT_ARGS(pat));
+  iter            = sord_find(sord, pat);
+  int num_results = 0;
+  for (; !sord_iter_end(iter); sord_iter_next(iter)) {
+    sord_iter_get(iter, id);
+    ++num_results;
+    if (!sord_quad_match(pat, id)) {
+      sord_iter_free(iter);
+      return test_fail("Fail: Query result " TUP_FMT
+                       " does not match pattern\n",
+                       TUP_FMT_ARGS(id));
+    }
+  }
+  fprintf(stderr, "OK\n");
+  sord_node_free(world, (SordNode*)pat[0]);
+  sord_iter_free(iter);
+  if (num_results != 2) {
+    return test_fail("Blank node subject query failed\n");
+  }
+
+  // Test nested queries
+  fprintf(stderr, "Nested Queries... ");
+  const SordNode* last_subject = 0;
+  iter                         = sord_search(sord, NULL, NULL, NULL, NULL);
+  for (; !sord_iter_end(iter); sord_iter_next(iter)) {
+    sord_iter_get(iter, id);
+    if (id[0] == last_subject) {
+      continue;
+    }
+
+    SordQuad  subpat          = {id[0], 0, 0};
+    SordIter* subiter         = sord_find(sord, subpat);
+    unsigned  num_sub_results = 0;
+    if (sord_iter_get_node(subiter, SORD_SUBJECT) != id[0]) {
+      return test_fail("Fail: Incorrect initial submatch\n");
+    }
+    for (; !sord_iter_end(subiter); sord_iter_next(subiter)) {
+      SordQuad subid;
+      sord_iter_get(subiter, subid);
+      if (!sord_quad_match(subpat, subid)) {
+        sord_iter_free(iter);
+        sord_iter_free(subiter);
+        return test_fail("Fail: Nested query result does not match pattern\n");
+      }
+      ++num_sub_results;
+    }
+    sord_iter_free(subiter);
+    if (num_sub_results != n_objects_per) {
+      return test_fail("Fail: Nested query " TUP_FMT " failed"
+                       " (%u results, expected %u)\n",
+                       TUP_FMT_ARGS(subpat),
+                       num_sub_results,
+                       n_objects_per);
+    }
+
+    uint64_t count = sord_count(sord, id[0], 0, 0, 0);
+    if (count != num_sub_results) {
+      return test_fail("Fail: Query " TUP_FMT " sord_count() %" PRIu64
+                       "does not match result count %u\n",
+                       TUP_FMT_ARGS(subpat),
+                       count,
+                       num_sub_results);
+    }
+
+    last_subject = id[0];
+  }
+  fprintf(stderr, "OK\n\n");
+  sord_iter_free(iter);
+
+  return ret;
 }
 
 static SerdStatus
 unexpected_error(void* handle, const SerdError* error)
 {
-	fprintf(stderr, "unexpected error: ");
-	vfprintf(stderr, error->fmt, *error->args);
-	return SERD_SUCCESS;
+  fprintf(stderr, "unexpected error: ");
+  vfprintf(stderr, error->fmt, *error->args);
+  return SERD_SUCCESS;
 }
 
 static SerdStatus
 expected_error(void* handle, const SerdError* error)
 {
-	fprintf(stderr, "expected error: ");
-	vfprintf(stderr, error->fmt, *error->args);
-	++n_expected_errors;
-	return SERD_SUCCESS;
+  fprintf(stderr, "expected error: ");
+  vfprintf(stderr, error->fmt, *error->args);
+  ++n_expected_errors;
+  return SERD_SUCCESS;
 }
 
 static int
 finished(SordWorld* world, SordModel* sord, int status)
 {
-	sord_free(sord);
-	sord_world_free(world);
-	return status;
+  sord_free(sord);
+  sord_world_free(world);
+  return status;
 }
 
 int
 main(int argc, char** argv)
 {
-	static const size_t n_quads = 300;
-
-	sord_free(NULL);  // Shouldn't crash
-
-	SordWorld* world = sord_world_new();
-
-
-	// Attempt to create invalid URI
-	fprintf(stderr, "expected ");
-	SordNode* bad_uri = sord_new_uri(world, USTR("noscheme"));
-	if (bad_uri) {
-		return test_fail("Successfully created invalid URI \"noscheme\"\n");
-	}
-	sord_node_free(world, bad_uri);
-
-	sord_world_set_error_sink(world, expected_error, NULL);
-
-	// Attempt to create invalid CURIE
-	SerdNode  base = serd_node_from_string(SERD_URI, USTR("http://example.org/"));
-	SerdEnv*  env  = serd_env_new(&base);
-	SerdNode  sbad = serd_node_from_string(SERD_CURIE, USTR("bad:"));
-	SordNode* bad  = sord_node_from_serd_node(world, env, &sbad, NULL, NULL);
-	if (bad) {
-		return test_fail("Successfully created CURIE with bad namespace\n");
-	}
-	sord_node_free(world, bad);
-	serd_env_free(env);
-
-	// Attempt to create node from garbage
-	SerdNode junk = SERD_NODE_NULL;
-	junk.type = (SerdType)1234;
-	if (sord_node_from_serd_node(world, env, &junk, NULL, NULL)) {
-		return test_fail("Successfully created node from garbage serd node\n");
-	}
-
-	// Attempt to create NULL node
-	SordNode* nil_node = sord_node_from_serd_node(
-		world, NULL, &SERD_NODE_NULL, NULL, NULL);
-	if (nil_node) {
-		return test_fail("Successfully created NULL node\n");
-	}
-	sord_node_free(world, nil_node);
-
-	// Check node flags are set properly
-	SordNode* with_newline = sord_new_literal(world, NULL, USTR("a\nb"), NULL);
-	if (!(sord_node_get_flags(with_newline) & SERD_HAS_NEWLINE)) {
-		return test_fail("Newline flag not set\n");
-	}
-	SordNode* with_quote = sord_new_literal(world, NULL, USTR("a\"b"), NULL);
-	if (!(sord_node_get_flags(with_quote) & SERD_HAS_QUOTE)) {
-		return test_fail("Quote flag not set\n");
-	}
-
-	// Create with minimal indexing
-	SordModel* sord = sord_new(world, SORD_SPO, false);
-	generate(world, sord, n_quads, NULL);
-
-	if (test_read(world, sord, NULL, n_quads)) {
-		sord_free(sord);
-		sord_world_free(world);
-		return EXIT_FAILURE;
-	}
-
-	// Check adding tuples with NULL fields fails
-	sord_world_set_error_sink(world, expected_error, NULL);
-	const size_t initial_num_quads = sord_num_quads(sord);
-	SordQuad tup = { 0, 0, 0, 0};
-	if (sord_add(sord, tup)) {
-		return test_fail("Added NULL tuple\n");
-	}
-	tup[0] = uri(world, 1);
-	if (sord_add(sord, tup)) {
-		return test_fail("Added tuple with NULL P and O\n");
-	}
-	tup[1] = uri(world, 2);
-	if (sord_add(sord, tup)) {
-		return test_fail("Added tuple with NULL O\n");
-	}
-
-	if (sord_num_quads(sord) != initial_num_quads) {
-		return test_fail("Num quads %zu != %zu\n",
-		                 sord_num_quads(sord), initial_num_quads);
-	}
-
-	// Check adding tuples with an active iterator fails
-	SordIter* iter = sord_begin(sord);
-	tup[2] = uri(world, 3);
-	if (sord_add(sord, tup)) {
-		return test_fail("Added tuple with active iterator\n");
-	}
-
-	// Check removing tuples with several active iterator fails
-	SordIter* iter2 = sord_begin(sord);
-	if (!sord_erase(sord, iter)) {
-		return test_fail("Erased tuple with several active iterators\n");
-	}
-	n_expected_errors = 0;
-	sord_remove(sord, tup);
-	if (n_expected_errors != 1) {
-		return test_fail("Removed tuple with several active iterators\n");
-	}
-	sord_iter_free(iter);
-	sord_iter_free(iter2);
-
-	sord_world_set_error_sink(world, unexpected_error, NULL);
-
-	// Check interning merges equivalent values
-	SordNode* uri_id   = sord_new_uri(world, USTR("http://example.org"));
-	SordNode* blank_id = sord_new_blank(world, USTR("testblank"));
-	SordNode* lit_id   = sord_new_literal(world, uri_id, USTR("hello"), NULL);
-	if (sord_node_get_type(uri_id) != SORD_URI) {
-		return test_fail("URI node has incorrect type\n");
-	} else if (sord_node_get_type(blank_id) != SORD_BLANK) {
-		return test_fail("Blank node has incorrect type\n");
-	} else if (sord_node_get_type(lit_id) != SORD_LITERAL) {
-		return test_fail("Literal node has incorrect type\n");
-	}
-
-	const size_t initial_num_nodes = sord_num_nodes(world);
-
-	SordNode* uri_id2   = sord_new_uri(world, USTR("http://example.org"));
-	SordNode* blank_id2 = sord_new_blank(world, USTR("testblank"));
-	SordNode* lit_id2   = sord_new_literal(world, uri_id, USTR("hello"), NULL);
-	if (uri_id2 != uri_id || !sord_node_equals(uri_id2, uri_id)) {
-		fprintf(stderr, "Fail: URI interning failed (duplicates)\n");
-		return finished(world, sord, EXIT_FAILURE);
-	} else if (blank_id2 != blank_id
-	           || !sord_node_equals(blank_id2, blank_id)) {
-		fprintf(stderr, "Fail: Blank node interning failed (duplicates)\n");
-		return finished(world, sord, EXIT_FAILURE);
-	} else if (lit_id2 != lit_id || !sord_node_equals(lit_id2, lit_id)) {
-		fprintf(stderr, "Fail: Literal interning failed (duplicates)\n");
-		return finished(world, sord, EXIT_FAILURE);
-	}
-
-	if (sord_num_nodes(world) != initial_num_nodes) {
-		return test_fail("Num nodes %zu != %zu\n",
-		                 sord_num_nodes(world), initial_num_nodes);
-	}
-
-	const uint8_t ni_hao[] = { 0xE4, 0xBD, 0xA0, 0xE5, 0xA5, 0xBD, 0 };
-	SordNode*     chello   = sord_new_literal(world, NULL, ni_hao, "cmn");
-
-	// Test literal length
-	size_t         n_bytes;
-	size_t         n_chars;
-	const uint8_t* str = sord_node_get_string_counted(lit_id2, &n_bytes);
-	if (strcmp((const char*)str, "hello")) {
-		return test_fail("Literal node corrupt\n");
-	} else if (n_bytes != strlen("hello")) {
-		return test_fail("ASCII literal byte count incorrect\n");
-	}
-
-	str = sord_node_get_string_measured(lit_id2, &n_bytes, &n_chars);
-	if (n_bytes != strlen("hello") || n_chars != strlen("hello")) {
-		return test_fail("ASCII literal measured length incorrect\n");
-	} else if (strcmp((const char*)str, "hello")) {
-		return test_fail("ASCII literal string incorrect\n");
-	}
-
-	str = sord_node_get_string_measured(chello, &n_bytes, &n_chars);
-	if (n_bytes != 6) {
-		return test_fail("Multi-byte literal byte count incorrect\n");
-	} else if (n_chars != 2) {
-		return test_fail("Multi-byte literal character count incorrect\n");
-	} else if (strcmp((const char*)str, (const char*)ni_hao)) {
-		return test_fail("Multi-byte literal string incorrect\n");
-	}
-
-	// Check interning doesn't clash non-equivalent values
-	SordNode* uri_id3   = sord_new_uri(world, USTR("http://example.orgX"));
-	SordNode* blank_id3 = sord_new_blank(world, USTR("testblankX"));
-	SordNode* lit_id3   = sord_new_literal(world, uri_id, USTR("helloX"), NULL);
-	if (uri_id3 == uri_id || sord_node_equals(uri_id3, uri_id)) {
-		fprintf(stderr, "Fail: URI interning failed (clash)\n");
-		return finished(world, sord, EXIT_FAILURE);
-	} else if (blank_id3 == blank_id || sord_node_equals(blank_id3, blank_id)) {
-		fprintf(stderr, "Fail: Blank node interning failed (clash)\n");
-		return finished(world, sord, EXIT_FAILURE);
-	} else if (lit_id3 == lit_id || sord_node_equals(lit_id3, lit_id)) {
-		fprintf(stderr, "Fail: Literal interning failed (clash)\n");
-		return finished(world, sord, EXIT_FAILURE);
-	}
-
-	// Check literal interning
-	SordNode* lit4 = sord_new_literal(world, NULL, USTR("hello"), NULL);
-	SordNode* lit5 = sord_new_literal(world, uri_id2, USTR("hello"), NULL);
-	SordNode* lit6 = sord_new_literal(world, NULL, USTR("hello"), "en-ca");
-	if (lit4 == lit5 || sord_node_equals(lit4, lit5)
-	    || lit4 == lit6 || sord_node_equals(lit4, lit6)
-	    || lit5 == lit6 || sord_node_equals(lit5, lit6)) {
-		fprintf(stderr, "Fail: Literal interning failed (type/lang clash)\n");
-		return finished(world, sord, EXIT_FAILURE);
-	}
-
-	// Check relative URI construction
-	SordNode* reluri = sord_new_relative_uri(
-		world, USTR("a/b"), USTR("http://example.org/"));
-	if (strcmp((const char*)sord_node_get_string(reluri),
-	           "http://example.org/a/b")) {
-		fprintf(stderr, "Fail: Bad relative URI constructed: <%s>\n",
-		        sord_node_get_string(reluri));
-		return finished(world, sord, EXIT_FAILURE);
-	}
-	SordNode* reluri2 = sord_new_relative_uri(
-		world, USTR("http://drobilla.net/"), USTR("http://example.org/"));
-	if (strcmp((const char*)sord_node_get_string(reluri2),
-	           "http://drobilla.net/")) {
-		fprintf(stderr, "Fail: Bad relative URI constructed: <%s>\n",
-		        sord_node_get_string(reluri));
-		return finished(world, sord, EXIT_FAILURE);
-	}
-
-	// Check comparison with NULL
-	sord_node_free(world, uri_id);
-	sord_node_free(world, blank_id);
-	sord_node_free(world, lit_id);
-	sord_node_free(world, uri_id2);
-	sord_node_free(world, blank_id2);
-	sord_node_free(world, lit_id2);
-	sord_node_free(world, uri_id3);
-	sord_node_free(world, blank_id3);
-	sord_node_free(world, lit_id3);
-	sord_free(sord);
-
-	static const char* const index_names[6] = {
-		"spo", "sop", "ops", "osp", "pso", "pos"
-	};
-
-	for (int i = 0; i < 6; ++i) {
-		sord = sord_new(world, (1 << i), false);
-		printf("Testing Index `%s'\n", index_names[i]);
-		generate(world, sord, n_quads, 0);
-		if (test_read(world, sord, 0, n_quads)) {
-			return finished(world, sord, EXIT_FAILURE);
-		}
-		sord_free(sord);
-	}
-
-	static const char* const graph_index_names[6] = {
-		"gspo", "gsop", "gops", "gosp", "gpso", "gpos"
-	};
-
-	for (int i = 0; i < 6; ++i) {
-		sord = sord_new(world, (1 << i), true);
-		printf("Testing Index `%s'\n", graph_index_names[i]);
-		SordNode* graph = uri(world, 42);
-		generate(world, sord, n_quads, graph);
-		if (test_read(world, sord, graph, n_quads)) {
-			return finished(world, sord, EXIT_FAILURE);
-		}
-		sord_free(sord);
-	}
-
-	// Test removing
-	sord = sord_new(world, SORD_SPO, true);
-	tup[0] = uri(world, 1);
-	tup[1] = uri(world, 2);
-	tup[2] = sord_new_literal(world, 0, USTR("hello"), NULL);
-	tup[3] = 0;
-	sord_add(sord, tup);
-	if (!sord_ask(sord, tup[0], tup[1], tup[2], tup[3])) {
-		fprintf(stderr, "Failed to add tuple\n");
-		return finished(world, sord, EXIT_FAILURE);
-	}
-	sord_node_free(world, (SordNode*)tup[2]);
-	tup[2] = sord_new_literal(world, 0, USTR("hi"), NULL);
-	sord_add(sord, tup);
-	sord_remove(sord, tup);
-	if (sord_num_quads(sord) != 1) {
-		fprintf(stderr, "Remove failed (%zu quads, expected 1)\n",
-		        sord_num_quads(sord));
-		return finished(world, sord, EXIT_FAILURE);
-	}
-
-	iter = sord_find(sord, tup);
-	if (!sord_iter_end(iter)) {
-		fprintf(stderr, "Found removed tuple\n");
-		return finished(world, sord, EXIT_FAILURE);
-	}
-	sord_iter_free(iter);
-
-	// Test double remove (silent success)
-	sord_remove(sord, tup);
-
-	// Load a couple graphs
-	SordNode* graph42 = uri(world, 42);
-	SordNode* graph43 = uri(world, 43);
-	generate(world, sord, 1, graph42);
-	generate(world, sord, 1, graph43);
-
-	// Remove one graph via iterator
-	SerdStatus st;
-	iter = sord_search(sord, NULL, NULL, NULL, graph43);
-	while (!sord_iter_end(iter)) {
-		if ((st = sord_erase(sord, iter))) {
-			fprintf(stderr, "Remove by iterator failed (%s)\n",
-			        serd_strerror(st));
-			return finished(world, sord, EXIT_FAILURE);
-		}
-	}
-	sord_iter_free(iter);
-
-	// Erase the first tuple (an element in the default graph)
-	iter = sord_begin(sord);
-	if (sord_erase(sord, iter)) {
-		return test_fail("Failed to erase begin iterator on non-empty model\n");
-	}
-	sord_iter_free(iter);
-
-	// Ensure only the other graph is left
-	SordQuad quad;
-	SordQuad pat = { 0, 0, 0, graph42 };
-	for (iter = sord_begin(sord); !sord_iter_end(iter); sord_iter_next(iter)) {
-		sord_iter_get(iter, quad);
-		if (!sord_quad_match(quad, pat)) {
-			fprintf(stderr, "Graph removal via iteration failed\n");
-			return finished(world, sord, EXIT_FAILURE);
-		}
-	}
-	sord_iter_free(iter);
-
-	// Load file into two separate graphs
-	sord_free(sord);
-	sord = sord_new(world, SORD_SPO, true);
-	env  = serd_env_new(&base);
-	SordNode*   graph1 = sord_new_uri(world, USTR("http://example.org/graph1"));
-	SordNode*   graph2 = sord_new_uri(world, USTR("http://example.org/graph2"));
-	SerdReader* reader = sord_new_reader(sord, env, SERD_TURTLE, graph1);
-	if ((st = serd_reader_read_string(reader, USTR("<s> <p> <o> .")))) {
-		fprintf(stderr, "Failed to read string (%s)\n", serd_strerror(st));
-		return finished(world, sord, EXIT_FAILURE);
-	}
-	serd_reader_free(reader);
-	reader = sord_new_reader(sord, env, SERD_TURTLE, graph2);
-	if ((st = serd_reader_read_string(reader, USTR("<s> <p> <o> .")))) {
-		fprintf(stderr, "Failed to re-read string (%s)\n", serd_strerror(st));
-		return finished(world, sord, EXIT_FAILURE);
-	}
-	serd_reader_free(reader);
-	serd_env_free(env);
-
-	// Ensure we only see triple once
-	size_t n_triples = 0;
-	for (iter = sord_begin(sord); !sord_iter_end(iter); sord_iter_next(iter)) {
-		fprintf(stderr, "%s %s %s %s\n",
-		        sord_node_get_string(sord_iter_get_node(iter, SORD_SUBJECT)),
-		        sord_node_get_string(sord_iter_get_node(iter, SORD_PREDICATE)),
-		        sord_node_get_string(sord_iter_get_node(iter, SORD_OBJECT)),
-		        sord_node_get_string(sord_iter_get_node(iter, SORD_GRAPH)));
-
-		++n_triples;
-	}
-	sord_iter_free(iter);
-	if (n_triples != 1) {
-		fprintf(stderr, "Found duplicate triple\n");
-		return finished(world, sord, EXIT_FAILURE);
-	}
-
-	// Test SPO iteration on an SOP indexed store
-	sord_free(sord);
-	sord = sord_new(world, SORD_SOP, false);
-	generate(world, sord, 1, graph42);
-	for (iter = sord_begin(sord); !sord_iter_end(iter); sord_iter_next(iter)) {
-		++n_triples;
-	}
-	sord_iter_free(iter);
-
-	return finished(world, sord, EXIT_SUCCESS);
+  static const size_t n_quads = 300;
+
+  sord_free(NULL); // Shouldn't crash
+
+  SordWorld* world = sord_world_new();
+
+  // Attempt to create invalid URI
+  fprintf(stderr, "expected ");
+  SordNode* bad_uri = sord_new_uri(world, USTR("noscheme"));
+  if (bad_uri) {
+    return test_fail("Successfully created invalid URI \"noscheme\"\n");
+  }
+  sord_node_free(world, bad_uri);
+
+  sord_world_set_error_sink(world, expected_error, NULL);
+
+  // Attempt to create invalid CURIE
+  SerdNode  base = serd_node_from_string(SERD_URI, USTR("http://example.org/"));
+  SerdEnv*  env  = serd_env_new(&base);
+  SerdNode  sbad = serd_node_from_string(SERD_CURIE, USTR("bad:"));
+  SordNode* bad  = sord_node_from_serd_node(world, env, &sbad, NULL, NULL);
+  if (bad) {
+    return test_fail("Successfully created CURIE with bad namespace\n");
+  }
+  sord_node_free(world, bad);
+  serd_env_free(env);
+
+  // Attempt to create node from garbage
+  SerdNode junk = SERD_NODE_NULL;
+  junk.type     = (SerdType)1234;
+  if (sord_node_from_serd_node(world, env, &junk, NULL, NULL)) {
+    return test_fail("Successfully created node from garbage serd node\n");
+  }
+
+  // Attempt to create NULL node
+  SordNode* nil_node =
+    sord_node_from_serd_node(world, NULL, &SERD_NODE_NULL, NULL, NULL);
+  if (nil_node) {
+    return test_fail("Successfully created NULL node\n");
+  }
+  sord_node_free(world, nil_node);
+
+  // Check node flags are set properly
+  SordNode* with_newline = sord_new_literal(world, NULL, USTR("a\nb"), NULL);
+  if (!(sord_node_get_flags(with_newline) & SERD_HAS_NEWLINE)) {
+    return test_fail("Newline flag not set\n");
+  }
+  SordNode* with_quote = sord_new_literal(world, NULL, USTR("a\"b"), NULL);
+  if (!(sord_node_get_flags(with_quote) & SERD_HAS_QUOTE)) {
+    return test_fail("Quote flag not set\n");
+  }
+
+  // Create with minimal indexing
+  SordModel* sord = sord_new(world, SORD_SPO, false);
+  generate(world, sord, n_quads, NULL);
+
+  if (test_read(world, sord, NULL, n_quads)) {
+    sord_free(sord);
+    sord_world_free(world);
+    return EXIT_FAILURE;
+  }
+
+  // Check adding tuples with NULL fields fails
+  sord_world_set_error_sink(world, expected_error, NULL);
+  const size_t initial_num_quads = sord_num_quads(sord);
+  SordQuad     tup               = {0, 0, 0, 0};
+  if (sord_add(sord, tup)) {
+    return test_fail("Added NULL tuple\n");
+  }
+  tup[0] = uri(world, 1);
+  if (sord_add(sord, tup)) {
+    return test_fail("Added tuple with NULL P and O\n");
+  }
+  tup[1] = uri(world, 2);
+  if (sord_add(sord, tup)) {
+    return test_fail("Added tuple with NULL O\n");
+  }
+
+  if (sord_num_quads(sord) != initial_num_quads) {
+    return test_fail(
+      "Num quads %zu != %zu\n", sord_num_quads(sord), initial_num_quads);
+  }
+
+  // Check adding tuples with an active iterator fails
+  SordIter* iter = sord_begin(sord);
+  tup[2]         = uri(world, 3);
+  if (sord_add(sord, tup)) {
+    return test_fail("Added tuple with active iterator\n");
+  }
+
+  // Check removing tuples with several active iterator fails
+  SordIter* iter2 = sord_begin(sord);
+  if (!sord_erase(sord, iter)) {
+    return test_fail("Erased tuple with several active iterators\n");
+  }
+  n_expected_errors = 0;
+  sord_remove(sord, tup);
+  if (n_expected_errors != 1) {
+    return test_fail("Removed tuple with several active iterators\n");
+  }
+  sord_iter_free(iter);
+  sord_iter_free(iter2);
+
+  sord_world_set_error_sink(world, unexpected_error, NULL);
+
+  // Check interning merges equivalent values
+  SordNode* uri_id   = sord_new_uri(world, USTR("http://example.org"));
+  SordNode* blank_id = sord_new_blank(world, USTR("testblank"));
+  SordNode* lit_id   = sord_new_literal(world, uri_id, USTR("hello"), NULL);
+  if (sord_node_get_type(uri_id) != SORD_URI) {
+    return test_fail("URI node has incorrect type\n");
+  } else if (sord_node_get_type(blank_id) != SORD_BLANK) {
+    return test_fail("Blank node has incorrect type\n");
+  } else if (sord_node_get_type(lit_id) != SORD_LITERAL) {
+    return test_fail("Literal node has incorrect type\n");
+  }
+
+  const size_t initial_num_nodes = sord_num_nodes(world);
+
+  SordNode* uri_id2   = sord_new_uri(world, USTR("http://example.org"));
+  SordNode* blank_id2 = sord_new_blank(world, USTR("testblank"));
+  SordNode* lit_id2   = sord_new_literal(world, uri_id, USTR("hello"), NULL);
+  if (uri_id2 != uri_id || !sord_node_equals(uri_id2, uri_id)) {
+    fprintf(stderr, "Fail: URI interning failed (duplicates)\n");
+    return finished(world, sord, EXIT_FAILURE);
+  } else if (blank_id2 != blank_id || !sord_node_equals(blank_id2, blank_id)) {
+    fprintf(stderr, "Fail: Blank node interning failed (duplicates)\n");
+    return finished(world, sord, EXIT_FAILURE);
+  } else if (lit_id2 != lit_id || !sord_node_equals(lit_id2, lit_id)) {
+    fprintf(stderr, "Fail: Literal interning failed (duplicates)\n");
+    return finished(world, sord, EXIT_FAILURE);
+  }
+
+  if (sord_num_nodes(world) != initial_num_nodes) {
+    return test_fail(
+      "Num nodes %zu != %zu\n", sord_num_nodes(world), initial_num_nodes);
+  }
+
+  const uint8_t ni_hao[] = {0xE4, 0xBD, 0xA0, 0xE5, 0xA5, 0xBD, 0};
+  SordNode*     chello   = sord_new_literal(world, NULL, ni_hao, "cmn");
+
+  // Test literal length
+  size_t         n_bytes;
+  size_t         n_chars;
+  const uint8_t* str = sord_node_get_string_counted(lit_id2, &n_bytes);
+  if (strcmp((const char*)str, "hello")) {
+    return test_fail("Literal node corrupt\n");
+  } else if (n_bytes != strlen("hello")) {
+    return test_fail("ASCII literal byte count incorrect\n");
+  }
+
+  str = sord_node_get_string_measured(lit_id2, &n_bytes, &n_chars);
+  if (n_bytes != strlen("hello") || n_chars != strlen("hello")) {
+    return test_fail("ASCII literal measured length incorrect\n");
+  } else if (strcmp((const char*)str, "hello")) {
+    return test_fail("ASCII literal string incorrect\n");
+  }
+
+  str = sord_node_get_string_measured(chello, &n_bytes, &n_chars);
+  if (n_bytes != 6) {
+    return test_fail("Multi-byte literal byte count incorrect\n");
+  } else if (n_chars != 2) {
+    return test_fail("Multi-byte literal character count incorrect\n");
+  } else if (strcmp((const char*)str, (const char*)ni_hao)) {
+    return test_fail("Multi-byte literal string incorrect\n");
+  }
+
+  // Check interning doesn't clash non-equivalent values
+  SordNode* uri_id3   = sord_new_uri(world, USTR("http://example.orgX"));
+  SordNode* blank_id3 = sord_new_blank(world, USTR("testblankX"));
+  SordNode* lit_id3   = sord_new_literal(world, uri_id, USTR("helloX"), NULL);
+  if (uri_id3 == uri_id || sord_node_equals(uri_id3, uri_id)) {
+    fprintf(stderr, "Fail: URI interning failed (clash)\n");
+    return finished(world, sord, EXIT_FAILURE);
+  } else if (blank_id3 == blank_id || sord_node_equals(blank_id3, blank_id)) {
+    fprintf(stderr, "Fail: Blank node interning failed (clash)\n");
+    return finished(world, sord, EXIT_FAILURE);
+  } else if (lit_id3 == lit_id || sord_node_equals(lit_id3, lit_id)) {
+    fprintf(stderr, "Fail: Literal interning failed (clash)\n");
+    return finished(world, sord, EXIT_FAILURE);
+  }
+
+  // Check literal interning
+  SordNode* lit4 = sord_new_literal(world, NULL, USTR("hello"), NULL);
+  SordNode* lit5 = sord_new_literal(world, uri_id2, USTR("hello"), NULL);
+  SordNode* lit6 = sord_new_literal(world, NULL, USTR("hello"), "en-ca");
+  if (lit4 == lit5 || sord_node_equals(lit4, lit5) || lit4 == lit6 ||
+      sord_node_equals(lit4, lit6) || lit5 == lit6 ||
+      sord_node_equals(lit5, lit6)) {
+    fprintf(stderr, "Fail: Literal interning failed (type/lang clash)\n");
+    return finished(world, sord, EXIT_FAILURE);
+  }
+
+  // Check relative URI construction
+  SordNode* reluri =
+    sord_new_relative_uri(world, USTR("a/b"), USTR("http://example.org/"));
+  if (strcmp((const char*)sord_node_get_string(reluri),
+             "http://example.org/a/b")) {
+    fprintf(stderr,
+            "Fail: Bad relative URI constructed: <%s>\n",
+            sord_node_get_string(reluri));
+    return finished(world, sord, EXIT_FAILURE);
+  }
+  SordNode* reluri2 = sord_new_relative_uri(
+    world, USTR("http://drobilla.net/"), USTR("http://example.org/"));
+  if (strcmp((const char*)sord_node_get_string(reluri2),
+             "http://drobilla.net/")) {
+    fprintf(stderr,
+            "Fail: Bad relative URI constructed: <%s>\n",
+            sord_node_get_string(reluri));
+    return finished(world, sord, EXIT_FAILURE);
+  }
+
+  // Check comparison with NULL
+  sord_node_free(world, uri_id);
+  sord_node_free(world, blank_id);
+  sord_node_free(world, lit_id);
+  sord_node_free(world, uri_id2);
+  sord_node_free(world, blank_id2);
+  sord_node_free(world, lit_id2);
+  sord_node_free(world, uri_id3);
+  sord_node_free(world, blank_id3);
+  sord_node_free(world, lit_id3);
+  sord_free(sord);
+
+  static const char* const index_names[6] = {
+    "spo", "sop", "ops", "osp", "pso", "pos"};
+
+  for (int i = 0; i < 6; ++i) {
+    sord = sord_new(world, (1 << i), false);
+    printf("Testing Index `%s'\n", index_names[i]);
+    generate(world, sord, n_quads, 0);
+    if (test_read(world, sord, 0, n_quads)) {
+      return finished(world, sord, EXIT_FAILURE);
+    }
+    sord_free(sord);
+  }
+
+  static const char* const graph_index_names[6] = {
+    "gspo", "gsop", "gops", "gosp", "gpso", "gpos"};
+
+  for (int i = 0; i < 6; ++i) {
+    sord = sord_new(world, (1 << i), true);
+    printf("Testing Index `%s'\n", graph_index_names[i]);
+    SordNode* graph = uri(world, 42);
+    generate(world, sord, n_quads, graph);
+    if (test_read(world, sord, graph, n_quads)) {
+      return finished(world, sord, EXIT_FAILURE);
+    }
+    sord_free(sord);
+  }
+
+  // Test removing
+  sord   = sord_new(world, SORD_SPO, true);
+  tup[0] = uri(world, 1);
+  tup[1] = uri(world, 2);
+  tup[2] = sord_new_literal(world, 0, USTR("hello"), NULL);
+  tup[3] = 0;
+  sord_add(sord, tup);
+  if (!sord_ask(sord, tup[0], tup[1], tup[2], tup[3])) {
+    fprintf(stderr, "Failed to add tuple\n");
+    return finished(world, sord, EXIT_FAILURE);
+  }
+  sord_node_free(world, (SordNode*)tup[2]);
+  tup[2] = sord_new_literal(world, 0, USTR("hi"), NULL);
+  sord_add(sord, tup);
+  sord_remove(sord, tup);
+  if (sord_num_quads(sord) != 1) {
+    fprintf(
+      stderr, "Remove failed (%zu quads, expected 1)\n", sord_num_quads(sord));
+    return finished(world, sord, EXIT_FAILURE);
+  }
+
+  iter = sord_find(sord, tup);
+  if (!sord_iter_end(iter)) {
+    fprintf(stderr, "Found removed tuple\n");
+    return finished(world, sord, EXIT_FAILURE);
+  }
+  sord_iter_free(iter);
+
+  // Test double remove (silent success)
+  sord_remove(sord, tup);
+
+  // Load a couple graphs
+  SordNode* graph42 = uri(world, 42);
+  SordNode* graph43 = uri(world, 43);
+  generate(world, sord, 1, graph42);
+  generate(world, sord, 1, graph43);
+
+  // Remove one graph via iterator
+  SerdStatus st;
+  iter = sord_search(sord, NULL, NULL, NULL, graph43);
+  while (!sord_iter_end(iter)) {
+    if ((st = sord_erase(sord, iter))) {
+      fprintf(stderr, "Remove by iterator failed (%s)\n", serd_strerror(st));
+      return finished(world, sord, EXIT_FAILURE);
+    }
+  }
+  sord_iter_free(iter);
+
+  // Erase the first tuple (an element in the default graph)
+  iter = sord_begin(sord);
+  if (sord_erase(sord, iter)) {
+    return test_fail("Failed to erase begin iterator on non-empty model\n");
+  }
+  sord_iter_free(iter);
+
+  // Ensure only the other graph is left
+  SordQuad quad;
+  SordQuad pat = {0, 0, 0, graph42};
+  for (iter = sord_begin(sord); !sord_iter_end(iter); sord_iter_next(iter)) {
+    sord_iter_get(iter, quad);
+    if (!sord_quad_match(quad, pat)) {
+      fprintf(stderr, "Graph removal via iteration failed\n");
+      return finished(world, sord, EXIT_FAILURE);
+    }
+  }
+  sord_iter_free(iter);
+
+  // Load file into two separate graphs
+  sord_free(sord);
+  sord               = sord_new(world, SORD_SPO, true);
+  env                = serd_env_new(&base);
+  SordNode*   graph1 = sord_new_uri(world, USTR("http://example.org/graph1"));
+  SordNode*   graph2 = sord_new_uri(world, USTR("http://example.org/graph2"));
+  SerdReader* reader = sord_new_reader(sord, env, SERD_TURTLE, graph1);
+  if ((st = serd_reader_read_string(reader, USTR("<s> <p> <o> .")))) {
+    fprintf(stderr, "Failed to read string (%s)\n", serd_strerror(st));
+    return finished(world, sord, EXIT_FAILURE);
+  }
+  serd_reader_free(reader);
+  reader = sord_new_reader(sord, env, SERD_TURTLE, graph2);
+  if ((st = serd_reader_read_string(reader, USTR("<s> <p> <o> .")))) {
+    fprintf(stderr, "Failed to re-read string (%s)\n", serd_strerror(st));
+    return finished(world, sord, EXIT_FAILURE);
+  }
+  serd_reader_free(reader);
+  serd_env_free(env);
+
+  // Ensure we only see triple once
+  size_t n_triples = 0;
+  for (iter = sord_begin(sord); !sord_iter_end(iter); sord_iter_next(iter)) {
+    fprintf(stderr,
+            "%s %s %s %s\n",
+            sord_node_get_string(sord_iter_get_node(iter, SORD_SUBJECT)),
+            sord_node_get_string(sord_iter_get_node(iter, SORD_PREDICATE)),
+            sord_node_get_string(sord_iter_get_node(iter, SORD_OBJECT)),
+            sord_node_get_string(sord_iter_get_node(iter, SORD_GRAPH)));
+
+    ++n_triples;
+  }
+  sord_iter_free(iter);
+  if (n_triples != 1) {
+    fprintf(stderr, "Found duplicate triple\n");
+    return finished(world, sord, EXIT_FAILURE);
+  }
+
+  // Test SPO iteration on an SOP indexed store
+  sord_free(sord);
+  sord = sord_new(world, SORD_SOP, false);
+  generate(world, sord, 1, graph42);
+  for (iter = sord_begin(sord); !sord_iter_end(iter); sord_iter_next(iter)) {
+    ++n_triples;
+  }
+  sord_iter_free(iter);
+
+  return finished(world, sord, EXIT_SUCCESS);
 }
diff --git a/src/sord_validate.c b/src/sord_validate.c
index 193dc06..0acb0a4 100644
--- a/src/sord_validate.c
+++ b/src/sord_validate.c
@@ -14,18 +14,18 @@
   OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
-#define _BSD_SOURCE     1  // for realpath
-#define _DEFAULT_SOURCE 1  // for realpath
+#define _BSD_SOURCE 1     // for realpath
+#define _DEFAULT_SOURCE 1 // for realpath
 
 #include "serd/serd.h"
 #include "sord/sord.h"
 #include "sord_config.h"
 
 #ifdef HAVE_PCRE
-#    include <pcre.h>
+#  include <pcre.h>
 #endif
 #ifdef _WIN32
-#    include <windows.h>
+#  include <windows.h>
 #endif
 
 #include <stdarg.h>
@@ -36,55 +36,55 @@
 #include <string.h>
 
 #ifdef __GNUC__
-#    define SORD_LOG_FUNC(fmt, arg1) __attribute__((format(printf, fmt, arg1)))
+#  define SORD_LOG_FUNC(fmt, arg1) __attribute__((format(printf, fmt, arg1)))
 #else
-#    define SORD_LOG_FUNC(fmt, arg1)
+#  define SORD_LOG_FUNC(fmt, arg1)
 #endif
 
 #define NS_foaf (const uint8_t*)"http://xmlns.com/foaf/0.1/"
-#define NS_owl  (const uint8_t*)"http://www.w3.org/2002/07/owl#"
-#define NS_rdf  (const uint8_t*)"http://www.w3.org/1999/02/22-rdf-syntax-ns#"
+#define NS_owl (const uint8_t*)"http://www.w3.org/2002/07/owl#"
+#define NS_rdf (const uint8_t*)"http://www.w3.org/1999/02/22-rdf-syntax-ns#"
 #define NS_rdfs (const uint8_t*)"http://www.w3.org/2000/01/rdf-schema#"
-#define NS_xsd  (const uint8_t*)"http://www.w3.org/2001/XMLSchema#"
+#define NS_xsd (const uint8_t*)"http://www.w3.org/2001/XMLSchema#"
 
 typedef struct {
-	SordNode* foaf_Document;
-	SordNode* owl_AnnotationProperty;
-	SordNode* owl_Class;
-	SordNode* owl_DatatypeProperty;
-	SordNode* owl_FunctionalProperty;
-	SordNode* owl_InverseFunctionalProperty;
-	SordNode* owl_ObjectProperty;
-	SordNode* owl_OntologyProperty;
-	SordNode* owl_Restriction;
-	SordNode* owl_Thing;
-	SordNode* owl_cardinality;
-	SordNode* owl_equivalentClass;
-	SordNode* owl_maxCardinality;
-	SordNode* owl_minCardinality;
-	SordNode* owl_onDatatype;
-	SordNode* owl_onProperty;
-	SordNode* owl_someValuesFrom;
-	SordNode* owl_withRestrictions;
-	SordNode* rdf_PlainLiteral;
-	SordNode* rdf_Property;
-	SordNode* rdf_first;
-	SordNode* rdf_rest;
-	SordNode* rdf_type;
-	SordNode* rdfs_Class;
-	SordNode* rdfs_Literal;
-	SordNode* rdfs_Resource;
-	SordNode* rdfs_domain;
-	SordNode* rdfs_label;
-	SordNode* rdfs_range;
-	SordNode* rdfs_subClassOf;
-	SordNode* xsd_anyURI;
-	SordNode* xsd_decimal;
-	SordNode* xsd_double;
-	SordNode* xsd_maxInclusive;
-	SordNode* xsd_minInclusive;
-	SordNode* xsd_pattern;
-	SordNode* xsd_string;
+  SordNode* foaf_Document;
+  SordNode* owl_AnnotationProperty;
+  SordNode* owl_Class;
+  SordNode* owl_DatatypeProperty;
+  SordNode* owl_FunctionalProperty;
+  SordNode* owl_InverseFunctionalProperty;
+  SordNode* owl_ObjectProperty;
+  SordNode* owl_OntologyProperty;
+  SordNode* owl_Restriction;
+  SordNode* owl_Thing;
+  SordNode* owl_cardinality;
+  SordNode* owl_equivalentClass;
+  SordNode* owl_maxCardinality;
+  SordNode* owl_minCardinality;
+  SordNode* owl_onDatatype;
+  SordNode* owl_onProperty;
+  SordNode* owl_someValuesFrom;
+  SordNode* owl_withRestrictions;
+  SordNode* rdf_PlainLiteral;
+  SordNode* rdf_Property;
+  SordNode* rdf_first;
+  SordNode* rdf_rest;
+  SordNode* rdf_type;
+  SordNode* rdfs_Class;
+  SordNode* rdfs_Literal;
+  SordNode* rdfs_Resource;
+  SordNode* rdfs_domain;
+  SordNode* rdfs_label;
+  SordNode* rdfs_range;
+  SordNode* rdfs_subClassOf;
+  SordNode* xsd_anyURI;
+  SordNode* xsd_decimal;
+  SordNode* xsd_double;
+  SordNode* xsd_maxInclusive;
+  SordNode* xsd_minInclusive;
+  SordNode* xsd_pattern;
+  SordNode* xsd_string;
 } URIs;
 
 static int  n_errors        = 0;
@@ -94,42 +94,42 @@ static bool one_line_errors = false;
 static int
 print_version(void)
 {
-	printf("sord_validate " SORD_VERSION
-	       " <http://drobilla.net/software/sord>\n");
-	printf("Copyright 2012-2017 David Robillard <http://drobilla.net>.\n"
-	       "License: <http://www.opensource.org/licenses/isc>\n"
-	       "This is free software; you are free to change and redistribute it."
-	       "\nThere is NO WARRANTY, to the extent permitted by law.\n");
-	return 0;
+  printf("sord_validate " SORD_VERSION
+         " <http://drobilla.net/software/sord>\n");
+  printf("Copyright 2012-2017 David Robillard <http://drobilla.net>.\n"
+         "License: <http://www.opensource.org/licenses/isc>\n"
+         "This is free software; you are free to change and redistribute it."
+         "\nThere is NO WARRANTY, to the extent permitted by law.\n");
+  return 0;
 }
 
 static int
 print_usage(const char* name, bool error)
 {
-	FILE* const os = error ? stderr : stdout;
-	fprintf(os, "Usage: %s [OPTION]... INPUT...\n", name);
-	fprintf(os, "Validate RDF data\n\n");
-	fprintf(os, "  -h  Display this help and exit\n");
-	fprintf(os, "  -l  Print errors on a single line.\n");
-	fprintf(os, "  -v  Display version information and exit\n");
-	fprintf(os,
-	        "Validate RDF data.  This is a simple validator which checks\n"
-	        "that all used properties are actually defined.  It does not do\n"
-	        "any fancy file retrieval, the files passed on the command line\n"
-	        "are the only data that is read.  In other words, you must pass\n"
-	        "the definition of all vocabularies used on the command line.\n");
-	return error ? 1 : 0;
+  FILE* const os = error ? stderr : stdout;
+  fprintf(os, "Usage: %s [OPTION]... INPUT...\n", name);
+  fprintf(os, "Validate RDF data\n\n");
+  fprintf(os, "  -h  Display this help and exit\n");
+  fprintf(os, "  -l  Print errors on a single line.\n");
+  fprintf(os, "  -v  Display version information and exit\n");
+  fprintf(os,
+          "Validate RDF data.  This is a simple validator which checks\n"
+          "that all used properties are actually defined.  It does not do\n"
+          "any fancy file retrieval, the files passed on the command line\n"
+          "are the only data that is read.  In other words, you must pass\n"
+          "the definition of all vocabularies used on the command line.\n");
+  return error ? 1 : 0;
 }
 
 static uint8_t*
 absolute_path(const uint8_t* path)
 {
 #ifdef _WIN32
-	char* out = (char*)malloc(MAX_PATH);
-	GetFullPathName((const char*)path, MAX_PATH, out, NULL);
-	return (uint8_t*)out;
+  char* out = (char*)malloc(MAX_PATH);
+  GetFullPathName((const char*)path, MAX_PATH, out, NULL);
+  return (uint8_t*)out;
 #else
-	return (uint8_t*)realpath((const char*)path, NULL);
+  return (uint8_t*)realpath((const char*)path, NULL);
 #endif
 }
 
@@ -137,20 +137,24 @@ SORD_LOG_FUNC(2, 3)
 static int
 errorf(const SordQuad quad, const char* fmt, ...)
 {
-	va_list args;
-	va_start(args, fmt);
-	fprintf(stderr, "error: ");
-	vfprintf(stderr, fmt, args);
-	va_end(args);
-
-	const char* sep = one_line_errors ? "\t" : "\n       ";
-	fprintf(stderr, "%s%s%s%s%s%s\n",
-	        sep, (const char*)sord_node_get_string(quad[SORD_SUBJECT]),
-	        sep, (const char*)sord_node_get_string(quad[SORD_PREDICATE]),
-	        sep, (const char*)sord_node_get_string(quad[SORD_OBJECT]));
-
-	++n_errors;
-	return 1;
+  va_list args;
+  va_start(args, fmt);
+  fprintf(stderr, "error: ");
+  vfprintf(stderr, fmt, args);
+  va_end(args);
+
+  const char* sep = one_line_errors ? "\t" : "\n       ";
+  fprintf(stderr,
+          "%s%s%s%s%s%s\n",
+          sep,
+          (const char*)sord_node_get_string(quad[SORD_SUBJECT]),
+          sep,
+          (const char*)sord_node_get_string(quad[SORD_PREDICATE]),
+          sep,
+          (const char*)sord_node_get_string(quad[SORD_OBJECT]));
+
+  ++n_errors;
+  return 1;
 }
 
 static bool
@@ -160,56 +164,55 @@ is_descendant_of(SordModel*      model,
                  const SordNode* parent,
                  const SordNode* pred)
 {
-	if (!child) {
-		return false;
-	} else if (
-		sord_node_equals(child, parent) ||
-		sord_ask(model, child, uris->owl_equivalentClass, parent, NULL)) {
-		return true;
-	}
-
-	SordIter* i = sord_search(model, child, pred, NULL, NULL);
-	for (; !sord_iter_end(i); sord_iter_next(i)) {
-		const SordNode* o = sord_iter_get_node(i, SORD_OBJECT);
-		if (sord_node_equals(child, o)) {
-			continue;  // Weird class is explicitly a descendent of itself
-		}
-		if (is_descendant_of(model, uris, o, parent, pred)) {
-			sord_iter_free(i);
-			return true;
-		}
-	}
-	sord_iter_free(i);
-
-	return false;
+  if (!child) {
+    return false;
+  } else if (sord_node_equals(child, parent) ||
+             sord_ask(model, child, uris->owl_equivalentClass, parent, NULL)) {
+    return true;
+  }
+
+  SordIter* i = sord_search(model, child, pred, NULL, NULL);
+  for (; !sord_iter_end(i); sord_iter_next(i)) {
+    const SordNode* o = sord_iter_get_node(i, SORD_OBJECT);
+    if (sord_node_equals(child, o)) {
+      continue; // Weird class is explicitly a descendent of itself
+    }
+    if (is_descendant_of(model, uris, o, parent, pred)) {
+      sord_iter_free(i);
+      return true;
+    }
+  }
+  sord_iter_free(i);
+
+  return false;
 }
 
 static bool
 regexp_match(const uint8_t* pat, const char* str)
 {
 #ifdef HAVE_PCRE
-	// Append a $ to the pattern so we only match if the entire string matches
-	const size_t len  = strlen((const char*)pat);
-	char* const  regx = (char*)malloc(len + 2);
-	memcpy(regx, pat, len);
-	regx[len]     = '$';
-	regx[len + 1] = '\0';
-
-	const char* err;
-	int         erroffset;
-	pcre*       re = pcre_compile(regx, PCRE_ANCHORED, &err, &erroffset, NULL);
-	free(regx);
-	if (!re) {
-		fprintf(stderr, "Error in pattern `%s' at offset %d (%s)\n",
-		        pat, erroffset, err);
-		return false;
-	}
-
-	const bool ret = pcre_exec(re, NULL, str, strlen(str), 0, 0, NULL, 0) >= 0;
-	pcre_free(re);
-	return ret;
-#endif  // HAVE_PCRE
-	return true;
+  // Append a $ to the pattern so we only match if the entire string matches
+  const size_t len  = strlen((const char*)pat);
+  char* const  regx = (char*)malloc(len + 2);
+  memcpy(regx, pat, len);
+  regx[len]     = '$';
+  regx[len + 1] = '\0';
+
+  const char* err;
+  int         erroffset;
+  pcre*       re = pcre_compile(regx, PCRE_ANCHORED, &err, &erroffset, NULL);
+  free(regx);
+  if (!re) {
+    fprintf(
+      stderr, "Error in pattern `%s' at offset %d (%s)\n", pat, erroffset, err);
+    return false;
+  }
+
+  const bool ret = pcre_exec(re, NULL, str, strlen(str), 0, 0, NULL, 0) >= 0;
+  pcre_free(re);
+  return ret;
+#endif // HAVE_PCRE
+  return true;
 }
 
 static int
@@ -219,22 +222,20 @@ bound_cmp(SordModel*      model,
           const SordNode* type,
           const SordNode* bound)
 {
-	const char*     str        = (const char*)sord_node_get_string(literal);
-	const char*     bound_str  = (const char*)sord_node_get_string(bound);
-	const SordNode* pred       = uris->owl_onDatatype;
-	const bool      is_numeric =
-		is_descendant_of(model, uris, type, uris->xsd_decimal, pred) ||
-		is_descendant_of(model, uris, type, uris->xsd_double, pred);
-
-	if (is_numeric) {
-		const double fbound   = serd_strtod(bound_str, NULL);
-		const double fliteral = serd_strtod(str, NULL);
-		return ((fliteral < fbound) ? -1 :
-		        (fliteral > fbound) ? 1 :
-		        0);
-	} else {
-		return strcmp(str, bound_str);
-	}
+  const char*     str       = (const char*)sord_node_get_string(literal);
+  const char*     bound_str = (const char*)sord_node_get_string(bound);
+  const SordNode* pred      = uris->owl_onDatatype;
+  const bool      is_numeric =
+    is_descendant_of(model, uris, type, uris->xsd_decimal, pred) ||
+    is_descendant_of(model, uris, type, uris->xsd_double, pred);
+
+  if (is_numeric) {
+    const double fbound   = serd_strtod(bound_str, NULL);
+    const double fliteral = serd_strtod(str, NULL);
+    return ((fliteral < fbound) ? -1 : (fliteral > fbound) ? 1 : 0);
+  } else {
+    return strcmp(str, bound_str);
+  }
 }
 
 static bool
@@ -244,58 +245,61 @@ check_restriction(SordModel*      model,
                   const SordNode* type,
                   const SordNode* restriction)
 {
-	size_t      len = 0;
-	const char* str = (const char*)sord_node_get_string_counted(literal, &len);
-
-	// Check xsd:pattern
-	SordIter* p = sord_search(model, restriction, uris->xsd_pattern, 0, 0);
-	if (p) {
-		const SordNode* pat  = sord_iter_get_node(p, SORD_OBJECT);
-		if (!regexp_match(sord_node_get_string(pat), str)) {
-			fprintf(stderr, "`%s' does not match <%s> pattern `%s'\n",
-			        sord_node_get_string(literal),
-			        sord_node_get_string(type),
-			        sord_node_get_string(pat));
-			sord_iter_free(p);
-			return false;
-		}
-		sord_iter_free(p);
-		++n_restrictions;
-	}
-
-	// Check xsd:minInclusive
-	SordIter* l = sord_search(model, restriction, uris->xsd_minInclusive, 0, 0);
-	if (l) {
-		const SordNode* lower = sord_iter_get_node(l, SORD_OBJECT);
-		if (bound_cmp(model, uris, literal, type, lower) < 0) {
-			fprintf(stderr, "`%s' is not >= <%s> minimum `%s'\n",
-			        sord_node_get_string(literal),
-			        sord_node_get_string(type),
-			        sord_node_get_string(lower));
-			sord_iter_free(l);
-			return false;
-		}
-		sord_iter_free(l);
-		++n_restrictions;
-	}
-
-	// Check xsd:maxInclusive
-	SordIter* u = sord_search(model, restriction, uris->xsd_maxInclusive, 0, 0);
-	if (u) {
-		const SordNode* upper = sord_iter_get_node(u, SORD_OBJECT);
-		if (bound_cmp(model, uris, literal, type, upper) > 0) {
-			fprintf(stderr, "`%s' is not <= <%s> maximum `%s'\n",
-			        sord_node_get_string(literal),
-			        sord_node_get_string(type),
-			        sord_node_get_string(upper));
-			sord_iter_free(u);
-			return false;
-		}
-		sord_iter_free(u);
-		++n_restrictions;
-	}
-
-	return true;  // Unknown restriction, be quietly tolerant
+  size_t      len = 0;
+  const char* str = (const char*)sord_node_get_string_counted(literal, &len);
+
+  // Check xsd:pattern
+  SordIter* p = sord_search(model, restriction, uris->xsd_pattern, 0, 0);
+  if (p) {
+    const SordNode* pat = sord_iter_get_node(p, SORD_OBJECT);
+    if (!regexp_match(sord_node_get_string(pat), str)) {
+      fprintf(stderr,
+              "`%s' does not match <%s> pattern `%s'\n",
+              sord_node_get_string(literal),
+              sord_node_get_string(type),
+              sord_node_get_string(pat));
+      sord_iter_free(p);
+      return false;
+    }
+    sord_iter_free(p);
+    ++n_restrictions;
+  }
+
+  // Check xsd:minInclusive
+  SordIter* l = sord_search(model, restriction, uris->xsd_minInclusive, 0, 0);
+  if (l) {
+    const SordNode* lower = sord_iter_get_node(l, SORD_OBJECT);
+    if (bound_cmp(model, uris, literal, type, lower) < 0) {
+      fprintf(stderr,
+              "`%s' is not >= <%s> minimum `%s'\n",
+              sord_node_get_string(literal),
+              sord_node_get_string(type),
+              sord_node_get_string(lower));
+      sord_iter_free(l);
+      return false;
+    }
+    sord_iter_free(l);
+    ++n_restrictions;
+  }
+
+  // Check xsd:maxInclusive
+  SordIter* u = sord_search(model, restriction, uris->xsd_maxInclusive, 0, 0);
+  if (u) {
+    const SordNode* upper = sord_iter_get_node(u, SORD_OBJECT);
+    if (bound_cmp(model, uris, literal, type, upper) > 0) {
+      fprintf(stderr,
+              "`%s' is not <= <%s> maximum `%s'\n",
+              sord_node_get_string(literal),
+              sord_node_get_string(type),
+              sord_node_get_string(upper));
+      sord_iter_free(u);
+      return false;
+    }
+    sord_iter_free(u);
+    ++n_restrictions;
+  }
+
+  return true; // Unknown restriction, be quietly tolerant
 }
 
 static bool
@@ -305,78 +309,72 @@ literal_is_valid(SordModel*      model,
                  const SordNode* literal,
                  const SordNode* type)
 {
-	if (!type) {
-		return true;
-	}
-
-	/* Check that literal data is related to required type.  We don't do a
-	   strict subtype check here because e.g. an xsd:decimal might be a valid
-	   xsd:unsignedInt, which the pattern checks will verify, but if the
-	   literal type is not related to the required type at all
-	   (e.g. xsd:decimal and xsd:string) there is a problem. */
-	const SordNode* datatype = sord_node_get_datatype(literal);
-	if (datatype && datatype != type) {
-		if (!is_descendant_of(
-			    model, uris,
-			    datatype, type, uris->owl_onDatatype) &&
-		    !is_descendant_of(
-			    model, uris,
-			    type, datatype, uris->owl_onDatatype) &&
-		    !(sord_node_equals(datatype, uris->xsd_decimal) &&
-		      is_descendant_of(
-			      model, uris,
-			      type, uris->xsd_double, uris->owl_onDatatype))) {
-			errorf(quad,
-			       "Literal `%s' datatype <%s> is not compatible with <%s>\n",
-			       sord_node_get_string(literal),
-			       sord_node_get_string(datatype),
-			       sord_node_get_string(type));
-			return false;
-		}
-	}
-
-	// Find restrictions list
-	SordIter* rs = sord_search(model, type, uris->owl_withRestrictions, 0, 0);
-	if (sord_iter_end(rs)) {
-		return true;  // No restrictions
-	}
-
-	// Walk list, checking each restriction
-	const SordNode* head = sord_iter_get_node(rs, SORD_OBJECT);
-	while (head) {
-		SordIter* f = sord_search(model, head, uris->rdf_first, 0, 0);
-		if (!f) {
-			break;  // Reached end of restrictions list without failure
-		}
-
-		// Check this restriction
-		const bool good = check_restriction(
-			model, uris, literal, type, sord_iter_get_node(f, SORD_OBJECT));
-		sord_iter_free(f);
-
-		if (!good) {
-			sord_iter_free(rs);
-			return false;  // Failed, literal is invalid
-		}
-
-		// Seek to next list node
-		SordIter* n = sord_search(model, head, uris->rdf_rest, 0, 0);
-		head = n ? sord_iter_get_node(n, SORD_OBJECT) : NULL;
-		sord_iter_free(n);
-	}
-
-	sord_iter_free(rs);
-
-	SordIter* s = sord_search(model, type, uris->owl_onDatatype, 0, 0);
-	if (s) {
-		const SordNode* super = sord_iter_get_node(s, SORD_OBJECT);
-		const bool      good  = literal_is_valid(
-			model, uris, quad, literal, super);
-		sord_iter_free(s);
-		return good;  // Match iff literal also matches supertype
-	}
-
-	return true;  // Matches top level type
+  if (!type) {
+    return true;
+  }
+
+  /* Check that literal data is related to required type.  We don't do a
+     strict subtype check here because e.g. an xsd:decimal might be a valid
+     xsd:unsignedInt, which the pattern checks will verify, but if the
+     literal type is not related to the required type at all
+     (e.g. xsd:decimal and xsd:string) there is a problem. */
+  const SordNode* datatype = sord_node_get_datatype(literal);
+  if (datatype && datatype != type) {
+    if (!is_descendant_of(model, uris, datatype, type, uris->owl_onDatatype) &&
+        !is_descendant_of(model, uris, type, datatype, uris->owl_onDatatype) &&
+        !(sord_node_equals(datatype, uris->xsd_decimal) &&
+          is_descendant_of(
+            model, uris, type, uris->xsd_double, uris->owl_onDatatype))) {
+      errorf(quad,
+             "Literal `%s' datatype <%s> is not compatible with <%s>\n",
+             sord_node_get_string(literal),
+             sord_node_get_string(datatype),
+             sord_node_get_string(type));
+      return false;
+    }
+  }
+
+  // Find restrictions list
+  SordIter* rs = sord_search(model, type, uris->owl_withRestrictions, 0, 0);
+  if (sord_iter_end(rs)) {
+    return true; // No restrictions
+  }
+
+  // Walk list, checking each restriction
+  const SordNode* head = sord_iter_get_node(rs, SORD_OBJECT);
+  while (head) {
+    SordIter* f = sord_search(model, head, uris->rdf_first, 0, 0);
+    if (!f) {
+      break; // Reached end of restrictions list without failure
+    }
+
+    // Check this restriction
+    const bool good = check_restriction(
+      model, uris, literal, type, sord_iter_get_node(f, SORD_OBJECT));
+    sord_iter_free(f);
+
+    if (!good) {
+      sord_iter_free(rs);
+      return false; // Failed, literal is invalid
+    }
+
+    // Seek to next list node
+    SordIter* n = sord_search(model, head, uris->rdf_rest, 0, 0);
+    head        = n ? sord_iter_get_node(n, SORD_OBJECT) : NULL;
+    sord_iter_free(n);
+  }
+
+  sord_iter_free(rs);
+
+  SordIter* s = sord_search(model, type, uris->owl_onDatatype, 0, 0);
+  if (s) {
+    const SordNode* super = sord_iter_get_node(s, SORD_OBJECT);
+    const bool      good  = literal_is_valid(model, uris, quad, literal, super);
+    sord_iter_free(s);
+    return good; // Match iff literal also matches supertype
+  }
+
+  return true; // Matches top level type
 }
 
 static bool
@@ -386,170 +384,168 @@ check_type(SordModel*      model,
            const SordNode* node,
            const SordNode* type)
 {
-	if (sord_node_equals(type, uris->rdfs_Resource) ||
-	    sord_node_equals(type, uris->owl_Thing)) {
-		return true;
-	}
-
-	if (sord_node_get_type(node) == SORD_LITERAL) {
-		if (sord_node_equals(type, uris->rdfs_Literal)) {
-			return true;
-		} else if (sord_node_equals(type, uris->rdf_PlainLiteral)) {
-			return !sord_node_get_language(node);
-		} else {
-			return literal_is_valid(model, uris, quad, node, type);
-		}
-	} else if (sord_node_get_type(node) == SORD_URI) {
-		if (sord_node_equals(type, uris->foaf_Document)) {
-			return true;  // Questionable...
-		} else if (is_descendant_of(
-			           model, uris,
-			           type, uris->xsd_anyURI, uris->owl_onDatatype)) {
-			/* Type is any URI and this is a URI, so pass.  Restrictions on
-			   anyURI subtypes are not currently checked (very uncommon). */
-			return true;  // Type is anyURI, and this is a URI
-		} else {
-			SordIter* t = sord_search(model, node, uris->rdf_type, NULL, NULL);
-			for (; !sord_iter_end(t); sord_iter_next(t)) {
-				if (is_descendant_of(model, uris,
-				                     sord_iter_get_node(t, SORD_OBJECT),
-				                     type,
-				                     uris->rdfs_subClassOf)) {
-					sord_iter_free(t);
-					return true;
-				}
-			}
-			sord_iter_free(t);
-			return false;
-		}
-	} else {
-		return true;  // Blanks often lack explicit types, ignore
-	}
-
-	return false;
+  if (sord_node_equals(type, uris->rdfs_Resource) ||
+      sord_node_equals(type, uris->owl_Thing)) {
+    return true;
+  }
+
+  if (sord_node_get_type(node) == SORD_LITERAL) {
+    if (sord_node_equals(type, uris->rdfs_Literal)) {
+      return true;
+    } else if (sord_node_equals(type, uris->rdf_PlainLiteral)) {
+      return !sord_node_get_language(node);
+    } else {
+      return literal_is_valid(model, uris, quad, node, type);
+    }
+  } else if (sord_node_get_type(node) == SORD_URI) {
+    if (sord_node_equals(type, uris->foaf_Document)) {
+      return true; // Questionable...
+    } else if (is_descendant_of(
+                 model, uris, type, uris->xsd_anyURI, uris->owl_onDatatype)) {
+      /* Type is any URI and this is a URI, so pass.  Restrictions on
+         anyURI subtypes are not currently checked (very uncommon). */
+      return true; // Type is anyURI, and this is a URI
+    } else {
+      SordIter* t = sord_search(model, node, uris->rdf_type, NULL, NULL);
+      for (; !sord_iter_end(t); sord_iter_next(t)) {
+        if (is_descendant_of(model,
+                             uris,
+                             sord_iter_get_node(t, SORD_OBJECT),
+                             type,
+                             uris->rdfs_subClassOf)) {
+          sord_iter_free(t);
+          return true;
+        }
+      }
+      sord_iter_free(t);
+      return false;
+    }
+  } else {
+    return true; // Blanks often lack explicit types, ignore
+  }
+
+  return false;
 }
 
 static uint64_t
 count_non_blanks(SordIter* i, SordQuadIndex field)
 {
-	uint64_t n = 0;
-	for (; !sord_iter_end(i); sord_iter_next(i)) {
-		const SordNode* node = sord_iter_get_node(i, field);
-		if (sord_node_get_type(node) != SORD_BLANK) {
-			++n;
-		}
-	}
-	return n;
+  uint64_t n = 0;
+  for (; !sord_iter_end(i); sord_iter_next(i)) {
+    const SordNode* node = sord_iter_get_node(i, field);
+    if (sord_node_get_type(node) != SORD_BLANK) {
+      ++n;
+    }
+  }
+  return n;
 }
 
 static int
 check_properties(SordModel* model, URIs* uris)
 {
-	int       st = 0;
-	SordIter* i  = sord_begin(model);
-	for (; !sord_iter_end(i); sord_iter_next(i)) {
-		SordQuad quad;
-		sord_iter_get(i, quad);
-
-		const SordNode* subj = quad[SORD_SUBJECT];
-		const SordNode* pred = quad[SORD_PREDICATE];
-		const SordNode* obj  = quad[SORD_OBJECT];
-
-		bool is_any_property = false;
-		SordIter* t = sord_search(model, pred, uris->rdf_type, NULL, NULL);
-		for (; !sord_iter_end(t); sord_iter_next(t)) {
-			if (is_descendant_of(model, uris,
-			                     sord_iter_get_node(t, SORD_OBJECT),
-			                     uris->rdf_Property,
-			                     uris->rdfs_subClassOf)) {
-				is_any_property = true;
-				break;
-			}
-		}
-		sord_iter_free(t);
-
-		const bool is_ObjectProperty = sord_ask(
-			model, pred, uris->rdf_type, uris->owl_ObjectProperty, 0);
-		const bool is_FunctionalProperty = sord_ask(
-			model, pred, uris->rdf_type, uris->owl_FunctionalProperty, 0);
-		const bool is_InverseFunctionalProperty = sord_ask(
-			model, pred, uris->rdf_type, uris->owl_InverseFunctionalProperty, 0);
-		const bool is_DatatypeProperty = sord_ask(
-			model, pred, uris->rdf_type, uris->owl_DatatypeProperty, 0);
-
-		if (!is_any_property) {
-			st = errorf(quad, "Use of undefined property");
-		}
-
-		if (!sord_ask(model, pred, uris->rdfs_label, NULL, NULL)) {
-			st = errorf(quad, "Property <%s> has no label",
-			            sord_node_get_string(pred));
-		}
-
-		if (is_DatatypeProperty &&
-		    sord_node_get_type(obj) != SORD_LITERAL) {
-			st = errorf(quad, "Datatype property with non-literal value");
-		}
-
-		if (is_ObjectProperty &&
-		    sord_node_get_type(obj) == SORD_LITERAL) {
-			st = errorf(quad, "Object property with literal value");
-		}
-
-		if (is_FunctionalProperty) {
-			SordIter*      o = sord_search(model, subj, pred, NULL, NULL);
-			const unsigned n = count_non_blanks(o, SORD_OBJECT);
-			if (n > 1) {
-				st = errorf(quad, "Functional property with %u objects", n);
-			}
-			sord_iter_free(o);
-		}
-
-		if (is_InverseFunctionalProperty) {
-			SordIter*      s = sord_search(model, NULL, pred, obj, NULL);
-			const unsigned n = count_non_blanks(s, SORD_SUBJECT);
-			if (n > 1) {
-				st = errorf(
-					quad, "Inverse functional property with %u subjects", n);
-			}
-			sord_iter_free(s);
-		}
-
-		if (sord_node_equals(pred, uris->rdf_type) &&
-		    !sord_ask(model, obj, uris->rdf_type, uris->rdfs_Class, NULL) &&
-		    !sord_ask(model, obj, uris->rdf_type, uris->owl_Class, NULL)) {
-			st = errorf(quad, "Type is not a rdfs:Class or owl:Class");
-		}
-
-		if (sord_node_get_type(obj) == SORD_LITERAL &&
-		    !literal_is_valid(model, uris, quad,
-		                      obj, sord_node_get_datatype(obj))) {
-			st = errorf(quad, "Literal does not match datatype");
-		}
-
-		SordIter* r = sord_search(model, pred, uris->rdfs_range, NULL, NULL);
-		for (; !sord_iter_end(r); sord_iter_next(r)) {
-			const SordNode* range = sord_iter_get_node(r, SORD_OBJECT);
-			if (!check_type(model, uris, quad, obj, range)) {
-				st = errorf(quad, "Object not in range <%s>\n",
-				            sord_node_get_string(range));
-			}
-		}
-		sord_iter_free(r);
-
-		SordIter* d = sord_search(model, pred, uris->rdfs_domain, NULL, NULL);
-		if (d) {
-			const SordNode* domain = sord_iter_get_node(d, SORD_OBJECT);
-			if (!check_type(model, uris, quad, subj, domain)) {
-				st = errorf(quad, "Subject not in domain <%s>",
-				            sord_node_get_string(domain));
-			}
-			sord_iter_free(d);
-		}
-	}
-	sord_iter_free(i);
-
-	return st;
+  int       st = 0;
+  SordIter* i  = sord_begin(model);
+  for (; !sord_iter_end(i); sord_iter_next(i)) {
+    SordQuad quad;
+    sord_iter_get(i, quad);
+
+    const SordNode* subj = quad[SORD_SUBJECT];
+    const SordNode* pred = quad[SORD_PREDICATE];
+    const SordNode* obj  = quad[SORD_OBJECT];
+
+    bool      is_any_property = false;
+    SordIter* t = sord_search(model, pred, uris->rdf_type, NULL, NULL);
+    for (; !sord_iter_end(t); sord_iter_next(t)) {
+      if (is_descendant_of(model,
+                           uris,
+                           sord_iter_get_node(t, SORD_OBJECT),
+                           uris->rdf_Property,
+                           uris->rdfs_subClassOf)) {
+        is_any_property = true;
+        break;
+      }
+    }
+    sord_iter_free(t);
+
+    const bool is_ObjectProperty =
+      sord_ask(model, pred, uris->rdf_type, uris->owl_ObjectProperty, 0);
+    const bool is_FunctionalProperty =
+      sord_ask(model, pred, uris->rdf_type, uris->owl_FunctionalProperty, 0);
+    const bool is_InverseFunctionalProperty = sord_ask(
+      model, pred, uris->rdf_type, uris->owl_InverseFunctionalProperty, 0);
+    const bool is_DatatypeProperty =
+      sord_ask(model, pred, uris->rdf_type, uris->owl_DatatypeProperty, 0);
+
+    if (!is_any_property) {
+      st = errorf(quad, "Use of undefined property");
+    }
+
+    if (!sord_ask(model, pred, uris->rdfs_label, NULL, NULL)) {
+      st =
+        errorf(quad, "Property <%s> has no label", sord_node_get_string(pred));
+    }
+
+    if (is_DatatypeProperty && sord_node_get_type(obj) != SORD_LITERAL) {
+      st = errorf(quad, "Datatype property with non-literal value");
+    }
+
+    if (is_ObjectProperty && sord_node_get_type(obj) == SORD_LITERAL) {
+      st = errorf(quad, "Object property with literal value");
+    }
+
+    if (is_FunctionalProperty) {
+      SordIter*      o = sord_search(model, subj, pred, NULL, NULL);
+      const unsigned n = count_non_blanks(o, SORD_OBJECT);
+      if (n > 1) {
+        st = errorf(quad, "Functional property with %u objects", n);
+      }
+      sord_iter_free(o);
+    }
+
+    if (is_InverseFunctionalProperty) {
+      SordIter*      s = sord_search(model, NULL, pred, obj, NULL);
+      const unsigned n = count_non_blanks(s, SORD_SUBJECT);
+      if (n > 1) {
+        st = errorf(quad, "Inverse functional property with %u subjects", n);
+      }
+      sord_iter_free(s);
+    }
+
+    if (sord_node_equals(pred, uris->rdf_type) &&
+        !sord_ask(model, obj, uris->rdf_type, uris->rdfs_Class, NULL) &&
+        !sord_ask(model, obj, uris->rdf_type, uris->owl_Class, NULL)) {
+      st = errorf(quad, "Type is not a rdfs:Class or owl:Class");
+    }
+
+    if (sord_node_get_type(obj) == SORD_LITERAL &&
+        !literal_is_valid(
+          model, uris, quad, obj, sord_node_get_datatype(obj))) {
+      st = errorf(quad, "Literal does not match datatype");
+    }
+
+    SordIter* r = sord_search(model, pred, uris->rdfs_range, NULL, NULL);
+    for (; !sord_iter_end(r); sord_iter_next(r)) {
+      const SordNode* range = sord_iter_get_node(r, SORD_OBJECT);
+      if (!check_type(model, uris, quad, obj, range)) {
+        st = errorf(
+          quad, "Object not in range <%s>\n", sord_node_get_string(range));
+      }
+    }
+    sord_iter_free(r);
+
+    SordIter* d = sord_search(model, pred, uris->rdfs_domain, NULL, NULL);
+    if (d) {
+      const SordNode* domain = sord_iter_get_node(d, SORD_OBJECT);
+      if (!check_type(model, uris, quad, subj, domain)) {
+        st = errorf(
+          quad, "Subject not in domain <%s>", sord_node_get_string(domain));
+      }
+      sord_iter_free(d);
+    }
+  }
+  sord_iter_free(i);
+
+  return st;
 }
 
 static int
@@ -558,82 +554,89 @@ check_instance(SordModel*      model,
                const SordNode* restriction,
                const SordQuad  quad)
 {
-	const SordNode* instance = quad[SORD_SUBJECT];
-	int             st       = 0;
-
-	const SordNode* prop = sord_get(
-		model, restriction, uris->owl_onProperty, NULL, NULL);
-	if (!prop) {
-		return 0;
-	}
-
-	const unsigned values = sord_count(model, instance, prop, NULL, NULL);
-
-	// Check exact cardinality
-	const SordNode* card = sord_get(
-		model, restriction, uris->owl_cardinality, NULL, NULL);
-	if (card) {
-		const unsigned c = atoi((const char*)sord_node_get_string(card));
-		if (values != c) {
-			st = errorf(quad, "Property %s on %s has %u != %u values",
-			            sord_node_get_string(prop),
-			            sord_node_get_string(instance),
-			            values, c);
-		}
-	}
-
-	// Check minimum cardinality
-	const SordNode* minCard = sord_get(
-		model, restriction, uris->owl_minCardinality, NULL, NULL);
-	if (minCard) {
-		const unsigned m = atoi((const char*)sord_node_get_string(minCard));
-		if (values < m) {
-			st = errorf(quad, "Property %s on %s has %u < %u values",
-			            sord_node_get_string(prop),
-			            sord_node_get_string(instance),
-			            values, m);
-		}
-	}
-
-	// Check maximum cardinality
-	const SordNode* maxCard = sord_get(
-		model, restriction, uris->owl_maxCardinality, NULL, NULL);
-	if (maxCard) {
-		const unsigned m = atoi((const char*)sord_node_get_string(maxCard));
-		if (values < m) {
-			st = errorf(quad, "Property %s on %s has %u > %u values",
-			            sord_node_get_string(prop),
-			            sord_node_get_string(instance),
-			            values, m);
-		}
-	}
-
-	// Check someValuesFrom
-	SordIter* sf = sord_search(
-		model, restriction, uris->owl_someValuesFrom, NULL, NULL);
-	if (sf) {
-		const SordNode* type = sord_iter_get_node(sf, SORD_OBJECT);
-
-		SordIter* v     = sord_search(model, instance, prop, NULL, NULL);
-		bool      found = false;
-		for (; !sord_iter_end(v); sord_iter_next(v)) {
-			const SordNode* value = sord_iter_get_node(v, SORD_OBJECT);
-			if (check_type(model, uris, quad, value, type)) {
-				found = true;
-				break;
-			}
-		}
-		if (!found) {
-			st = errorf(quad, "%s has no <%s> values of type <%s>\n",
-			            sord_node_get_string(instance),
-			            sord_node_get_string(prop),
-			            sord_node_get_string(type));
-		}
-		sord_iter_free(v);
-	}
-	sord_iter_free(sf);
-
-	return st;
+  const SordNode* instance = quad[SORD_SUBJECT];
+  int             st       = 0;
+
+  const SordNode* prop =
+    sord_get(model, restriction, uris->owl_onProperty, NULL, NULL);
+  if (!prop) {
+    return 0;
+  }
+
+  const unsigned values = sord_count(model, instance, prop, NULL, NULL);
+
+  // Check exact cardinality
+  const SordNode* card =
+    sord_get(model, restriction, uris->owl_cardinality, NULL, NULL);
+  if (card) {
+    const unsigned c = atoi((const char*)sord_node_get_string(card));
+    if (values != c) {
+      st = errorf(quad,
+                  "Property %s on %s has %u != %u values",
+                  sord_node_get_string(prop),
+                  sord_node_get_string(instance),
+                  values,
+                  c);
+    }
+  }
+
+  // Check minimum cardinality
+  const SordNode* minCard =
+    sord_get(model, restriction, uris->owl_minCardinality, NULL, NULL);
+  if (minCard) {
+    const unsigned m = atoi((const char*)sord_node_get_string(minCard));
+    if (values < m) {
+      st = errorf(quad,
+                  "Property %s on %s has %u < %u values",
+                  sord_node_get_string(prop),
+                  sord_node_get_string(instance),
+                  values,
+                  m);
+    }
+  }
+
+  // Check maximum cardinality
+  const SordNode* maxCard =
+    sord_get(model, restriction, uris->owl_maxCardinality, NULL, NULL);
+  if (maxCard) {
+    const unsigned m = atoi((const char*)sord_node_get_string(maxCard));
+    if (values < m) {
+      st = errorf(quad,
+                  "Property %s on %s has %u > %u values",
+                  sord_node_get_string(prop),
+                  sord_node_get_string(instance),
+                  values,
+                  m);
+    }
+  }
+
+  // Check someValuesFrom
+  SordIter* sf =
+    sord_search(model, restriction, uris->owl_someValuesFrom, NULL, NULL);
+  if (sf) {
+    const SordNode* type = sord_iter_get_node(sf, SORD_OBJECT);
+
+    SordIter* v     = sord_search(model, instance, prop, NULL, NULL);
+    bool      found = false;
+    for (; !sord_iter_end(v); sord_iter_next(v)) {
+      const SordNode* value = sord_iter_get_node(v, SORD_OBJECT);
+      if (check_type(model, uris, quad, value, type)) {
+        found = true;
+        break;
+      }
+    }
+    if (!found) {
+      st = errorf(quad,
+                  "%s has no <%s> values of type <%s>\n",
+                  sord_node_get_string(instance),
+                  sord_node_get_string(prop),
+                  sord_node_get_string(type));
+    }
+    sord_iter_free(v);
+  }
+  sord_iter_free(sf);
+
+  return st;
 }
 
 static int
@@ -642,158 +645,159 @@ check_class_instances(SordModel*      model,
                       const SordNode* restriction,
                       const SordNode* klass)
 {
-	// Check immediate instances of this class
-	SordIter* i = sord_search(model, NULL, uris->rdf_type, klass, NULL);
-	for (; !sord_iter_end(i); sord_iter_next(i)) {
-		SordQuad quad;
-		sord_iter_get(i, quad);
-		check_instance(model, uris, restriction, quad);
-	}
-	sord_iter_free(i);
-
-	// Check instances of all subclasses recursively
-	SordIter* s = sord_search(model, NULL, uris->rdfs_subClassOf, klass, NULL);
-	for (; !sord_iter_end(s); sord_iter_next(s)) {
-		const SordNode* subklass = sord_iter_get_node(s, SORD_SUBJECT);
-		check_class_instances(model, uris, restriction, subklass);
-	}
-	sord_iter_free(s);
-
-	return 0;
+  // Check immediate instances of this class
+  SordIter* i = sord_search(model, NULL, uris->rdf_type, klass, NULL);
+  for (; !sord_iter_end(i); sord_iter_next(i)) {
+    SordQuad quad;
+    sord_iter_get(i, quad);
+    check_instance(model, uris, restriction, quad);
+  }
+  sord_iter_free(i);
+
+  // Check instances of all subclasses recursively
+  SordIter* s = sord_search(model, NULL, uris->rdfs_subClassOf, klass, NULL);
+  for (; !sord_iter_end(s); sord_iter_next(s)) {
+    const SordNode* subklass = sord_iter_get_node(s, SORD_SUBJECT);
+    check_class_instances(model, uris, restriction, subklass);
+  }
+  sord_iter_free(s);
+
+  return 0;
 }
 
 static int
 check_instances(SordModel* model, const URIs* uris)
 {
-	int       st = 0;
-	SordIter* r = sord_search(
-		model, NULL, uris->rdf_type, uris->owl_Restriction, NULL);
-	for (; !sord_iter_end(r); sord_iter_next(r)) {
-		const SordNode* restriction = sord_iter_get_node(r, SORD_SUBJECT);
-		const SordNode* prop        = sord_get(
-			model, restriction, uris->owl_onProperty, NULL, NULL);
-		if (!prop) {
-			continue;
-		}
-
-		SordIter* c = sord_search(
-			model, NULL, uris->rdfs_subClassOf, restriction, NULL);
-		for (; !sord_iter_end(c); sord_iter_next(c)) {
-			const SordNode* klass = sord_iter_get_node(c, SORD_SUBJECT);
-			check_class_instances(model, uris, restriction, klass);
-		}
-		sord_iter_free(c);
-	}
-	sord_iter_free(r);
-
-	return st;
+  int       st = 0;
+  SordIter* r =
+    sord_search(model, NULL, uris->rdf_type, uris->owl_Restriction, NULL);
+  for (; !sord_iter_end(r); sord_iter_next(r)) {
+    const SordNode* restriction = sord_iter_get_node(r, SORD_SUBJECT);
+    const SordNode* prop =
+      sord_get(model, restriction, uris->owl_onProperty, NULL, NULL);
+    if (!prop) {
+      continue;
+    }
+
+    SordIter* c =
+      sord_search(model, NULL, uris->rdfs_subClassOf, restriction, NULL);
+    for (; !sord_iter_end(c); sord_iter_next(c)) {
+      const SordNode* klass = sord_iter_get_node(c, SORD_SUBJECT);
+      check_class_instances(model, uris, restriction, klass);
+    }
+    sord_iter_free(c);
+  }
+  sord_iter_free(r);
+
+  return st;
 }
 
 int
 main(int argc, char** argv)
 {
-	if (argc < 2) {
-		return print_usage(argv[0], true);
-	}
-
-	int a = 1;
-	for (; a < argc && argv[a][0] == '-'; ++a) {
-		if (argv[a][1] == 'l') {
-			one_line_errors = true;
-		} else if (argv[a][1] == 'v') {
-			return print_version();
-		} else {
-			fprintf(stderr, "%s: Unknown option `%s'\n", argv[0], argv[a]);
-			return print_usage(argv[0], true);
-		}
-	}
-
-	SordWorld*  world  = sord_world_new();
-	SordModel*  model  = sord_new(world, SORD_SPO|SORD_OPS, false);
-	SerdEnv*    env    = serd_env_new(&SERD_NODE_NULL);
-	SerdReader* reader = sord_new_reader(model, env, SERD_TURTLE, NULL);
-
-	for (; a < argc; ++a) {
-		const uint8_t* input       = (const uint8_t*)argv[a];
-		uint8_t*       rel_in_path = serd_file_uri_parse(input, NULL);
-		uint8_t*       in_path     = absolute_path(rel_in_path);
-
-		free(rel_in_path);
-		if (!in_path) {
-			fprintf(stderr, "Skipping file %s\n", input);
-			continue;
-		}
-
-		SerdURI  base_uri;
-		SerdNode base_uri_node = serd_node_new_file_uri(
-			in_path, NULL, &base_uri, true);
-
-		serd_env_set_base_uri(env, &base_uri_node);
-		const SerdStatus st = serd_reader_read_file(reader, in_path);
-		if (st) {
-			fprintf(stderr, "error reading %s: %s\n",
-			        in_path, serd_strerror(st));
-		}
-
-		serd_node_free(&base_uri_node);
-		free(in_path);
-	}
-	serd_reader_free(reader);
-	serd_env_free(env);
+  if (argc < 2) {
+    return print_usage(argv[0], true);
+  }
+
+  int a = 1;
+  for (; a < argc && argv[a][0] == '-'; ++a) {
+    if (argv[a][1] == 'l') {
+      one_line_errors = true;
+    } else if (argv[a][1] == 'v') {
+      return print_version();
+    } else {
+      fprintf(stderr, "%s: Unknown option `%s'\n", argv[0], argv[a]);
+      return print_usage(argv[0], true);
+    }
+  }
+
+  SordWorld*  world  = sord_world_new();
+  SordModel*  model  = sord_new(world, SORD_SPO | SORD_OPS, false);
+  SerdEnv*    env    = serd_env_new(&SERD_NODE_NULL);
+  SerdReader* reader = sord_new_reader(model, env, SERD_TURTLE, NULL);
+
+  for (; a < argc; ++a) {
+    const uint8_t* input       = (const uint8_t*)argv[a];
+    uint8_t*       rel_in_path = serd_file_uri_parse(input, NULL);
+    uint8_t*       in_path     = absolute_path(rel_in_path);
+
+    free(rel_in_path);
+    if (!in_path) {
+      fprintf(stderr, "Skipping file %s\n", input);
+      continue;
+    }
+
+    SerdURI  base_uri;
+    SerdNode base_uri_node =
+      serd_node_new_file_uri(in_path, NULL, &base_uri, true);
+
+    serd_env_set_base_uri(env, &base_uri_node);
+    const SerdStatus st = serd_reader_read_file(reader, in_path);
+    if (st) {
+      fprintf(stderr, "error reading %s: %s\n", in_path, serd_strerror(st));
+    }
+
+    serd_node_free(&base_uri_node);
+    free(in_path);
+  }
+  serd_reader_free(reader);
+  serd_env_free(env);
 
 #define URI(prefix, suffix) \
-	uris.prefix##_##suffix = sord_new_uri(world, NS_##prefix #suffix)
-
-	URIs uris;
-	URI(foaf, Document);
-	URI(owl, AnnotationProperty);
-	URI(owl, Class);
-	URI(owl, DatatypeProperty);
-	URI(owl, FunctionalProperty);
-	URI(owl, InverseFunctionalProperty);
-	URI(owl, ObjectProperty);
-	URI(owl, OntologyProperty);
-	URI(owl, Restriction);
-	URI(owl, Thing);
-	URI(owl, cardinality);
-	URI(owl, equivalentClass);
-	URI(owl, maxCardinality);
-	URI(owl, minCardinality);
-	URI(owl, onDatatype);
-	URI(owl, onProperty);
-	URI(owl, someValuesFrom);
-	URI(owl, withRestrictions);
-	URI(rdf, PlainLiteral);
-	URI(rdf, Property);
-	URI(rdf, first);
-	URI(rdf, rest);
-	URI(rdf, type);
-	URI(rdfs, Class);
-	URI(rdfs, Literal);
-	URI(rdfs, Resource);
-	URI(rdfs, domain);
-	URI(rdfs, label);
-	URI(rdfs, range);
-	URI(rdfs, subClassOf);
-	URI(xsd, anyURI);
-	URI(xsd, decimal);
-	URI(xsd, double);
-	URI(xsd, maxInclusive);
-	URI(xsd, minInclusive);
-	URI(xsd, pattern);
-	URI(xsd, string);
+  uris.prefix##_##suffix = sord_new_uri(world, NS_##prefix #suffix)
+
+  URIs uris;
+  URI(foaf, Document);
+  URI(owl, AnnotationProperty);
+  URI(owl, Class);
+  URI(owl, DatatypeProperty);
+  URI(owl, FunctionalProperty);
+  URI(owl, InverseFunctionalProperty);
+  URI(owl, ObjectProperty);
+  URI(owl, OntologyProperty);
+  URI(owl, Restriction);
+  URI(owl, Thing);
+  URI(owl, cardinality);
+  URI(owl, equivalentClass);
+  URI(owl, maxCardinality);
+  URI(owl, minCardinality);
+  URI(owl, onDatatype);
+  URI(owl, onProperty);
+  URI(owl, someValuesFrom);
+  URI(owl, withRestrictions);
+  URI(rdf, PlainLiteral);
+  URI(rdf, Property);
+  URI(rdf, first);
+  URI(rdf, rest);
+  URI(rdf, type);
+  URI(rdfs, Class);
+  URI(rdfs, Literal);
+  URI(rdfs, Resource);
+  URI(rdfs, domain);
+  URI(rdfs, label);
+  URI(rdfs, range);
+  URI(rdfs, subClassOf);
+  URI(xsd, anyURI);
+  URI(xsd, decimal);
+  URI(xsd, double);
+  URI(xsd, maxInclusive);
+  URI(xsd, minInclusive);
+  URI(xsd, pattern);
+  URI(xsd, string);
 
 #ifndef HAVE_PCRE
-	fprintf(stderr, "warning: Built without PCRE, datatypes not checked.\n");
+  fprintf(stderr, "warning: Built without PCRE, datatypes not checked.\n");
 #endif
 
-	const int prop_st = check_properties(model, &uris);
-	const int inst_st = check_instances(model, &uris);
+  const int prop_st = check_properties(model, &uris);
+  const int inst_st = check_instances(model, &uris);
 
-	printf("Found %d errors among %d files (checked %d restrictions)\n",
-	       n_errors, argc - 1, n_restrictions);
+  printf("Found %d errors among %d files (checked %d restrictions)\n",
+         n_errors,
+         argc - 1,
+         n_restrictions);
 
-	sord_free(model);
-	sord_world_free(world);
-	return prop_st || inst_st;
+  sord_free(model);
+  sord_world_free(world);
+  return prop_st || inst_st;
 }
diff --git a/src/sordi.c b/src/sordi.c
index 3a68fa7..c038dbb 100644
--- a/src/sordi.c
+++ b/src/sordi.c
@@ -19,7 +19,7 @@
 #include "sord_config.h"
 
 #ifdef _WIN32
-#    include <windows.h>
+#  include <windows.h>
 #endif
 
 #include <stdbool.h>
@@ -28,189 +28,189 @@
 #include <stdlib.h>
 #include <string.h>
 
-#define SORDI_ERROR(msg)       fprintf(stderr, "sordi: " msg)
+#define SORDI_ERROR(msg) fprintf(stderr, "sordi: " msg)
 #define SORDI_ERRORF(fmt, ...) fprintf(stderr, "sordi: " fmt, __VA_ARGS__)
 
 typedef struct {
-	SerdWriter* writer;
-	SerdEnv*    env;
-	SerdNode    base_uri_node;
-	SerdURI     base_uri;
-	SordModel*  sord;
+  SerdWriter* writer;
+  SerdEnv*    env;
+  SerdNode    base_uri_node;
+  SerdURI     base_uri;
+  SordModel*  sord;
 } State;
 
 static int
 print_version(void)
 {
-	printf("sordi " SORD_VERSION " <http://drobilla.net/software/sord>\n");
-	printf("Copyright 2011-2016 David Robillard <http://drobilla.net>.\n"
-	       "License: <http://www.opensource.org/licenses/isc>\n"
-	       "This is free software; you are free to change and redistribute it."
-	       "\nThere is NO WARRANTY, to the extent permitted by law.\n");
-	return 0;
+  printf("sordi " SORD_VERSION " <http://drobilla.net/software/sord>\n");
+  printf("Copyright 2011-2016 David Robillard <http://drobilla.net>.\n"
+         "License: <http://www.opensource.org/licenses/isc>\n"
+         "This is free software; you are free to change and redistribute it."
+         "\nThere is NO WARRANTY, to the extent permitted by law.\n");
+  return 0;
 }
 
 static int
 print_usage(const char* name, bool error)
 {
-	FILE* const os = error ? stderr : stdout;
-	fprintf(os, "%s", error ? "\n" : "");
-	fprintf(os, "Usage: %s [OPTION]... INPUT [BASE_URI]\n", name);
-	fprintf(os, "Load and re-serialise RDF data.\n");
-	fprintf(os, "Use - for INPUT to read from standard input.\n\n");
-	fprintf(os, "  -h           Display this help and exit\n");
-	fprintf(os, "  -i SYNTAX    Input syntax (`turtle' or `ntriples')\n");
-	fprintf(os, "  -o SYNTAX    Output syntax (`turtle' or `ntriples')\n");
-	fprintf(os, "  -s INPUT     Parse INPUT as string (terminates options)\n");
-	fprintf(os, "  -v           Display version information and exit\n");
-	return error ? 1 : 0;
+  FILE* const os = error ? stderr : stdout;
+  fprintf(os, "%s", error ? "\n" : "");
+  fprintf(os, "Usage: %s [OPTION]... INPUT [BASE_URI]\n", name);
+  fprintf(os, "Load and re-serialise RDF data.\n");
+  fprintf(os, "Use - for INPUT to read from standard input.\n\n");
+  fprintf(os, "  -h           Display this help and exit\n");
+  fprintf(os, "  -i SYNTAX    Input syntax (`turtle' or `ntriples')\n");
+  fprintf(os, "  -o SYNTAX    Output syntax (`turtle' or `ntriples')\n");
+  fprintf(os, "  -s INPUT     Parse INPUT as string (terminates options)\n");
+  fprintf(os, "  -v           Display version information and exit\n");
+  return error ? 1 : 0;
 }
 
 static bool
 set_syntax(SerdSyntax* syntax, const char* name)
 {
-	if (!strcmp(name, "turtle")) {
-		*syntax = SERD_TURTLE;
-	} else if (!strcmp(name, "ntriples")) {
-		*syntax = SERD_NTRIPLES;
-	} else {
-		SORDI_ERRORF("unknown syntax `%s'\n", name);
-		return false;
-	}
-	return true;
+  if (!strcmp(name, "turtle")) {
+    *syntax = SERD_TURTLE;
+  } else if (!strcmp(name, "ntriples")) {
+    *syntax = SERD_NTRIPLES;
+  } else {
+    SORDI_ERRORF("unknown syntax `%s'\n", name);
+    return false;
+  }
+  return true;
 }
 
 int
 main(int argc, char** argv)
 {
-	if (argc < 2) {
-		return print_usage(argv[0], true);
-	}
-
-	FILE*          in_fd         = NULL;
-	SerdSyntax     input_syntax  = SERD_TURTLE;
-	SerdSyntax     output_syntax = SERD_NTRIPLES;
-	bool           from_file     = true;
-	const uint8_t* in_name       = NULL;
-	int a = 1;
-	for (; a < argc && argv[a][0] == '-'; ++a) {
-		if (argv[a][1] == '\0') {
-			in_name = (const uint8_t*)"(stdin)";
-			in_fd   = stdin;
-			break;
-		} else if (argv[a][1] == 'h') {
-			return print_usage(argv[0], false);
-		} else if (argv[a][1] == 'v') {
-			return print_version();
-		} else if (argv[a][1] == 's') {
-			in_name = (const uint8_t*)"(string)";
-			from_file = false;
-			++a;
-			break;
-		} else if (argv[a][1] == 'i') {
-			if (++a == argc) {
-				SORDI_ERROR("option requires an argument -- 'i'\n\n");
-				return print_usage(argv[0], true);
-			}
-			if (!set_syntax(&input_syntax, argv[a])) {
-				return print_usage(argv[0], true);
-			}
-		} else if (argv[a][1] == 'o') {
-			if (++a == argc) {
-				SORDI_ERROR("option requires an argument -- 'o'\n\n");
-				return print_usage(argv[0], true);
-			}
-			if (!set_syntax(&output_syntax, argv[a])) {
-				return print_usage(argv[0], true);
-			}
-		} else {
-			SORDI_ERRORF("invalid option -- '%s'\n", argv[a] + 1);
-			return print_usage(argv[0], true);
-		}
-	}
-
-	if (a == argc) {
-		SORDI_ERROR("missing input\n");
-		return print_usage(argv[0], true);
-	}
-
-	uint8_t*       input_path = NULL;
-	const uint8_t* input      = (const uint8_t*)argv[a++];
-	if (from_file) {
-		in_name = in_name ? in_name : input;
-		if (!in_fd) {
-			if (!strncmp((const char*)input, "file:", 5)) {
-				input_path = serd_file_uri_parse(input, NULL);
-				input      = input_path;
-			}
-			if (!input || !(in_fd = fopen((const char*)input, "rb"))) {
-				return 1;
-			}
-		}
-	}
-
-	SerdURI  base_uri = SERD_URI_NULL;
-	SerdNode base     = SERD_NODE_NULL;
-	if (a < argc) {  // Base URI given on command line
-		base = serd_node_new_uri_from_string(
-			(const uint8_t*)argv[a], NULL, &base_uri);
-	} else if (from_file && in_fd != stdin) {  // Use input file URI
-		base = serd_node_new_file_uri(input, NULL, &base_uri, true);
-	}
-
-	SordWorld*  world  = sord_world_new();
-	SordModel*  sord   = sord_new(world, SORD_SPO|SORD_OPS, false);
-	SerdEnv*    env    = serd_env_new(&base);
-	SerdReader* reader = sord_new_reader(sord, env, input_syntax, NULL);
-
-	SerdStatus status = (from_file)
-		? serd_reader_read_file_handle(reader, in_fd, in_name)
-		: serd_reader_read_string(reader, input);
-
-	serd_reader_free(reader);
-
-	FILE*    out_fd    = stdout;
-	SerdEnv* write_env = serd_env_new(&base);
-
-	int output_style = SERD_STYLE_RESOLVED;
-	if (output_syntax == SERD_NTRIPLES) {
-		output_style |= SERD_STYLE_ASCII;
-	} else {
-		output_style |= SERD_STYLE_CURIED | SERD_STYLE_ABBREVIATED;
-	}
-
-	SerdWriter* writer = serd_writer_new(
-		output_syntax,
-		(SerdStyle)output_style,
-		write_env, &base_uri, serd_file_sink, stdout);
-
-	// Write @prefix directives
-	serd_env_foreach(env,
-	                 (SerdPrefixSink)serd_writer_set_prefix,
-	                 writer);
-
-	// Write statements
-	sord_write(sord, writer, NULL);
-
-	serd_writer_finish(writer);
-	serd_writer_free(writer);
-
-	serd_env_free(env);
-	serd_env_free(write_env);
-	serd_node_free(&base);
-	free(input_path);
-
-	sord_free(sord);
-	sord_world_free(world);
-
-	if (from_file) {
-		fclose(in_fd);
-	}
-
-	if (fclose(out_fd)) {
-		perror("sordi: write error");
-		status = SERD_ERR_UNKNOWN;
-	}
-
-	return (status > SERD_FAILURE) ? 1 : 0;
+  if (argc < 2) {
+    return print_usage(argv[0], true);
+  }
+
+  FILE*          in_fd         = NULL;
+  SerdSyntax     input_syntax  = SERD_TURTLE;
+  SerdSyntax     output_syntax = SERD_NTRIPLES;
+  bool           from_file     = true;
+  const uint8_t* in_name       = NULL;
+  int            a             = 1;
+  for (; a < argc && argv[a][0] == '-'; ++a) {
+    if (argv[a][1] == '\0') {
+      in_name = (const uint8_t*)"(stdin)";
+      in_fd   = stdin;
+      break;
+    } else if (argv[a][1] == 'h') {
+      return print_usage(argv[0], false);
+    } else if (argv[a][1] == 'v') {
+      return print_version();
+    } else if (argv[a][1] == 's') {
+      in_name   = (const uint8_t*)"(string)";
+      from_file = false;
+      ++a;
+      break;
+    } else if (argv[a][1] == 'i') {
+      if (++a == argc) {
+        SORDI_ERROR("option requires an argument -- 'i'\n\n");
+        return print_usage(argv[0], true);
+      }
+      if (!set_syntax(&input_syntax, argv[a])) {
+        return print_usage(argv[0], true);
+      }
+    } else if (argv[a][1] == 'o') {
+      if (++a == argc) {
+        SORDI_ERROR("option requires an argument -- 'o'\n\n");
+        return print_usage(argv[0], true);
+      }
+      if (!set_syntax(&output_syntax, argv[a])) {
+        return print_usage(argv[0], true);
+      }
+    } else {
+      SORDI_ERRORF("invalid option -- '%s'\n", argv[a] + 1);
+      return print_usage(argv[0], true);
+    }
+  }
+
+  if (a == argc) {
+    SORDI_ERROR("missing input\n");
+    return print_usage(argv[0], true);
+  }
+
+  uint8_t*       input_path = NULL;
+  const uint8_t* input      = (const uint8_t*)argv[a++];
+  if (from_file) {
+    in_name = in_name ? in_name : input;
+    if (!in_fd) {
+      if (!strncmp((const char*)input, "file:", 5)) {
+        input_path = serd_file_uri_parse(input, NULL);
+        input      = input_path;
+      }
+      if (!input || !(in_fd = fopen((const char*)input, "rb"))) {
+        return 1;
+      }
+    }
+  }
+
+  SerdURI  base_uri = SERD_URI_NULL;
+  SerdNode base     = SERD_NODE_NULL;
+  if (a < argc) { // Base URI given on command line
+    base =
+      serd_node_new_uri_from_string((const uint8_t*)argv[a], NULL, &base_uri);
+  } else if (from_file && in_fd != stdin) { // Use input file URI
+    base = serd_node_new_file_uri(input, NULL, &base_uri, true);
+  }
+
+  SordWorld*  world  = sord_world_new();
+  SordModel*  sord   = sord_new(world, SORD_SPO | SORD_OPS, false);
+  SerdEnv*    env    = serd_env_new(&base);
+  SerdReader* reader = sord_new_reader(sord, env, input_syntax, NULL);
+
+  SerdStatus status = (from_file)
+                        ? serd_reader_read_file_handle(reader, in_fd, in_name)
+                        : serd_reader_read_string(reader, input);
+
+  serd_reader_free(reader);
+
+  FILE*    out_fd    = stdout;
+  SerdEnv* write_env = serd_env_new(&base);
+
+  int output_style = SERD_STYLE_RESOLVED;
+  if (output_syntax == SERD_NTRIPLES) {
+    output_style |= SERD_STYLE_ASCII;
+  } else {
+    output_style |= SERD_STYLE_CURIED | SERD_STYLE_ABBREVIATED;
+  }
+
+  SerdWriter* writer = serd_writer_new(output_syntax,
+                                       (SerdStyle)output_style,
+                                       write_env,
+                                       &base_uri,
+                                       serd_file_sink,
+                                       stdout);
+
+  // Write @prefix directives
+  serd_env_foreach(env, (SerdPrefixSink)serd_writer_set_prefix, writer);
+
+  // Write statements
+  sord_write(sord, writer, NULL);
+
+  serd_writer_finish(writer);
+  serd_writer_free(writer);
+
+  serd_env_free(env);
+  serd_env_free(write_env);
+  serd_node_free(&base);
+  free(input_path);
+
+  sord_free(sord);
+  sord_world_free(world);
+
+  if (from_file) {
+    fclose(in_fd);
+  }
+
+  if (fclose(out_fd)) {
+    perror("sordi: write error");
+    status = SERD_ERR_UNKNOWN;
+  }
+
+  return (status > SERD_FAILURE) ? 1 : 0;
 }
diff --git a/src/sordmm_test.cpp b/src/sordmm_test.cpp
index 8dc1386..3d09b9d 100644
--- a/src/sordmm_test.cpp
+++ b/src/sordmm_test.cpp
@@ -19,7 +19,7 @@
 int
 main()
 {
-	Sord::World world;
-	Sord::Model model(world, "http://example.org/");
-	return 0;
+  Sord::World world;
+  Sord::Model model(world, "http://example.org/");
+  return 0;
 }
diff --git a/src/syntax.c b/src/syntax.c
index 1561c1d..6ed868f 100644
--- a/src/syntax.c
+++ b/src/syntax.c
@@ -23,31 +23,29 @@
 #include <string.h>
 
 struct SordInserterImpl {
-	SordModel* model;
-	SerdEnv*   env;
+  SordModel* model;
+  SerdEnv*   env;
 };
 
 SordInserter*
-sord_inserter_new(SordModel* model,
-                  SerdEnv*   env)
+sord_inserter_new(SordModel* model, SerdEnv* env)
 {
-	SordInserter* inserter = (SordInserter*)malloc(sizeof(SordInserter));
-	inserter->model = model;
-	inserter->env   = env;
-	return inserter;
+  SordInserter* inserter = (SordInserter*)malloc(sizeof(SordInserter));
+  inserter->model        = model;
+  inserter->env          = env;
+  return inserter;
 }
 
 void
 sord_inserter_free(SordInserter* inserter)
 {
-	free(inserter);
+  free(inserter);
 }
 
 SerdStatus
-sord_inserter_set_base_uri(SordInserter*   inserter,
-                           const SerdNode* uri)
+sord_inserter_set_base_uri(SordInserter* inserter, const SerdNode* uri)
 {
-	return serd_env_set_base_uri(inserter->env, uri);
+  return serd_env_set_base_uri(inserter->env, uri);
 }
 
 SerdStatus
@@ -55,7 +53,7 @@ sord_inserter_set_prefix(SordInserter*   inserter,
                          const SerdNode* name,
                          const SerdNode* uri)
 {
-	return serd_env_set_prefix(inserter->env, name, uri);
+  return serd_env_set_prefix(inserter->env, name, uri);
 }
 
 SerdStatus
@@ -68,28 +66,28 @@ sord_inserter_write_statement(SordInserter*      inserter,
                               const SerdNode*    object_datatype,
                               const SerdNode*    object_lang)
 {
-	SordWorld* world = sord_get_world(inserter->model);
-	SerdEnv*   env   = inserter->env;
+  SordWorld* world = sord_get_world(inserter->model);
+  SerdEnv*   env   = inserter->env;
 
-	SordNode* g = sord_node_from_serd_node(world, env, graph, NULL, NULL);
-	SordNode* s = sord_node_from_serd_node(world, env, subject, NULL, NULL);
-	SordNode* p = sord_node_from_serd_node(world, env, predicate, NULL, NULL);
-	SordNode* o = sord_node_from_serd_node(world, env, object,
-	                                       object_datatype, object_lang);
+  SordNode* g = sord_node_from_serd_node(world, env, graph, NULL, NULL);
+  SordNode* s = sord_node_from_serd_node(world, env, subject, NULL, NULL);
+  SordNode* p = sord_node_from_serd_node(world, env, predicate, NULL, NULL);
+  SordNode* o =
+    sord_node_from_serd_node(world, env, object, object_datatype, object_lang);
 
-	if (!s || !p || !o) {
-		return SERD_ERR_BAD_ARG;
-	}
+  if (!s || !p || !o) {
+    return SERD_ERR_BAD_ARG;
+  }
 
-	const SordQuad tup = { s, p, o, g };
-	sord_add(inserter->model, tup);
+  const SordQuad tup = {s, p, o, g};
+  sord_add(inserter->model, tup);
 
-	sord_node_free(world, o);
-	sord_node_free(world, p);
-	sord_node_free(world, s);
-	sord_node_free(world, g);
+  sord_node_free(world, o);
+  sord_node_free(world, p);
+  sord_node_free(world, s);
+  sord_node_free(world, g);
 
-	return SERD_SUCCESS;
+  return SERD_SUCCESS;
 }
 
 SORD_API
@@ -99,20 +97,22 @@ sord_new_reader(SordModel* model,
                 SerdSyntax syntax,
                 SordNode*  graph)
 {
-	SordInserter* inserter = sord_inserter_new(model, env);
-
-	SerdReader* reader = serd_reader_new(
-		syntax, inserter, (void (*)(void* ptr))sord_inserter_free,
-		(SerdBaseSink)sord_inserter_set_base_uri,
-		(SerdPrefixSink)sord_inserter_set_prefix,
-		(SerdStatementSink)sord_inserter_write_statement,
-		NULL);
-
-	if (graph) {
-		serd_reader_set_default_graph(reader, sord_node_to_serd_node(graph));
-	}
-
-	return reader;
+  SordInserter* inserter = sord_inserter_new(model, env);
+
+  SerdReader* reader =
+    serd_reader_new(syntax,
+                    inserter,
+                    (void (*)(void* ptr))sord_inserter_free,
+                    (SerdBaseSink)sord_inserter_set_base_uri,
+                    (SerdPrefixSink)sord_inserter_set_prefix,
+                    (SerdStatementSink)sord_inserter_write_statement,
+                    NULL);
+
+  if (graph) {
+    serd_reader_set_default_graph(reader, sord_node_to_serd_node(graph));
+  }
+
+  return reader;
 }
 
 static SerdStatus
@@ -121,86 +121,83 @@ write_statement(SordModel*         sord,
                 SordQuad           tup,
                 SerdStatementFlags flags)
 {
-	const SordNode* s  = tup[SORD_SUBJECT];
-	const SordNode* p  = tup[SORD_PREDICATE];
-	const SordNode* o  = tup[SORD_OBJECT];
-	const SordNode* d  = sord_node_get_datatype(o);
-	const SerdNode* ss = sord_node_to_serd_node(s);
-	const SerdNode* sp = sord_node_to_serd_node(p);
-	const SerdNode* so = sord_node_to_serd_node(o);
-	const SerdNode* sd = sord_node_to_serd_node(d);
-
-	const char* lang_str = sord_node_get_language(o);
-	size_t      lang_len = lang_str ? strlen(lang_str) : 0;
-	SerdNode    language = SERD_NODE_NULL;
-	if (lang_str) {
-		language.type    = SERD_LITERAL;
-		language.n_bytes = lang_len;
-		language.n_chars = lang_len;
-		language.buf     = (const uint8_t*)lang_str;
-	}
-
-	// TODO: Subject abbreviation
-
-	if (sord_node_is_inline_object(s) && !(flags & SERD_ANON_CONT)) {
-		return SERD_SUCCESS;
-	}
-
-	SerdStatus st = SERD_SUCCESS;
-	if (sord_node_is_inline_object(o)) {
-		SordQuad  sub_pat  = { o, 0, 0, 0 };
-		SordIter* sub_iter = sord_find(sord, sub_pat);
-
-		SerdStatementFlags start_flags = flags
-			| ((sub_iter) ? SERD_ANON_O_BEGIN : SERD_EMPTY_O);
-
-		st = serd_writer_write_statement(
-			writer, start_flags, NULL, ss, sp, so, sd, &language);
-
-		if (!st && sub_iter) {
-			flags |= SERD_ANON_CONT;
-			for (; !st && !sord_iter_end(sub_iter); sord_iter_next(sub_iter)) {
-				SordQuad sub_tup;
-				sord_iter_get(sub_iter, sub_tup);
-				st = write_statement(sord, writer, sub_tup, flags);
-			}
-			sord_iter_free(sub_iter);
-			serd_writer_end_anon(writer, so);
-		}
-	} else {
-		st = serd_writer_write_statement(
-			writer, flags, NULL, ss, sp, so, sd, &language);
-	}
-
-	return st;
+  const SordNode* s  = tup[SORD_SUBJECT];
+  const SordNode* p  = tup[SORD_PREDICATE];
+  const SordNode* o  = tup[SORD_OBJECT];
+  const SordNode* d  = sord_node_get_datatype(o);
+  const SerdNode* ss = sord_node_to_serd_node(s);
+  const SerdNode* sp = sord_node_to_serd_node(p);
+  const SerdNode* so = sord_node_to_serd_node(o);
+  const SerdNode* sd = sord_node_to_serd_node(d);
+
+  const char* lang_str = sord_node_get_language(o);
+  size_t      lang_len = lang_str ? strlen(lang_str) : 0;
+  SerdNode    language = SERD_NODE_NULL;
+  if (lang_str) {
+    language.type    = SERD_LITERAL;
+    language.n_bytes = lang_len;
+    language.n_chars = lang_len;
+    language.buf     = (const uint8_t*)lang_str;
+  }
+
+  // TODO: Subject abbreviation
+
+  if (sord_node_is_inline_object(s) && !(flags & SERD_ANON_CONT)) {
+    return SERD_SUCCESS;
+  }
+
+  SerdStatus st = SERD_SUCCESS;
+  if (sord_node_is_inline_object(o)) {
+    SordQuad  sub_pat  = {o, 0, 0, 0};
+    SordIter* sub_iter = sord_find(sord, sub_pat);
+
+    SerdStatementFlags start_flags =
+      flags | ((sub_iter) ? SERD_ANON_O_BEGIN : SERD_EMPTY_O);
+
+    st = serd_writer_write_statement(
+      writer, start_flags, NULL, ss, sp, so, sd, &language);
+
+    if (!st && sub_iter) {
+      flags |= SERD_ANON_CONT;
+      for (; !st && !sord_iter_end(sub_iter); sord_iter_next(sub_iter)) {
+        SordQuad sub_tup;
+        sord_iter_get(sub_iter, sub_tup);
+        st = write_statement(sord, writer, sub_tup, flags);
+      }
+      sord_iter_free(sub_iter);
+      serd_writer_end_anon(writer, so);
+    }
+  } else {
+    st = serd_writer_write_statement(
+      writer, flags, NULL, ss, sp, so, sd, &language);
+  }
+
+  return st;
 }
 
 bool
-sord_write(SordModel*  model,
-           SerdWriter* writer,
-           SordNode*   graph)
+sord_write(SordModel* model, SerdWriter* writer, SordNode* graph)
 {
-	SordQuad  pat  = { 0, 0, 0, graph };
-	SordIter* iter = sord_find(model, pat);
-	return sord_write_iter(iter, writer);
+  SordQuad  pat  = {0, 0, 0, graph};
+  SordIter* iter = sord_find(model, pat);
+  return sord_write_iter(iter, writer);
 }
 
 bool
-sord_write_iter(SordIter*   iter,
-                SerdWriter* writer)
+sord_write_iter(SordIter* iter, SerdWriter* writer)
 {
-	if (!iter) {
-		return false;
-	}
-
-	SordModel* model = (SordModel*)sord_iter_get_model(iter);
-	SerdStatus st    = SERD_SUCCESS;
-	for (; !st && !sord_iter_end(iter); sord_iter_next(iter)) {
-		SordQuad tup;
-		sord_iter_get(iter, tup);
-		st = write_statement(model, writer, tup, 0);
-	}
-	sord_iter_free(iter);
-
-	return !st;
+  if (!iter) {
+    return false;
+  }
+
+  SordModel* model = (SordModel*)sord_iter_get_model(iter);
+  SerdStatus st    = SERD_SUCCESS;
+  for (; !st && !sord_iter_end(iter); sord_iter_next(iter)) {
+    SordQuad tup;
+    sord_iter_get(iter, tup);
+    st = write_statement(model, writer, tup, 0);
+  }
+  sord_iter_free(iter);
+
+  return !st;
 }