diff --git a/.github/workflows/static-analysis.yml b/.github/workflows/static-analysis.yml
new file mode 100644
index 000000000..70a19c680
--- /dev/null
+++ b/.github/workflows/static-analysis.yml
@@ -0,0 +1,86 @@
+# JULEA - Flexible storage framework
+# Copyright (C) 2026 Jan Frase
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation, either version 3 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Lesser General Public License for more details.
+#
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+name: static-analysis.yml
+on: [push, pull_request]
+defaults:
+  run:
+    shell: bash
+
+jobs:
+  # This job is responsible for running Codechecker.
+  code-checker:
+    name: Code checker
+    runs-on: ubuntu-24.04
+    timeout-minutes: 60
+    env:
+      JULEA_SPACK_DIR: /julea-dependencies
+
+
+    steps:
+      # First, checkout julea.
+      - name: Checkout
+        uses: actions/checkout@v6
+        with:
+          persist-credentials: false
+          show-progress: false
+
+      # Get the dependencies.
+      - name: Install dependencies
+        run: |
+          sudo apt update
+          sudo apt --yes --no-install-recommends install meson ninja-build pkgconf libglib2.0-dev libbson-dev libfabric-dev libgdbm-dev liblmdb-dev libsqlite3-dev libleveldb-dev libmongoc-dev libmariadb-dev librocksdb-dev libfuse3-dev libopen-trace-format-dev librados-dev
+
+      # Then, generate compile_commands.json.
+      - name: Generate compile_commands.json
+        env:
+          CC: clang
+        run: |
+          . scripts/environment.sh
+          meson setup bld
+        
+      # Install CodeChecker, gcc and cppcheck.
+      - name: Install CodeChecker
+        run: |
+          pip install codechecker
+          sudo apt install --yes --no-install-recommends cppcheck gcc 
+
+      - name: Install Infer
+        run: |
+          VERSION=1.3.0; \
+          curl -sSL "https://github.com/facebook/infer/releases/download/v$VERSION/infer-linux-x86_64-v$VERSION.tar.xz" \
+          | sudo tar -C /opt -xJ && \
+          sudo ln -s "/opt/infer-linux-x86_64-v$VERSION/bin/infer" /usr/local/bin/infer
+
+      # Run the analysis.
+      - name: Run CodeChecker
+        # Since we already have ~100 warnings, i have disabled the sensitive checks for now.
+        # Should we ever run out of warnings, feel free to enable them again :D
+        run: CodeChecker analyze ./bld/compile_commands.json -o results --ctu || true #--enable sensitive
+
+      # Parse the results and generate an HTML report.
+      - name: Generate HTML report
+        run: |
+          # The parse command returns with exit code 2 if it finds any bugs.
+          # Thus, we ignore the exit code with "|| true", to avoid failing the workflow.
+          CodeChecker parse --export html --output ./reports_html ./results || true
+
+      # Lastly, upload the results to the CI.
+      - name: Upload results
+        uses: actions/upload-artifact@v7.0.1
+        with:
+          name: "CodeChecker Bug Reports"
+          path: ./reports_html
\ No newline at end of file
diff --git a/backend/db/mysql.c b/backend/db/mysql.c
index 7385fc533..1bf83f3af 100644
--- a/backend/db/mysql.c
+++ b/backend/db/mysql.c
@@ -74,7 +74,7 @@ j_sql_finalize(gpointer backend_db, void* _stmt, GError** error)
 	g_return_val_if_fail(backend_db != NULL, FALSE);
 	g_return_val_if_fail(_stmt != NULL, FALSE);
 
-	if (wrapper->stmt && (status = mysql_stmt_close(wrapper->stmt)))
+	if (wrapper->stmt && (status = (unsigned char)mysql_stmt_close(wrapper->stmt)))
 	{
 		g_set_error(error, J_BACKEND_SQL_ERROR, J_BACKEND_SQL_ERROR_FINALIZE, "sql finalize failed error was  (%d):'%s'", status, mysql_stmt_error(wrapper->stmt));
 		goto _error;
@@ -477,7 +477,7 @@ j_sql_step(gpointer backend_db, void* _stmt, gboolean* found, GError** error)
 	{
 		if (wrapper->param_count_in)
 		{
-			if ((status = mysql_stmt_bind_param(wrapper->stmt, wrapper->bind_in)))
+			if ((status = (unsigned char)mysql_stmt_bind_param(wrapper->stmt, wrapper->bind_in)))
 			{
 				g_set_error(error, J_BACKEND_SQL_ERROR, J_BACKEND_SQL_ERROR_STEP, "sql step failed error was  (%d):'%s'", status, mysql_stmt_error(wrapper->stmt));
 				goto _error;
@@ -486,7 +486,7 @@ j_sql_step(gpointer backend_db, void* _stmt, gboolean* found, GError** error)
 
 		if (wrapper->param_count_out)
 		{
-			if ((status = mysql_stmt_bind_result(wrapper->stmt, wrapper->bind_out)))
+			if ((status = (unsigned char)mysql_stmt_bind_result(wrapper->stmt, wrapper->bind_out)))
 			{
 				g_set_error(error, J_BACKEND_SQL_ERROR, J_BACKEND_SQL_ERROR_STEP, "sql step failed error was  (%d):'%s'", status, mysql_stmt_error(wrapper->stmt));
 				goto _error;
diff --git a/benchmark/benchmark.c b/benchmark/benchmark.c
index 7520fbd06..84f436a92 100644
--- a/benchmark/benchmark.c
+++ b/benchmark/benchmark.c
@@ -198,7 +198,7 @@ j_benchmark_run_one(BenchmarkRun* run)
 		{
 			g_autofree gchar* size = NULL;
 
-			size = g_format_size((gdouble)run->bytes / elapsed_time);
+			size = g_format_size((guint64)((gdouble)run->bytes / elapsed_time));
 			g_print(" (%s/s)", size);
 		}
 
@@ -311,7 +311,12 @@ main(int argc, char** argv)
 	};
 
 	// Explicitly enable UTF-8 since functions such as g_format_size might return UTF-8 characters.
-	setlocale(LC_ALL, "C.UTF-8");
+	g_autofree const char* local_result = setlocale(LC_ALL, "C.UTF-8");
+	if (local_result == NULL)
+	{
+		g_warning("Failed to set locale!");
+		return 1;
+	}
 
 	context = g_option_context_new(NULL);
 	g_option_context_add_main_entries(context, entries, NULL);
diff --git a/benchmark/db/common.c b/benchmark/db/common.c
index 9071b1df7..88516bba7 100644
--- a/benchmark/db/common.c
+++ b/benchmark/db/common.c
@@ -38,13 +38,13 @@
 #define FLOAT_FACTOR (3.1415926)
 
 static char*
-_benchmark_db_get_identifier(gint64 i)
+helper_fn_benchmark_db_get_identifier(gint64 i)
 {
 	return g_strdup_printf("%x-benchmark-%ld", (guint32)(i * SIGNED_FACTOR % N_MODULUS), i);
 }
 
 static JDBSchema*
-_benchmark_db_prepare_scheme(gchar const* namespace, gboolean use_batch, gboolean use_index_all, gboolean use_index_single, JBatch* batch, JBatch* delete_batch)
+helper_fn_benchmark_db_prepare_scheme(gchar const* namespace, gboolean use_batch, gboolean use_index_all, gboolean use_index_single, JBatch* batch, JBatch* delete_batch)
 {
 	gboolean ret;
 	g_autoptr(GError) b_s_error = NULL;
@@ -132,7 +132,7 @@ _benchmark_db_prepare_scheme(gchar const* namespace, gboolean use_batch, gboolea
 }
 
 static void
-_benchmark_db_insert(BenchmarkRun* run, JDBSchema* scheme, gchar const* namespace, gboolean use_batch, gboolean use_index_all, gboolean use_index_single, gboolean use_timer)
+helper_fn_benchmark_db_insert(BenchmarkRun* run, JDBSchema* scheme, gchar const* namespace, gboolean use_batch, gboolean use_index_all, gboolean use_index_single, gboolean use_timer)
 {
 	gboolean ret;
 	g_autoptr(JBatch) delete_batch = NULL;
@@ -150,7 +150,7 @@ _benchmark_db_insert(BenchmarkRun* run, JDBSchema* scheme, gchar const* namespac
 		g_assert_null(scheme);
 		g_assert_nonnull(run);
 
-		b_scheme = _benchmark_db_prepare_scheme(namespace, use_batch, use_index_all, use_index_single, batch, delete_batch);
+		b_scheme = helper_fn_benchmark_db_prepare_scheme(namespace, use_batch, use_index_all, use_index_single, batch, delete_batch);
 		g_assert_nonnull(b_scheme);
 
 		j_benchmark_timer_start(run);
@@ -172,7 +172,7 @@ _benchmark_db_insert(BenchmarkRun* run, JDBSchema* scheme, gchar const* namespac
 			gint64 i_signed = ((i * SIGNED_FACTOR) % CLASS_MODULUS) - CLASS_LIMIT;
 			guint64 i_usigned = ((i * USIGNED_FACTOR) % CLASS_MODULUS);
 			gdouble i_float = i_signed * FLOAT_FACTOR;
-			g_autofree gchar* string = _benchmark_db_get_identifier(i);
+			g_autofree gchar* string = helper_fn_benchmark_db_get_identifier(i);
 			g_autoptr(JDBEntry) entry = j_db_entry_new(b_scheme, &b_s_error);
 			g_assert_null(b_s_error);
 
diff --git a/benchmark/db/entry.c b/benchmark/db/entry.c
index 5071f1301..1af335c97 100644
--- a/benchmark/db/entry.c
+++ b/benchmark/db/entry.c
@@ -30,7 +30,7 @@
 #include "common.c"
 
 static void
-_benchmark_db_delete(BenchmarkRun* run, gchar const* namespace, gboolean use_batch, gboolean use_index_all, gboolean use_index_single)
+helper_fn_benchmark_db_delete(BenchmarkRun* run, gchar const* namespace, gboolean use_batch, gboolean use_index_all, gboolean use_index_single)
 {
 	gboolean ret;
 	g_autoptr(JBatch) delete_batch = NULL;
@@ -43,21 +43,21 @@ _benchmark_db_delete(BenchmarkRun* run, gchar const* namespace, gboolean use_bat
 	delete_batch = j_batch_new(semantics);
 	batch = j_batch_new(semantics);
 
-	b_scheme = _benchmark_db_prepare_scheme(namespace, false, use_index_all, use_index_single, batch, delete_batch);
+	b_scheme = helper_fn_benchmark_db_prepare_scheme(namespace, false, use_index_all, use_index_single, batch, delete_batch);
 
 	g_assert_nonnull(b_scheme);
 	g_assert_nonnull(run);
 
 	while (j_benchmark_iterate(run))
 	{
-		_benchmark_db_insert(NULL, b_scheme, NULL, true, false, false, false);
+		helper_fn_benchmark_db_insert(NULL, b_scheme, NULL, true, false, false, false);
 
 		j_benchmark_timer_start(run);
 
 		for (gint i = 0; i < ((use_index_all || use_index_single) ? N : (N / N_GET_DIVIDER)); i++)
 		{
 			g_autoptr(JDBEntry) entry = j_db_entry_new(b_scheme, &b_s_error);
-			g_autofree gchar* string = _benchmark_db_get_identifier(i);
+			g_autofree gchar* string = helper_fn_benchmark_db_get_identifier(i);
 			g_autoptr(JDBSelector) selector = j_db_selector_new(b_scheme, J_DB_SELECTOR_MODE_AND, &b_s_error);
 
 			ret = j_db_selector_add_field(selector, "string", J_DB_SELECTOR_OPERATOR_EQ, string, 0, &b_s_error);
@@ -91,7 +91,7 @@ _benchmark_db_delete(BenchmarkRun* run, gchar const* namespace, gboolean use_bat
 }
 
 static void
-_benchmark_db_update(BenchmarkRun* run, gchar const* namespace, gboolean use_batch, gboolean use_index_all, gboolean use_index_single)
+helper_fn_benchmark_db_update(BenchmarkRun* run, gchar const* namespace, gboolean use_batch, gboolean use_index_all, gboolean use_index_single)
 {
 	gboolean ret;
 	g_autoptr(JBatch) delete_batch = NULL;
@@ -104,12 +104,12 @@ _benchmark_db_update(BenchmarkRun* run, gchar const* namespace, gboolean use_bat
 	delete_batch = j_batch_new(semantics);
 	batch = j_batch_new(semantics);
 
-	b_scheme = _benchmark_db_prepare_scheme(namespace, false, use_index_all, use_index_single, batch, delete_batch);
+	b_scheme = helper_fn_benchmark_db_prepare_scheme(namespace, false, use_index_all, use_index_single, batch, delete_batch);
 
 	g_assert_nonnull(b_scheme);
 	g_assert_nonnull(run);
 
-	_benchmark_db_insert(NULL, b_scheme, NULL, true, false, false, false);
+	helper_fn_benchmark_db_insert(NULL, b_scheme, NULL, true, false, false, false);
 
 	j_benchmark_timer_start(run);
 
@@ -120,7 +120,7 @@ _benchmark_db_update(BenchmarkRun* run, gchar const* namespace, gboolean use_bat
 			gint64 i_signed = (((i + N_PRIME) * SIGNED_FACTOR) % CLASS_MODULUS) - CLASS_LIMIT;
 			g_autoptr(JDBSelector) selector = j_db_selector_new(b_scheme, J_DB_SELECTOR_MODE_AND, &b_s_error);
 			g_autoptr(JDBEntry) entry = j_db_entry_new(b_scheme, &b_s_error);
-			g_autofree gchar* string = _benchmark_db_get_identifier(i);
+			g_autofree gchar* string = helper_fn_benchmark_db_get_identifier(i);
 
 			g_assert_null(b_s_error);
 
@@ -161,145 +161,145 @@ _benchmark_db_update(BenchmarkRun* run, gchar const* namespace, gboolean use_bat
 static void
 benchmark_db_insert(BenchmarkRun* run)
 {
-	_benchmark_db_insert(run, NULL, "benchmark_insert", false, false, false, true);
+	helper_fn_benchmark_db_insert(run, NULL, "benchmark_insert", false, false, false, true);
 }
 
 static void
 benchmark_db_insert_batch(BenchmarkRun* run)
 {
-	_benchmark_db_insert(run, NULL, "benchmark_insert_batch", true, false, false, true);
+	helper_fn_benchmark_db_insert(run, NULL, "benchmark_insert_batch", true, false, false, true);
 }
 
 static void
 benchmark_db_insert_index_single(BenchmarkRun* run)
 {
-	_benchmark_db_insert(run, NULL, "benchmark_insert_index_single", false, false, true, true);
+	helper_fn_benchmark_db_insert(run, NULL, "benchmark_insert_index_single", false, false, true, true);
 }
 
 static void
 benchmark_db_insert_batch_index_single(BenchmarkRun* run)
 {
-	_benchmark_db_insert(run, NULL, "benchmark_insert_batch_index_single", true, false, true, true);
+	helper_fn_benchmark_db_insert(run, NULL, "benchmark_insert_batch_index_single", true, false, true, true);
 }
 
 static void
 benchmark_db_insert_index_all(BenchmarkRun* run)
 {
-	_benchmark_db_insert(run, NULL, "benchmark_insert_index_all", false, true, false, true);
+	helper_fn_benchmark_db_insert(run, NULL, "benchmark_insert_index_all", false, true, false, true);
 }
 
 static void
 benchmark_db_insert_batch_index_all(BenchmarkRun* run)
 {
-	_benchmark_db_insert(run, NULL, "benchmark_insert_batch_index_all", true, true, false, true);
+	helper_fn_benchmark_db_insert(run, NULL, "benchmark_insert_batch_index_all", true, true, false, true);
 }
 
 static void
 benchmark_db_insert_index_mixed(BenchmarkRun* run)
 {
-	_benchmark_db_insert(run, NULL, "benchmark_insert_index_mixed", false, true, true, true);
+	helper_fn_benchmark_db_insert(run, NULL, "benchmark_insert_index_mixed", false, true, true, true);
 }
 
 static void
 benchmark_db_insert_batch_index_mixed(BenchmarkRun* run)
 {
-	_benchmark_db_insert(run, NULL, "benchmark_insert_batch_index_mixed", true, true, true, true);
+	helper_fn_benchmark_db_insert(run, NULL, "benchmark_insert_batch_index_mixed", true, true, true, true);
 }
 
 static void
 benchmark_db_delete(BenchmarkRun* run)
 {
-	_benchmark_db_delete(run, "benchmark_delete", false, false, false);
+	helper_fn_benchmark_db_delete(run, "benchmark_delete", false, false, false);
 }
 
 static void
 benchmark_db_delete_batch(BenchmarkRun* run)
 {
-	_benchmark_db_delete(run, "benchmark_delete_batch", true, false, false);
+	helper_fn_benchmark_db_delete(run, "benchmark_delete_batch", true, false, false);
 }
 
 static void
 benchmark_db_delete_index_single(BenchmarkRun* run)
 {
-	_benchmark_db_delete(run, "benchmark_delete_index_single", false, false, true);
+	helper_fn_benchmark_db_delete(run, "benchmark_delete_index_single", false, false, true);
 }
 
 static void
 benchmark_db_delete_batch_index_single(BenchmarkRun* run)
 {
-	_benchmark_db_delete(run, "benchmark_delete_batch_index_single", true, false, true);
+	helper_fn_benchmark_db_delete(run, "benchmark_delete_batch_index_single", true, false, true);
 }
 
 static void
 benchmark_db_delete_index_all(BenchmarkRun* run)
 {
-	_benchmark_db_delete(run, "benchmark_delete_index_all", false, true, false);
+	helper_fn_benchmark_db_delete(run, "benchmark_delete_index_all", false, true, false);
 }
 
 static void
 benchmark_db_delete_batch_index_all(BenchmarkRun* run)
 {
-	_benchmark_db_delete(run, "benchmark_delete_batch_index_all", true, true, false);
+	helper_fn_benchmark_db_delete(run, "benchmark_delete_batch_index_all", true, true, false);
 }
 
 static void
 benchmark_db_delete_index_mixed(BenchmarkRun* run)
 {
-	_benchmark_db_delete(run, "benchmark_delete_index_mixed", false, true, true);
+	helper_fn_benchmark_db_delete(run, "benchmark_delete_index_mixed", false, true, true);
 }
 
 static void
 benchmark_db_delete_batch_index_mixed(BenchmarkRun* run)
 {
-	_benchmark_db_delete(run, "benchmark_delete_batch_index_mixed", true, true, true);
+	helper_fn_benchmark_db_delete(run, "benchmark_delete_batch_index_mixed", true, true, true);
 }
 
 static void
 benchmark_db_update(BenchmarkRun* run)
 {
-	_benchmark_db_update(run, "benchmark_update", false, false, false);
+	helper_fn_benchmark_db_update(run, "benchmark_update", false, false, false);
 }
 
 static void
 benchmark_db_update_batch(BenchmarkRun* run)
 {
-	_benchmark_db_update(run, "benchmark_update_batch", true, false, false);
+	helper_fn_benchmark_db_update(run, "benchmark_update_batch", true, false, false);
 }
 
 static void
 benchmark_db_update_index_single(BenchmarkRun* run)
 {
-	_benchmark_db_update(run, "benchmark_update_index_single", false, false, true);
+	helper_fn_benchmark_db_update(run, "benchmark_update_index_single", false, false, true);
 }
 
 static void
 benchmark_db_update_batch_index_single(BenchmarkRun* run)
 {
-	_benchmark_db_update(run, "benchmark_update_batch_index_single", true, false, true);
+	helper_fn_benchmark_db_update(run, "benchmark_update_batch_index_single", true, false, true);
 }
 
 static void
 benchmark_db_update_index_all(BenchmarkRun* run)
 {
-	_benchmark_db_update(run, "benchmark_update_index_all", false, true, false);
+	helper_fn_benchmark_db_update(run, "benchmark_update_index_all", false, true, false);
 }
 
 static void
 benchmark_db_update_batch_index_all(BenchmarkRun* run)
 {
-	_benchmark_db_update(run, "benchmark_update_batch_index_all", true, true, false);
+	helper_fn_benchmark_db_update(run, "benchmark_update_batch_index_all", true, true, false);
 }
 
 static void
 benchmark_db_update_index_mixed(BenchmarkRun* run)
 {
-	_benchmark_db_update(run, "benchmark_update_index_mixed", false, true, true);
+	helper_fn_benchmark_db_update(run, "benchmark_update_index_mixed", false, true, true);
 }
 
 static void
 benchmark_db_update_batch_index_mixed(BenchmarkRun* run)
 {
-	_benchmark_db_update(run, "benchmark_update_batch_index_mixed", true, true, true);
+	helper_fn_benchmark_db_update(run, "benchmark_update_batch_index_mixed", true, true, true);
 }
 
 void
diff --git a/benchmark/db/iterator.c b/benchmark/db/iterator.c
index d52450435..a73234241 100644
--- a/benchmark/db/iterator.c
+++ b/benchmark/db/iterator.c
@@ -30,7 +30,7 @@
 #include "common.c"
 
 static void
-_benchmark_db_get_simple(BenchmarkRun* run, gchar const* namespace, gboolean use_index_all, gboolean use_index_single)
+helper_fn_benchmark_db_get_simple(BenchmarkRun* run, gchar const* namespace, gboolean use_index_all, gboolean use_index_single)
 {
 	gboolean ret;
 	g_autoptr(JBatch) delete_batch = NULL;
@@ -43,12 +43,12 @@ _benchmark_db_get_simple(BenchmarkRun* run, gchar const* namespace, gboolean use
 	delete_batch = j_batch_new(semantics);
 	batch = j_batch_new(semantics);
 
-	b_scheme = _benchmark_db_prepare_scheme(namespace, false, use_index_all, use_index_single, batch, delete_batch);
+	b_scheme = helper_fn_benchmark_db_prepare_scheme(namespace, false, use_index_all, use_index_single, batch, delete_batch);
 
 	g_assert_nonnull(b_scheme);
 	g_assert_nonnull(run);
 
-	_benchmark_db_insert(NULL, b_scheme, NULL, true, false, false, false);
+	helper_fn_benchmark_db_insert(NULL, b_scheme, NULL, true, false, false, false);
 
 	j_benchmark_timer_start(run);
 
@@ -60,7 +60,7 @@ _benchmark_db_get_simple(BenchmarkRun* run, gchar const* namespace, gboolean use
 			g_autofree gpointer field_value;
 			guint64 field_length;
 			g_autoptr(JDBIterator) iterator;
-			g_autofree gchar* string = _benchmark_db_get_identifier(i);
+			g_autofree gchar* string = helper_fn_benchmark_db_get_identifier(i);
 			g_autoptr(JDBSelector) selector = j_db_selector_new(b_scheme, J_DB_SELECTOR_MODE_AND, &b_s_error);
 
 			ret = j_db_selector_add_field(selector, "string", J_DB_SELECTOR_OPERATOR_EQ, string, 0, &b_s_error);
@@ -90,7 +90,7 @@ _benchmark_db_get_simple(BenchmarkRun* run, gchar const* namespace, gboolean use
 }
 
 static void
-_benchmark_db_get_range(BenchmarkRun* run, gchar const* namespace, gboolean use_index_all, gboolean use_index_single)
+helper_fn_benchmark_db_get_range(BenchmarkRun* run, gchar const* namespace, gboolean use_index_all, gboolean use_index_single)
 {
 	gboolean ret;
 	g_autoptr(JBatch) delete_batch = NULL;
@@ -103,12 +103,12 @@ _benchmark_db_get_range(BenchmarkRun* run, gchar const* namespace, gboolean use_
 	delete_batch = j_batch_new(semantics);
 	batch = j_batch_new(semantics);
 
-	b_scheme = _benchmark_db_prepare_scheme(namespace, false, use_index_all, use_index_single, batch, delete_batch);
+	b_scheme = helper_fn_benchmark_db_prepare_scheme(namespace, false, use_index_all, use_index_single, batch, delete_batch);
 
 	g_assert_nonnull(b_scheme);
 	g_assert_nonnull(run);
 
-	_benchmark_db_insert(NULL, b_scheme, NULL, true, false, false, false);
+	helper_fn_benchmark_db_insert(NULL, b_scheme, NULL, true, false, false, false);
 
 	j_benchmark_timer_start(run);
 
@@ -159,49 +159,49 @@ _benchmark_db_get_range(BenchmarkRun* run, gchar const* namespace, gboolean use_
 static void
 benchmark_db_get_simple(BenchmarkRun* run)
 {
-	_benchmark_db_get_simple(run, "benchmark_get_simple", false, false);
+	helper_fn_benchmark_db_get_simple(run, "benchmark_get_simple", false, false);
 }
 
 static void
 benchmark_db_get_simple_index_single(BenchmarkRun* run)
 {
-	_benchmark_db_get_simple(run, "benchmark_get_simple_index_single", false, true);
+	helper_fn_benchmark_db_get_simple(run, "benchmark_get_simple_index_single", false, true);
 }
 
 static void
 benchmark_db_get_simple_index_all(BenchmarkRun* run)
 {
-	_benchmark_db_get_simple(run, "benchmark_get_simple_index_all", true, false);
+	helper_fn_benchmark_db_get_simple(run, "benchmark_get_simple_index_all", true, false);
 }
 
 static void
 benchmark_db_get_simple_index_mixed(BenchmarkRun* run)
 {
-	_benchmark_db_get_simple(run, "benchmark_get_simple_index_mixed", true, true);
+	helper_fn_benchmark_db_get_simple(run, "benchmark_get_simple_index_mixed", true, true);
 }
 
 static void
 benchmark_db_get_range(BenchmarkRun* run)
 {
-	_benchmark_db_get_range(run, "benchmark_get_range", false, false);
+	helper_fn_benchmark_db_get_range(run, "benchmark_get_range", false, false);
 }
 
 static void
 benchmark_db_get_range_index_single(BenchmarkRun* run)
 {
-	_benchmark_db_get_range(run, "benchmark_get_range_index_single", false, true);
+	helper_fn_benchmark_db_get_range(run, "benchmark_get_range_index_single", false, true);
 }
 
 static void
 benchmark_db_get_range_index_all(BenchmarkRun* run)
 {
-	_benchmark_db_get_range(run, "benchmark_get_range_index_all", true, false);
+	helper_fn_benchmark_db_get_range(run, "benchmark_get_range_index_all", true, false);
 }
 
 static void
 benchmark_db_get_range_index_mixed(BenchmarkRun* run)
 {
-	_benchmark_db_get_range(run, "benchmark_get_range_index_mixed", true, true);
+	helper_fn_benchmark_db_get_range(run, "benchmark_get_range_index_mixed", true, true);
 }
 
 void
diff --git a/benchmark/db/schema.c b/benchmark/db/schema.c
index e2f671392..5eec38658 100644
--- a/benchmark/db/schema.c
+++ b/benchmark/db/schema.c
@@ -26,7 +26,7 @@
 #include "benchmark.h"
 
 static void
-_benchmark_db_schema_create(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_db_schema_create(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 100;
 
@@ -90,17 +90,17 @@ _benchmark_db_schema_create(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_db_schema_create(BenchmarkRun* run)
 {
-	_benchmark_db_schema_create(run, FALSE);
+	helper_fn_benchmark_db_schema_create(run, FALSE);
 }
 
 static void
 benchmark_db_schema_create_batch(BenchmarkRun* run)
 {
-	_benchmark_db_schema_create(run, TRUE);
+	helper_fn_benchmark_db_schema_create(run, TRUE);
 }
 
 static void
-_benchmark_db_schema_delete(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_db_schema_delete(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 100;
 
@@ -172,13 +172,13 @@ _benchmark_db_schema_delete(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_db_schema_delete(BenchmarkRun* run)
 {
-	_benchmark_db_schema_delete(run, FALSE);
+	helper_fn_benchmark_db_schema_delete(run, FALSE);
 }
 
 static void
 benchmark_db_schema_delete_batch(BenchmarkRun* run)
 {
-	_benchmark_db_schema_delete(run, TRUE);
+	helper_fn_benchmark_db_schema_delete(run, TRUE);
 }
 
 void
diff --git a/benchmark/hdf5/hdf.c b/benchmark/hdf5/hdf.c
index 47f4e7683..c466c2489 100644
--- a/benchmark/hdf5/hdf.c
+++ b/benchmark/hdf5/hdf.c
@@ -335,7 +335,7 @@ benchmark_hdf_attribute_read(BenchmarkRun* run)
 }
 
 static void
-_benchmark_hdf_dataset_create(BenchmarkRun* run, guint dimensions)
+helper_fn_benchmark_hdf_dataset_create(BenchmarkRun* run, guint dimensions)
 {
 	guint const n = 1000;
 
@@ -376,17 +376,17 @@ _benchmark_hdf_dataset_create(BenchmarkRun* run, guint dimensions)
 static void
 benchmark_hdf_dataset_create_4m(BenchmarkRun* run)
 {
-	_benchmark_hdf_dataset_create(run, 2);
+	helper_fn_benchmark_hdf_dataset_create(run, 2);
 }
 
 static void
 benchmark_hdf_dataset_create_4k(BenchmarkRun* run)
 {
-	_benchmark_hdf_dataset_create(run, 1);
+	helper_fn_benchmark_hdf_dataset_create(run, 1);
 }
 
 static void
-_benchmark_hdf_dataset_open(BenchmarkRun* run, guint dimensions)
+helper_fn_benchmark_hdf_dataset_open(BenchmarkRun* run, guint dimensions)
 {
 	guint const n = 1000;
 
@@ -438,17 +438,17 @@ _benchmark_hdf_dataset_open(BenchmarkRun* run, guint dimensions)
 static void
 benchmark_hdf_dataset_open_4m(BenchmarkRun* run)
 {
-	_benchmark_hdf_dataset_open(run, 2);
+	helper_fn_benchmark_hdf_dataset_open(run, 2);
 }
 
 static void
 benchmark_hdf_dataset_open_4k(BenchmarkRun* run)
 {
-	_benchmark_hdf_dataset_open(run, 1);
+	helper_fn_benchmark_hdf_dataset_open(run, 1);
 }
 
 static void
-_benchmark_hdf_dataset_write(BenchmarkRun* run, guint dimensions)
+helper_fn_benchmark_hdf_dataset_write(BenchmarkRun* run, guint dimensions)
 {
 	guint const n = 100;
 
@@ -493,17 +493,17 @@ _benchmark_hdf_dataset_write(BenchmarkRun* run, guint dimensions)
 static void
 benchmark_hdf_dataset_write_4m(BenchmarkRun* run)
 {
-	_benchmark_hdf_dataset_write(run, 2);
+	helper_fn_benchmark_hdf_dataset_write(run, 2);
 }
 
 static void
 benchmark_hdf_dataset_write_4k(BenchmarkRun* run)
 {
-	_benchmark_hdf_dataset_write(run, 1);
+	helper_fn_benchmark_hdf_dataset_write(run, 1);
 }
 
 static void
-_benchmark_hdf_dataset_read(BenchmarkRun* run, guint dimensions)
+helper_fn_benchmark_hdf_dataset_read(BenchmarkRun* run, guint dimensions)
 {
 	guint const n = 100;
 
@@ -560,13 +560,13 @@ _benchmark_hdf_dataset_read(BenchmarkRun* run, guint dimensions)
 static void
 benchmark_hdf_dataset_read_4m(BenchmarkRun* run)
 {
-	_benchmark_hdf_dataset_read(run, 2);
+	helper_fn_benchmark_hdf_dataset_read(run, 2);
 }
 
 static void
 benchmark_hdf_dataset_read_4k(BenchmarkRun* run)
 {
-	_benchmark_hdf_dataset_read(run, 1);
+	helper_fn_benchmark_hdf_dataset_read(run, 1);
 }
 
 static void
diff --git a/benchmark/item/collection.c b/benchmark/item/collection.c
index 5b711f232..84bd9483d 100644
--- a/benchmark/item/collection.c
+++ b/benchmark/item/collection.c
@@ -26,7 +26,7 @@
 #include "benchmark.h"
 
 static void
-_benchmark_collection_create(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_collection_create(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -78,17 +78,17 @@ _benchmark_collection_create(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_collection_create(BenchmarkRun* run)
 {
-	_benchmark_collection_create(run, FALSE);
+	helper_fn_benchmark_collection_create(run, FALSE);
 }
 
 static void
 benchmark_collection_create_batch(BenchmarkRun* run)
 {
-	_benchmark_collection_create(run, TRUE);
+	helper_fn_benchmark_collection_create(run, TRUE);
 }
 
 static void
-_benchmark_collection_delete(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_collection_delete(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -103,11 +103,10 @@ _benchmark_collection_delete(BenchmarkRun* run, gboolean use_batch)
 	{
 		for (guint i = 0; i < n; i++)
 		{
-			g_autoptr(JCollection) collection = NULL;
-			g_autofree gchar* name = NULL;
+			g_autofree const gchar* name = NULL;
 
 			name = g_strdup_printf("benchmark-%d", i);
-			collection = j_collection_create(name, batch);
+			j_collection_create(name, batch);
 		}
 
 		ret = j_batch_execute(batch);
@@ -149,13 +148,13 @@ _benchmark_collection_delete(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_collection_delete(BenchmarkRun* run)
 {
-	_benchmark_collection_delete(run, FALSE);
+	helper_fn_benchmark_collection_delete(run, FALSE);
 }
 
 static void
 benchmark_collection_delete_batch(BenchmarkRun* run)
 {
-	_benchmark_collection_delete(run, TRUE);
+	helper_fn_benchmark_collection_delete(run, TRUE);
 }
 
 static void
@@ -200,7 +199,7 @@ benchmark_collection_delete_batch_without_get(BenchmarkRun* run)
 }
 
 static void
-_benchmark_collection_unordered_create_delete(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_collection_unordered_create_delete(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -246,13 +245,13 @@ _benchmark_collection_unordered_create_delete(BenchmarkRun* run, gboolean use_ba
 static void
 benchmark_collection_unordered_create_delete(BenchmarkRun* run)
 {
-	_benchmark_collection_unordered_create_delete(run, FALSE);
+	helper_fn_benchmark_collection_unordered_create_delete(run, FALSE);
 }
 
 static void
 benchmark_collection_unordered_create_delete_batch(BenchmarkRun* run)
 {
-	_benchmark_collection_unordered_create_delete(run, TRUE);
+	helper_fn_benchmark_collection_unordered_create_delete(run, TRUE);
 }
 
 void
diff --git a/benchmark/item/item.c b/benchmark/item/item.c
index 3292e89ad..3ef3755f1 100644
--- a/benchmark/item/item.c
+++ b/benchmark/item/item.c
@@ -28,7 +28,7 @@
 #include "benchmark.h"
 
 static void
-_benchmark_item_create(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_item_create(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -89,17 +89,17 @@ _benchmark_item_create(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_item_create(BenchmarkRun* run)
 {
-	_benchmark_item_create(run, FALSE);
+	helper_fn_benchmark_item_create(run, FALSE);
 }
 
 static void
 benchmark_item_create_batch(BenchmarkRun* run)
 {
-	_benchmark_item_create(run, TRUE);
+	helper_fn_benchmark_item_create(run, TRUE);
 }
 
 static void
-_benchmark_item_delete(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_item_delete(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -121,11 +121,10 @@ _benchmark_item_delete(BenchmarkRun* run, gboolean use_batch)
 	{
 		for (guint i = 0; i < n; i++)
 		{
-			g_autoptr(JItem) item = NULL;
-			g_autofree gchar* name = NULL;
+			g_autofree const gchar* name = NULL;
 
 			name = g_strdup_printf("benchmark-%d", i);
-			item = j_item_create(collection, name, NULL, batch);
+			j_item_create(collection, name, NULL, batch);
 		}
 
 		ret = j_batch_execute(batch);
@@ -171,13 +170,13 @@ _benchmark_item_delete(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_item_delete(BenchmarkRun* run)
 {
-	_benchmark_item_delete(run, FALSE);
+	helper_fn_benchmark_item_delete(run, FALSE);
 }
 
 static void
 benchmark_item_delete_batch(BenchmarkRun* run)
 {
-	_benchmark_item_delete(run, TRUE);
+	helper_fn_benchmark_item_delete(run, TRUE);
 }
 
 static void
@@ -231,7 +230,7 @@ benchmark_item_delete_batch_without_get(BenchmarkRun* run)
 }
 
 static void
-_benchmark_item_get_status(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_item_get_status(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = (use_batch) ? 10000 : 1000;
 
@@ -290,17 +289,17 @@ _benchmark_item_get_status(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_item_get_status(BenchmarkRun* run)
 {
-	_benchmark_item_get_status(run, FALSE);
+	helper_fn_benchmark_item_get_status(run, FALSE);
 }
 
 static void
 benchmark_item_get_status_batch(BenchmarkRun* run)
 {
-	_benchmark_item_get_status(run, TRUE);
+	helper_fn_benchmark_item_get_status(run, TRUE);
 }
 
 static void
-_benchmark_item_read(BenchmarkRun* run, gboolean use_batch, guint block_size)
+helper_fn_benchmark_item_read(BenchmarkRun* run, gboolean use_batch, guint block_size)
 {
 	guint const n = (use_batch) ? 10000 : 1000;
 
@@ -367,17 +366,17 @@ _benchmark_item_read(BenchmarkRun* run, gboolean use_batch, guint block_size)
 static void
 benchmark_item_read(BenchmarkRun* run)
 {
-	_benchmark_item_read(run, FALSE, 4 * 1024);
+	helper_fn_benchmark_item_read(run, FALSE, 4 * 1024);
 }
 
 static void
 benchmark_item_read_batch(BenchmarkRun* run)
 {
-	_benchmark_item_read(run, TRUE, 4 * 1024);
+	helper_fn_benchmark_item_read(run, TRUE, 4 * 1024);
 }
 
 static void
-_benchmark_item_write(BenchmarkRun* run, gboolean use_batch, guint block_size)
+helper_fn_benchmark_item_write(BenchmarkRun* run, gboolean use_batch, guint block_size)
 {
 	guint const n = (use_batch) ? 10000 : 1000;
 
@@ -437,17 +436,17 @@ _benchmark_item_write(BenchmarkRun* run, gboolean use_batch, guint block_size)
 static void
 benchmark_item_write(BenchmarkRun* run)
 {
-	_benchmark_item_write(run, FALSE, 4 * 1024);
+	helper_fn_benchmark_item_write(run, FALSE, 4 * 1024);
 }
 
 static void
 benchmark_item_write_batch(BenchmarkRun* run)
 {
-	_benchmark_item_write(run, TRUE, 4 * 1024);
+	helper_fn_benchmark_item_write(run, TRUE, 4 * 1024);
 }
 
 static void
-_benchmark_item_unordered_create_delete(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_item_unordered_create_delete(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -502,13 +501,13 @@ _benchmark_item_unordered_create_delete(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_item_unordered_create_delete(BenchmarkRun* run)
 {
-	_benchmark_item_unordered_create_delete(run, FALSE);
+	helper_fn_benchmark_item_unordered_create_delete(run, FALSE);
 }
 
 static void
 benchmark_item_unordered_create_delete_batch(BenchmarkRun* run)
 {
-	_benchmark_item_unordered_create_delete(run, TRUE);
+	helper_fn_benchmark_item_unordered_create_delete(run, TRUE);
 }
 
 void
diff --git a/benchmark/kv/kv.c b/benchmark/kv/kv.c
index 16cca78da..12dd23200 100644
--- a/benchmark/kv/kv.c
+++ b/benchmark/kv/kv.c
@@ -28,7 +28,7 @@
 #include "benchmark.h"
 
 static void
-_benchmark_kv_put(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_kv_put(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -81,17 +81,17 @@ _benchmark_kv_put(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_kv_put(BenchmarkRun* run)
 {
-	_benchmark_kv_put(run, FALSE);
+	helper_fn_benchmark_kv_put(run, FALSE);
 }
 
 static void
 benchmark_kv_put_batch(BenchmarkRun* run)
 {
-	_benchmark_kv_put(run, TRUE);
+	helper_fn_benchmark_kv_put(run, TRUE);
 }
 
 static void
-_benchmark_kv_get_callback(gpointer value, guint32 len, gpointer data)
+helper_fn_benchmark_kv_get_callback(gpointer value, guint32 len, gpointer data)
 {
 	(void)len;
 	(void)data;
@@ -100,7 +100,7 @@ _benchmark_kv_get_callback(gpointer value, guint32 len, gpointer data)
 }
 
 static void
-_benchmark_kv_get(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_kv_get(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -139,7 +139,7 @@ _benchmark_kv_get(BenchmarkRun* run, gboolean use_batch)
 
 			name = g_strdup_printf("benchmark-%d", i);
 			object = j_kv_new("benchmark", name);
-			j_kv_get_callback(object, _benchmark_kv_get_callback, NULL, batch);
+			j_kv_get_callback(object, helper_fn_benchmark_kv_get_callback, NULL, batch);
 
 			if (!use_batch)
 			{
@@ -166,17 +166,17 @@ _benchmark_kv_get(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_kv_get(BenchmarkRun* run)
 {
-	_benchmark_kv_get(run, FALSE);
+	helper_fn_benchmark_kv_get(run, FALSE);
 }
 
 static void
 benchmark_kv_get_batch(BenchmarkRun* run)
 {
-	_benchmark_kv_get(run, TRUE);
+	helper_fn_benchmark_kv_get(run, TRUE);
 }
 
 static void
-_benchmark_kv_delete(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_kv_delete(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -236,17 +236,17 @@ _benchmark_kv_delete(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_kv_delete(BenchmarkRun* run)
 {
-	_benchmark_kv_delete(run, FALSE);
+	helper_fn_benchmark_kv_delete(run, FALSE);
 }
 
 static void
 benchmark_kv_delete_batch(BenchmarkRun* run)
 {
-	_benchmark_kv_delete(run, TRUE);
+	helper_fn_benchmark_kv_delete(run, TRUE);
 }
 
 static void
-_benchmark_kv_unordered_put_delete(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_kv_unordered_put_delete(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -293,13 +293,13 @@ _benchmark_kv_unordered_put_delete(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_kv_unordered_put_delete(BenchmarkRun* run)
 {
-	_benchmark_kv_unordered_put_delete(run, FALSE);
+	helper_fn_benchmark_kv_unordered_put_delete(run, FALSE);
 }
 
 static void
 benchmark_kv_unordered_put_delete_batch(BenchmarkRun* run)
 {
-	_benchmark_kv_unordered_put_delete(run, TRUE);
+	helper_fn_benchmark_kv_unordered_put_delete(run, TRUE);
 }
 
 void
diff --git a/benchmark/message.c b/benchmark/message.c
index 13fe48a1d..e22dc6bbb 100644
--- a/benchmark/message.c
+++ b/benchmark/message.c
@@ -27,7 +27,7 @@
 #include "benchmark.h"
 
 static void
-_benchmark_message_new(BenchmarkRun* run, gboolean append)
+helper_benchmark_message_new(BenchmarkRun* run, gboolean append)
 {
 	guint const n = 100000;
 	guint const m = 100;
@@ -62,17 +62,17 @@ _benchmark_message_new(BenchmarkRun* run, gboolean append)
 static void
 benchmark_message_new(BenchmarkRun* run)
 {
-	_benchmark_message_new(run, FALSE);
+	helper_benchmark_message_new(run, FALSE);
 }
 
 static void
 benchmark_message_new_append(BenchmarkRun* run)
 {
-	_benchmark_message_new(run, TRUE);
+	helper_benchmark_message_new(run, TRUE);
 }
 
 static void
-_benchmark_message_add_operation(BenchmarkRun* run, gboolean large)
+helper_benchmark_message_add_operation(BenchmarkRun* run, gboolean large)
 {
 	guint const n = (large) ? 100 : 10000;
 	guint const m = (large) ? 10000 : 100;
@@ -105,13 +105,13 @@ _benchmark_message_add_operation(BenchmarkRun* run, gboolean large)
 static void
 benchmark_message_add_operation_small(BenchmarkRun* run)
 {
-	_benchmark_message_add_operation(run, FALSE);
+	helper_benchmark_message_add_operation(run, FALSE);
 }
 
 static void
 benchmark_message_add_operation_large(BenchmarkRun* run)
 {
-	_benchmark_message_add_operation(run, TRUE);
+	helper_benchmark_message_add_operation(run, TRUE);
 }
 
 void
diff --git a/benchmark/object/distributed-object.c b/benchmark/object/distributed-object.c
index a716c071d..4c8dd582d 100644
--- a/benchmark/object/distributed-object.c
+++ b/benchmark/object/distributed-object.c
@@ -28,7 +28,7 @@
 #include "benchmark.h"
 
 static void
-_benchmark_distributed_object_create(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_distributed_object_create(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -83,17 +83,17 @@ _benchmark_distributed_object_create(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_distributed_object_create(BenchmarkRun* run)
 {
-	_benchmark_distributed_object_create(run, FALSE);
+	helper_fn_benchmark_distributed_object_create(run, FALSE);
 }
 
 static void
 benchmark_distributed_object_create_batch(BenchmarkRun* run)
 {
-	_benchmark_distributed_object_create(run, TRUE);
+	helper_fn_benchmark_distributed_object_create(run, TRUE);
 }
 
 static void
-_benchmark_distributed_object_delete(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_distributed_object_delete(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -155,17 +155,17 @@ _benchmark_distributed_object_delete(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_distributed_object_delete(BenchmarkRun* run)
 {
-	_benchmark_distributed_object_delete(run, FALSE);
+	helper_fn_benchmark_distributed_object_delete(run, FALSE);
 }
 
 static void
 benchmark_distributed_object_delete_batch(BenchmarkRun* run)
 {
-	_benchmark_distributed_object_delete(run, TRUE);
+	helper_fn_benchmark_distributed_object_delete(run, TRUE);
 }
 
 static void
-_benchmark_distributed_object_status(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_distributed_object_status(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = (use_batch) ? 10000 : 1000;
 
@@ -225,17 +225,17 @@ _benchmark_distributed_object_status(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_distributed_object_status(BenchmarkRun* run)
 {
-	_benchmark_distributed_object_status(run, FALSE);
+	helper_fn_benchmark_distributed_object_status(run, FALSE);
 }
 
 static void
 benchmark_distributed_object_status_batch(BenchmarkRun* run)
 {
-	_benchmark_distributed_object_status(run, TRUE);
+	helper_fn_benchmark_distributed_object_status(run, TRUE);
 }
 
 static void
-_benchmark_distributed_object_read(BenchmarkRun* run, gboolean use_batch, guint block_size)
+helper_fn_benchmark_distributed_object_read(BenchmarkRun* run, gboolean use_batch, guint block_size)
 {
 	guint const n = (use_batch) ? 10000 : 1000;
 
@@ -302,17 +302,17 @@ _benchmark_distributed_object_read(BenchmarkRun* run, gboolean use_batch, guint
 static void
 benchmark_distributed_object_read(BenchmarkRun* run)
 {
-	_benchmark_distributed_object_read(run, FALSE, 4 * 1024);
+	helper_fn_benchmark_distributed_object_read(run, FALSE, 4 * 1024);
 }
 
 static void
 benchmark_distributed_object_read_batch(BenchmarkRun* run)
 {
-	_benchmark_distributed_object_read(run, TRUE, 4 * 1024);
+	helper_fn_benchmark_distributed_object_read(run, TRUE, 4 * 1024);
 }
 
 static void
-_benchmark_distributed_object_write(BenchmarkRun* run, gboolean use_batch, guint block_size)
+helper_fn_benchmark_distributed_object_write(BenchmarkRun* run, gboolean use_batch, guint block_size)
 {
 	guint const n = (use_batch) ? 10000 : 1000;
 
@@ -372,17 +372,17 @@ _benchmark_distributed_object_write(BenchmarkRun* run, gboolean use_batch, guint
 static void
 benchmark_distributed_object_write(BenchmarkRun* run)
 {
-	_benchmark_distributed_object_write(run, FALSE, 4 * 1024);
+	helper_fn_benchmark_distributed_object_write(run, FALSE, 4 * 1024);
 }
 
 static void
 benchmark_distributed_object_write_batch(BenchmarkRun* run)
 {
-	_benchmark_distributed_object_write(run, TRUE, 4 * 1024);
+	helper_fn_benchmark_distributed_object_write(run, TRUE, 4 * 1024);
 }
 
 static void
-_benchmark_distributed_object_unordered_create_delete(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_distributed_object_unordered_create_delete(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -431,13 +431,13 @@ _benchmark_distributed_object_unordered_create_delete(BenchmarkRun* run, gboolea
 static void
 benchmark_distributed_object_unordered_create_delete(BenchmarkRun* run)
 {
-	_benchmark_distributed_object_unordered_create_delete(run, FALSE);
+	helper_fn_benchmark_distributed_object_unordered_create_delete(run, FALSE);
 }
 
 static void
 benchmark_distributed_object_unordered_create_delete_batch(BenchmarkRun* run)
 {
-	_benchmark_distributed_object_unordered_create_delete(run, TRUE);
+	helper_fn_benchmark_distributed_object_unordered_create_delete(run, TRUE);
 }
 
 void
diff --git a/benchmark/object/object.c b/benchmark/object/object.c
index 032318b7e..8e2e570f5 100644
--- a/benchmark/object/object.c
+++ b/benchmark/object/object.c
@@ -28,7 +28,7 @@
 #include "benchmark.h"
 
 static void
-_benchmark_object_create(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_object_create(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -81,17 +81,17 @@ _benchmark_object_create(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_object_create(BenchmarkRun* run)
 {
-	_benchmark_object_create(run, FALSE);
+	helper_fn_benchmark_object_create(run, FALSE);
 }
 
 static void
 benchmark_object_create_batch(BenchmarkRun* run)
 {
-	_benchmark_object_create(run, TRUE);
+	helper_fn_benchmark_object_create(run, TRUE);
 }
 
 static void
-_benchmark_object_delete(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_object_delete(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -151,17 +151,17 @@ _benchmark_object_delete(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_object_delete(BenchmarkRun* run)
 {
-	_benchmark_object_delete(run, FALSE);
+	helper_fn_benchmark_object_delete(run, FALSE);
 }
 
 static void
 benchmark_object_delete_batch(BenchmarkRun* run)
 {
-	_benchmark_object_delete(run, TRUE);
+	helper_fn_benchmark_object_delete(run, TRUE);
 }
 
 static void
-_benchmark_object_status(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_object_status(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = (use_batch) ? 10000 : 1000;
 
@@ -219,17 +219,17 @@ _benchmark_object_status(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_object_status(BenchmarkRun* run)
 {
-	_benchmark_object_status(run, FALSE);
+	helper_fn_benchmark_object_status(run, FALSE);
 }
 
 static void
 benchmark_object_status_batch(BenchmarkRun* run)
 {
-	_benchmark_object_status(run, TRUE);
+	helper_fn_benchmark_object_status(run, TRUE);
 }
 
 static void
-_benchmark_object_read(BenchmarkRun* run, gboolean use_batch, guint block_size)
+helper_fn_benchmark_object_read(BenchmarkRun* run, gboolean use_batch, guint block_size)
 {
 	guint const n = (use_batch) ? 10000 : 1000;
 
@@ -294,17 +294,17 @@ _benchmark_object_read(BenchmarkRun* run, gboolean use_batch, guint block_size)
 static void
 benchmark_object_read(BenchmarkRun* run)
 {
-	_benchmark_object_read(run, FALSE, 4 * 1024);
+	helper_fn_benchmark_object_read(run, FALSE, 4 * 1024);
 }
 
 static void
 benchmark_object_read_batch(BenchmarkRun* run)
 {
-	_benchmark_object_read(run, TRUE, 4 * 1024);
+	helper_fn_benchmark_object_read(run, TRUE, 4 * 1024);
 }
 
 static void
-_benchmark_object_write(BenchmarkRun* run, gboolean use_batch, guint block_size)
+helper_fn_benchmark_object_write(BenchmarkRun* run, gboolean use_batch, guint block_size)
 {
 	guint const n = (use_batch) ? 10000 : 1000;
 
@@ -362,17 +362,17 @@ _benchmark_object_write(BenchmarkRun* run, gboolean use_batch, guint block_size)
 static void
 benchmark_object_write(BenchmarkRun* run)
 {
-	_benchmark_object_write(run, FALSE, 4 * 1024);
+	helper_fn_benchmark_object_write(run, FALSE, 4 * 1024);
 }
 
 static void
 benchmark_object_write_batch(BenchmarkRun* run)
 {
-	_benchmark_object_write(run, TRUE, 4 * 1024);
+	helper_fn_benchmark_object_write(run, TRUE, 4 * 1024);
 }
 
 static void
-_benchmark_object_unordered_create_delete(BenchmarkRun* run, gboolean use_batch)
+helper_fn_benchmark_object_unordered_create_delete(BenchmarkRun* run, gboolean use_batch)
 {
 	guint const n = 1000;
 
@@ -419,13 +419,13 @@ _benchmark_object_unordered_create_delete(BenchmarkRun* run, gboolean use_batch)
 static void
 benchmark_object_unordered_create_delete(BenchmarkRun* run)
 {
-	_benchmark_object_unordered_create_delete(run, FALSE);
+	helper_fn_benchmark_object_unordered_create_delete(run, FALSE);
 }
 
 static void
 benchmark_object_unordered_create_delete_batch(BenchmarkRun* run)
 {
-	_benchmark_object_unordered_create_delete(run, TRUE);
+	helper_fn_benchmark_object_unordered_create_delete(run, TRUE);
 }
 
 void
diff --git a/cli/cli.c b/cli/cli.c
index 0d6af17c0..3fe786026 100644
--- a/cli/cli.c
+++ b/cli/cli.c
@@ -86,7 +86,12 @@ main(int argc, char** argv)
 	gint i;
 
 	// Explicitly enable UTF-8 since functions such as g_format_size might return UTF-8 characters.
-	setlocale(LC_ALL, "C.UTF-8");
+	g_autofree const char* local_result = setlocale(LC_ALL, "C.UTF-8");
+	if (local_result == NULL)
+	{
+		g_warning("Failed to set locale!");
+		return 1;
+	}
 
 	basename = g_path_get_basename(argv[0]);
 	g_set_prgname(basename);
diff --git a/cli/copy.c b/cli/copy.c
index e9f249996..720192d88 100644
--- a/cli/copy.c
+++ b/cli/copy.c
@@ -87,8 +87,6 @@ j_cmd_copy(gchar const** arguments)
 			}
 			else if (i == 1)
 			{
-				g_autoptr(JItem) item = NULL;
-
 				if (j_uri_get(uri[i], &error))
 				{
 					ret = FALSE;
@@ -114,7 +112,7 @@ j_cmd_copy(gchar const** arguments)
 				}
 
 				batch = j_batch_new_for_template(J_SEMANTICS_TEMPLATE_DEFAULT);
-				item = j_item_create(j_uri_get_collection(uri[i]), j_uri_get_item_name(uri[i]), NULL, batch);
+				j_item_create(j_uri_get_collection(uri[i]), j_uri_get_item_name(uri[i]), NULL, batch);
 
 				if (!j_batch_execute(batch))
 				{
diff --git a/doc/static-analysis.md b/doc/static-analysis.md
new file mode 100644
index 000000000..9ed9f07a9
--- /dev/null
+++ b/doc/static-analysis.md
@@ -0,0 +1,38 @@
+# Static Analysis
+
+The codebase is checked for defects using CodeChecker, which wraps several static analysis tools (clang-sa, gcc, infer, cppcheck).
+
+## Pipeline
+It is automatically run in the GitHub pipeline and emits an artifact called "CodeChecker Bug Reports".
+A small summary of the number and types of errors found is given at the end of the "Generate HTML report" step.
+To view the detailed results, the artifact must be downloaded, extracted, and the `index.html` or `statistics.html` file opened.
+
+## Local
+Alternatively, the tool can be run locally.
+A full guide can be found [here](https://github.com/Ericsson/codechecker/blob/master/docs/usage.md).
+
+Notably, the tool can calculate a diff between two analysis runs as explained [here](https://github.com/Ericsson/codechecker/blob/master/docs/usage.md#using-diff-command-on-the-local-filesystem).
+This can be used to check whether your current local changes would introduce or remove any bugs.
+
+In summary:
+1. Ensure CodeChecker, the desired static analysis tools, and all JULEA dependencies are installed and available.
+
+2. Generate a `compile_commands.json` file.
+```bash
+meson setup -Dis_analysis_build=true bld
+```
+
+3. Run the analysis.
+```bash
+CodeChecker analyze ./bld/compile_commands.json -o results
+```
+
+4. Parse and view the results.
+```bash
+CodeChecker parse --export html --output ./reports_html ./results  &&
+firefox ./reports_html/index.html
+```
+
+## Potential improvements
+The current setup is quite bare-bones.
+CodeChecker supports running a server to store results of previous analysis runs, tracking reports that have already been marked as known false positives, and automatically calculating a diff between the main branch and the branch to be merged.
diff --git a/fuse/julea-fuse.c b/fuse/julea-fuse.c
index ca9d056b2..523a8ae9f 100644
--- a/fuse/julea-fuse.c
+++ b/fuse/julea-fuse.c
@@ -48,7 +48,12 @@ main(int argc, char** argv)
 	gint ret;
 
 	// Explicitly enable UTF-8 since functions such as g_format_size might return UTF-8 characters.
-	setlocale(LC_ALL, "C.UTF-8");
+	g_autofree const char* local_result = setlocale(LC_ALL, "C.UTF-8");
+	if (local_result == NULL)
+	{
+		g_warning("Failed to set locale!");
+		return 1;
+	}
 
 	ret = fuse_main(argc, argv, &jfs_vtable, NULL);
 
diff --git a/fuse/read.c b/fuse/read.c
index 43450aa7d..c6142e50e 100644
--- a/fuse/read.c
+++ b/fuse/read.c
@@ -28,14 +28,12 @@ jfs_read(char const* path, char* buf, size_t size, off_t offset, struct fuse_fil
 	int ret = -ENOENT;
 
 	g_autoptr(JBatch) batch = NULL;
-	g_autoptr(JKV) kv = NULL;
 	g_autoptr(JObject) object = NULL;
 	guint64 bytes_read;
 
 	(void)fi;
 
 	batch = j_batch_new_for_template(J_SEMANTICS_TEMPLATE_POSIX);
-	kv = j_kv_new("posix", path);
 	object = j_object_new("posix", path);
 
 	j_object_read(object, buf, size, offset, &bytes_read, batch);
diff --git a/include/item/jcollection.h b/include/item/jcollection.h
index 4dbcd0148..f0583df65 100644
--- a/include/item/jcollection.h
+++ b/include/item/jcollection.h
@@ -37,12 +37,6 @@ struct JCollection;
 
 typedef struct JCollection JCollection;
 
-G_END_DECLS
-
-#include <item/jitem.h>
-
-G_BEGIN_DECLS
-
 /**
  * \defgroup JCollection Collection
  *
diff --git a/lib/core/jmessage.c b/lib/core/jmessage.c
index 1bc7c42be..d465794f8 100644
--- a/lib/core/jmessage.c
+++ b/lib/core/jmessage.c
@@ -259,7 +259,7 @@ j_message_extend(JMessage* message, gsize length)
 
 	if (count > 10)
 	{
-		factor = pow(10, floor(log10(count)));
+		factor = (gsize)pow(10, floor(log10(count)));
 	}
 
 	message->size += length * factor;
diff --git a/lib/core/jnetwork.c b/lib/core/jnetwork.c
index eb72951e9..4ccd9f75d 100644
--- a/lib/core/jnetwork.c
+++ b/lib/core/jnetwork.c
@@ -696,7 +696,6 @@ j_network_connection_init(JNetworkConnection* connection)
 
 	EXE(j_network_connection_create_memory_resources(connection), "Failed to create memory resources for connection!");
 
-	res = fi_cq_open(connection->domain, &(struct fi_cq_attr){ .wait_obj = FI_WAIT_UNSPEC, .format = FI_CQ_FORMAT_CONTEXT, .size = connection->info->tx_attr->size }, &connection->cq.tx, &connection->cq.tx);
 	res = fi_cq_open(connection->domain, &(struct fi_cq_attr){ .wait_obj = FI_WAIT_UNSPEC, .format = FI_CQ_FORMAT_CONTEXT, .size = connection->info->rx_attr->size }, &connection->cq.rx, &connection->cq.rx);
 	CHECK("Failed to create completion queue!");
 
diff --git a/lib/core/jtrace.c b/lib/core/jtrace.c
index ae3e8f0d8..18d53444d 100644
--- a/lib/core/jtrace.c
+++ b/lib/core/jtrace.c
@@ -729,30 +729,21 @@ j_trace_file_begin(gchar const* path, JTraceFileOperation op)
 #ifdef HAVE_OTF
 	if (j_trace_flags & J_TRACE_OTF)
 	{
-		gpointer value;
-		guint32 file_id;
-
 		G_LOCK(j_trace_otf);
 
-		if ((value = g_hash_table_lookup(otf_file_table, path)) == NULL)
+		if ((g_hash_table_lookup(otf_file_table, path)) == NULL)
 		{
-			file_id = g_atomic_int_add(&otf_file_id, 1);
+			const guint32 file_id = g_atomic_int_add(&otf_file_id, 1);
 
 			OTF_Writer_writeDefFile(otf_writer, 0, file_id, path, 0);
 			g_hash_table_insert(otf_file_table, g_strdup(path), GUINT_TO_POINTER(file_id));
 		}
-		else
-		{
-			file_id = GPOINTER_TO_UINT(value);
-		}
 
 		G_UNLOCK(j_trace_otf);
 
 		OTF_Writer_writeBeginFileOperation(otf_writer, timestamp, trace_thread->otf.process_id, 1, 0);
 	}
 #endif
-
-	return;
 }
 
 void
diff --git a/lib/db-util/sql-generic-ddl.c b/lib/db-util/sql-generic-ddl.c
index f89a153f7..c6544c496 100644
--- a/lib/db-util/sql-generic-ddl.c
+++ b/lib/db-util/sql-generic-ddl.c
@@ -74,7 +74,7 @@ sql_generic_schema_create(gpointer backend_data, gpointer _batch, gchar const* n
 		}
 	}
 
-	if (G_UNLIKELY(!_backend_batch_execute(backend_data, batch, error)))
+	if (G_UNLIKELY(!internal_backend_batch_execute(backend_data, batch, error)))
 	{
 		//no ddl in transaction - most databases won't support that - continue without any open transaction
 		goto _error;
@@ -360,7 +360,7 @@ sql_generic_schema_create(gpointer backend_data, gpointer _batch, gchar const* n
 		}
 	}
 
-	if (G_UNLIKELY(!_backend_batch_start(backend_data, batch, error)))
+	if (G_UNLIKELY(!internal_backend_batch_start(backend_data, batch, error)))
 	{
 		goto _error;
 	}
@@ -368,7 +368,7 @@ sql_generic_schema_create(gpointer backend_data, gpointer _batch, gchar const* n
 	return TRUE;
 
 _error:
-	if (G_UNLIKELY(!_backend_batch_start(backend_data, batch, NULL)))
+	if (G_UNLIKELY(!internal_backend_batch_start(backend_data, batch, NULL)))
 	{
 		goto _error2;
 	}
@@ -426,7 +426,7 @@ sql_generic_schema_delete(gpointer backend_data, gpointer _batch, gchar const* n
 		}
 	}
 
-	if (G_UNLIKELY(!_backend_batch_execute(backend_data, batch, error)))
+	if (G_UNLIKELY(!internal_backend_batch_execute(backend_data, batch, error)))
 	{
 		//no ddl in transaction - most databases wont support that - continue without any open transaction
 		goto _error;
@@ -456,7 +456,7 @@ sql_generic_schema_delete(gpointer backend_data, gpointer _batch, gchar const* n
 		goto _error;
 	}
 
-	if (G_UNLIKELY(!_backend_batch_start(backend_data, batch, error)))
+	if (G_UNLIKELY(!internal_backend_batch_start(backend_data, batch, error)))
 	{
 		goto _error;
 	}
@@ -469,7 +469,7 @@ sql_generic_schema_delete(gpointer backend_data, gpointer _batch, gchar const* n
 		g_string_free(table_drop_sql, TRUE);
 	}
 
-	if (G_UNLIKELY(!_backend_batch_start(backend_data, batch, NULL)))
+	if (G_UNLIKELY(!internal_backend_batch_start(backend_data, batch, NULL)))
 	{
 		goto _error2;
 	}
diff --git a/lib/db-util/sql-generic-dml.c b/lib/db-util/sql-generic-dml.c
index 4b9279582..fe429e944 100644
--- a/lib/db-util/sql-generic-dml.c
+++ b/lib/db-util/sql-generic-dml.c
@@ -249,7 +249,7 @@ sql_generic_insert(gpointer backend_data, gpointer _batch, gchar const* name, bs
 
 _error:
 
-	if (G_UNLIKELY(!_backend_batch_abort(backend_data, batch, NULL)))
+	if (G_UNLIKELY(!internal_backend_batch_abort(backend_data, batch, NULL)))
 	{
 		goto _error2;
 	}
@@ -375,7 +375,7 @@ sql_generic_update(gpointer backend_data, gpointer _batch, gchar const* name, bs
 		}
 	}
 
-	if (G_UNLIKELY(!_backend_query_ids(backend_data, batch, name, selector, &matches, error)))
+	if (G_UNLIKELY(!internal_backend_query_ids(backend_data, batch, name, selector, &matches, error)))
 	{
 		goto _error;
 	}
@@ -439,7 +439,7 @@ sql_generic_update(gpointer backend_data, gpointer _batch, gchar const* name, bs
 	return TRUE;
 
 _error:
-	if (G_UNLIKELY(!_backend_batch_abort(backend_data, batch, NULL)))
+	if (G_UNLIKELY(!internal_backend_batch_abort(backend_data, batch, NULL)))
 	{
 		goto _error2;
 	}
@@ -470,7 +470,7 @@ sql_generic_delete(gpointer backend_data, gpointer _batch, gchar const* name, bs
 		goto _error;
 	}
 
-	if (G_UNLIKELY(!_backend_query_ids(backend_data, batch, name, selector, &matches, error)))
+	if (G_UNLIKELY(!internal_backend_query_ids(backend_data, batch, name, selector, &matches, error)))
 	{
 		goto _error;
 	}
@@ -520,7 +520,7 @@ sql_generic_delete(gpointer backend_data, gpointer _batch, gchar const* name, bs
 	return TRUE;
 
 _error:
-	if (G_UNLIKELY(!_backend_batch_abort(backend_data, batch, NULL)))
+	if (G_UNLIKELY(!internal_backend_batch_abort(backend_data, batch, NULL)))
 	{
 		goto _error2;
 	}
diff --git a/lib/db-util/sql-generic-dql.c b/lib/db-util/sql-generic-dql.c
index 4fc80bba5..e65e44d11 100644
--- a/lib/db-util/sql-generic-dql.c
+++ b/lib/db-util/sql-generic-dql.c
@@ -23,7 +23,7 @@
 #include "sql-generic-internal.h"
 
 gboolean
-_backend_schema_get(gpointer backend_data, gchar const* namespace, gchar const* name, bson_t* schema, GError** error)
+internal_backend_schema_get(gpointer backend_data, gchar const* namespace, gchar const* name, bson_t* schema, GError** error)
 {
 	J_TRACE_FUNCTION(NULL);
 
@@ -198,12 +198,11 @@ get_schema(gpointer backend_data, gchar const* namespace, gchar const* name, GEr
 		bson_iter_t iter;
 		gboolean has_next;
 		JDBTypeValue value;
-		gboolean schema_initialized = FALSE;
 		char const* string_tmp;
 
 		schema_map = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, NULL);
 
-		if (!(schema_initialized = _backend_schema_get(backend_data, namespace, name, &schema, error)))
+		if (!internal_backend_schema_get(backend_data, namespace, name, &schema, error))
 		{
 			goto _error;
 		}
@@ -292,11 +291,11 @@ sql_generic_schema_get(gpointer backend_data, gpointer _batch, gchar const* name
 	gboolean ret;
 	JSqlBatch* batch = _batch;
 
-	ret = _backend_schema_get(backend_data, batch->namespace, name, schema, error);
+	ret = internal_backend_schema_get(backend_data, batch->namespace, name, schema, error);
 
 	if (!ret)
 	{
-		_backend_batch_abort(backend_data, _batch, NULL);
+		internal_backend_batch_abort(backend_data, _batch, NULL);
 	}
 
 	return ret;
@@ -480,7 +479,7 @@ build_query_condition_part(gpointer backend_data, JSqlBatch* batch, bson_iter_t*
 }
 
 static gboolean
-_bind_selector_query(gpointer backend_data, const gchar* namespace, bson_iter_t* iter, JSqlStatement* statement, GHashTable* variable_types, guint64* position, GError** error)
+internal_bind_selector_query(gpointer backend_data, const gchar* namespace, bson_iter_t* iter, JSqlStatement* statement, GHashTable* variable_types, guint64* position, GError** error)
 {
 	J_TRACE_FUNCTION(NULL);
 
@@ -533,7 +532,7 @@ _bind_selector_query(gpointer backend_data, const gchar* namespace, bson_iter_t*
 				goto _error;
 			}
 
-			if (G_UNLIKELY(!_bind_selector_query(backend_data, namespace, &iterchild, statement, variable_types, position, error)))
+			if (G_UNLIKELY(!internal_bind_selector_query(backend_data, namespace, &iterchild, statement, variable_types, position, error)))
 			{
 				goto _error;
 			}
@@ -598,7 +597,7 @@ bind_selector_query(gpointer backend_data, const gchar* namespace, bson_iter_t*
 {
 	guint64 pos = 0;
 
-	return _bind_selector_query(backend_data, namespace, iter, statement, schema, &pos, error);
+	return internal_bind_selector_query(backend_data, namespace, iter, statement, schema, &pos, error);
 }
 
 static gboolean
@@ -823,7 +822,7 @@ build_query_join_part(bson_t const* selector, JSqlBatch* batch, GString* sql, GE
 }
 
 gboolean
-_backend_query_ids(gpointer backend_data, gpointer _batch, gchar const* name, bson_t const* selector, GArray** matches, GError** error)
+internal_backend_query_ids(gpointer backend_data, gpointer _batch, gchar const* name, bson_t const* selector, GArray** matches, GError** error)
 {
 	J_TRACE_FUNCTION(NULL);
 
diff --git a/lib/db-util/sql-generic-internal.h b/lib/db-util/sql-generic-internal.h
index 855572aa0..936374212 100644
--- a/lib/db-util/sql-generic-internal.h
+++ b/lib/db-util/sql-generic-internal.h
@@ -203,7 +203,7 @@ GString* j_sql_get_full_field_name(const gchar* namespace, const gchar* table, c
  * \param[out] error An uninitialized GError* for error code passing.
  * \return gboolean TRUE on success, FALSE otherwise.
  */
-gboolean _backend_schema_get(gpointer backend_data, gchar const* namespace, gchar const* name, bson_t* schema, GError** error);
+gboolean internal_backend_schema_get(gpointer backend_data, gchar const* namespace, gchar const* name, bson_t* schema, GError** error);
 
 /**
  * \brief Get the schema as a HashTable for internal usage.
@@ -263,7 +263,7 @@ gboolean bind_selector_query(gpointer backend_data, const gchar* namespace, bson
  * \param[out] error An uninitialized GError* for error code passing.
  * \return gboolean TRUE on success, FALSE otherwise.
  */
-gboolean _backend_query_ids(gpointer backend_data, gpointer _batch, gchar const* name, bson_t const* selector, GArray** matches, GError** error);
+gboolean internal_backend_query_ids(gpointer backend_data, gpointer _batch, gchar const* name, bson_t const* selector, GArray** matches, GError** error);
 
 // TCL
 
@@ -275,7 +275,7 @@ gboolean _backend_query_ids(gpointer backend_data, gpointer _batch, gchar const*
  * \param[out] error An uninitialized GError* for error code passing.
  * \return gboolean TRUE on success, FALSE otherwise.
  */
-gboolean _backend_batch_start(gpointer backend_data, JSqlBatch* batch, GError** error);
+gboolean internal_backend_batch_start(gpointer backend_data, JSqlBatch* batch, GError** error);
 
 /**
  * \brief Execute a batch. Commits a transaction in the DB backend.
@@ -285,7 +285,7 @@ gboolean _backend_batch_start(gpointer backend_data, JSqlBatch* batch, GError**
  * \param[out] error An uninitialized GError* for error code passing.
  * \return gboolean TRUE on success, FALSE otherwise.
  */
-gboolean _backend_batch_execute(gpointer backend_data, JSqlBatch* batch, GError** error);
+gboolean internal_backend_batch_execute(gpointer backend_data, JSqlBatch* batch, GError** error);
 
 /**
  * \brief Abort a batch. Triggers a rollback in the DB backend.
@@ -295,6 +295,6 @@ gboolean _backend_batch_execute(gpointer backend_data, JSqlBatch* batch, GError*
  * \param[out] error An uninitialized GError* for error code passing.
  * \return gboolean TRUE on success, FALSE otherwise.
  */
-gboolean _backend_batch_abort(gpointer backend_data, JSqlBatch* batch, GError** error);
+gboolean internal_backend_batch_abort(gpointer backend_data, JSqlBatch* batch, GError** error);
 
 #endif
diff --git a/lib/db-util/sql-generic-tcl.c b/lib/db-util/sql-generic-tcl.c
index bdfc04e59..41efad8f1 100644
--- a/lib/db-util/sql-generic-tcl.c
+++ b/lib/db-util/sql-generic-tcl.c
@@ -22,7 +22,7 @@
 #include "sql-generic-internal.h"
 
 gboolean
-_backend_batch_start(gpointer backend_data, JSqlBatch* batch, GError** error)
+internal_backend_batch_start(gpointer backend_data, JSqlBatch* batch, GError** error)
 {
 	J_TRACE_FUNCTION(NULL);
 
@@ -50,7 +50,7 @@ _backend_batch_start(gpointer backend_data, JSqlBatch* batch, GError** error)
 }
 
 gboolean
-_backend_batch_execute(gpointer backend_data, JSqlBatch* batch, GError** error)
+internal_backend_batch_execute(gpointer backend_data, JSqlBatch* batch, GError** error)
 {
 	J_TRACE_FUNCTION(NULL);
 
@@ -77,7 +77,7 @@ _backend_batch_execute(gpointer backend_data, JSqlBatch* batch, GError** error)
 }
 
 gboolean
-_backend_batch_abort(gpointer backend_data, JSqlBatch* batch, GError** error)
+internal_backend_batch_abort(gpointer backend_data, JSqlBatch* batch, GError** error)
 {
 	J_TRACE_FUNCTION(NULL);
 
@@ -126,7 +126,7 @@ sql_generic_batch_start(gpointer backend_data, gchar const* namespace, JSemantic
 	batch->open = FALSE;
 	batch->aborted = FALSE;
 
-	if (G_UNLIKELY(!_backend_batch_start(backend_data, batch, error)))
+	if (G_UNLIKELY(!internal_backend_batch_start(backend_data, batch, error)))
 	{
 		goto _error;
 	}
@@ -154,7 +154,7 @@ sql_generic_batch_execute(gpointer backend_data, gpointer _batch, GError** error
 
 	g_return_val_if_fail(batch != NULL, FALSE);
 
-	if (G_UNLIKELY(!_backend_batch_execute(backend_data, batch, error)))
+	if (G_UNLIKELY(!internal_backend_batch_execute(backend_data, batch, error)))
 	{
 		goto _error;
 	}
diff --git a/lib/db/jdb-entry.c b/lib/db/jdb-entry.c
index feaa20504..043116a38 100644
--- a/lib/db/jdb-entry.c
+++ b/lib/db/jdb-entry.c
@@ -233,7 +233,10 @@ j_db_entry_delete(JDBEntry* entry, JDBSelector* selector, JBatch* batch, GError*
 	g_return_val_if_fail(batch != NULL, FALSE);
 	g_return_val_if_fail((selector == NULL) || (selector->schema == entry->schema), FALSE);
 	g_return_val_if_fail(error == NULL || *error == NULL, FALSE);
-	g_return_val_if_fail(g_hash_table_size(selector->join_schema) < 2, FALSE); // no cross-table deletes
+	if (selector != NULL && selector->join_schema != NULL)
+	{
+		g_return_val_if_fail(g_hash_table_size(selector->join_schema) < 2, FALSE); // no cross-table deletes
+	}
 
 	if (G_UNLIKELY(!j_db_internal_delete(entry, selector, batch, error)))
 	{
diff --git a/lib/item/jcollection.c b/lib/item/jcollection.c
index 6366c1f28..9e3a9b596 100644
--- a/lib/item/jcollection.c
+++ b/lib/item/jcollection.c
@@ -29,9 +29,6 @@
 #include <item/jcollection.h>
 #include <item/jcollection-internal.h>
 
-#include <item/jitem.h>
-#include <item/jitem-internal.h>
-
 #include <julea.h>
 #include <julea-kv.h>
 
diff --git a/lib/object/jdistributed-object.c b/lib/object/jdistributed-object.c
index bee78b101..60d4effac 100644
--- a/lib/object/jdistributed-object.c
+++ b/lib/object/jdistributed-object.c
@@ -624,7 +624,7 @@ j_distributed_object_create_exec(JList* operations, JSemantics* semantics)
 		}
 		else
 		{
-			gpointer object_handle;
+			gpointer object_handle = NULL;
 
 			ret = j_backend_object_create(object_backend, object->namespace, object->name, &object_handle) && ret;
 			ret = j_backend_object_close(object_backend, object_handle) && ret;
@@ -721,7 +721,7 @@ j_distributed_object_delete_exec(JList* operations, JSemantics* semantics)
 		else
 		{
 			gboolean lret = FALSE;
-			gpointer object_handle;
+			gpointer object_handle = NULL;
 
 			if (j_backend_object_open(object_backend, object->namespace, object->name, &object_handle)
 			    && j_backend_object_delete(object_backend, object_handle))
@@ -782,7 +782,7 @@ j_distributed_object_read_exec(JList* operations, JSemantics* semantics)
 	g_autoptr(JListIterator) it = NULL;
 	g_autofree JMessage** messages = NULL;
 	JDistributedObject* object = NULL;
-	gpointer object_handle;
+	gpointer object_handle = NULL;
 	gsize name_len = 0;
 	gsize namespace_len = 0;
 	guint32 server_count = 0;
@@ -972,7 +972,7 @@ j_distributed_object_write_exec(JList* operations, JSemantics* semantics)
 	g_autoptr(JListIterator) it = NULL;
 	g_autofree JMessage** messages = NULL;
 	JDistributedObject* object = NULL;
-	gpointer object_handle;
+	gpointer object_handle = NULL;
 	gsize name_len = 0;
 	gsize namespace_len = 0;
 	guint32 server_count = 0;
@@ -1228,7 +1228,7 @@ j_distributed_object_status_exec(JList* operations, JSemantics* semantics)
 		}
 		else
 		{
-			gpointer object_handle;
+			gpointer object_handle = NULL;
 
 			ret = j_backend_object_open(object_backend, object->namespace, object->name, &object_handle) && ret;
 			ret = j_backend_object_status(object_backend, object_handle, modification_time, size) && ret;
@@ -1328,7 +1328,7 @@ j_distributed_object_sync_exec(JList* operations, JSemantics* semantics)
 		}
 		else
 		{
-			gpointer object_handle;
+			gpointer object_handle = NULL;
 
 			ret = j_backend_object_open(object_backend, object->namespace, object->name, &object_handle) && ret;
 			ret = j_backend_object_sync(object_backend, object_handle) && ret;
diff --git a/lib/object/jobject.c b/lib/object/jobject.c
index 2a8212c90..fccb31e6a 100644
--- a/lib/object/jobject.c
+++ b/lib/object/jobject.c
@@ -289,7 +289,7 @@ j_object_create_exec(JList* operations, JSemantics* semantics)
 		}
 		else
 		{
-			gpointer object_handle;
+			gpointer object_handle = NULL;
 
 			ret = j_backend_object_create(object_backend, object->namespace, object->name, &object_handle) && ret;
 			ret = j_backend_object_close(object_backend, object_handle) && ret;
@@ -376,7 +376,7 @@ j_object_delete_exec(JList* operations, JSemantics* semantics)
 		else
 		{
 			gboolean lret = FALSE;
-			gpointer object_handle;
+			gpointer object_handle = NULL;
 
 			if (j_backend_object_open(object_backend, object->namespace, object->name, &object_handle)
 			    && j_backend_object_delete(object_backend, object_handle))
@@ -435,7 +435,7 @@ j_object_read_exec(JList* operations, JSemantics* semantics)
 	JListIterator* it;
 	g_autoptr(JMessage) message = NULL;
 	JObject* object;
-	gpointer object_handle;
+	gpointer object_handle = NULL;
 
 	/// \todo
 	//JLock* lock = NULL;
@@ -602,7 +602,7 @@ j_object_write_exec(JList* operations, JSemantics* semantics)
 	JListIterator* it;
 	g_autoptr(JMessage) message = NULL;
 	JObject* object;
-	gpointer object_handle;
+	gpointer object_handle = NULL;
 
 	/// \todo
 	//JLock* lock = NULL;
@@ -807,7 +807,7 @@ j_object_status_exec(JList* operations, JSemantics* semantics)
 		}
 		else
 		{
-			gpointer object_handle;
+			gpointer object_handle = NULL;
 
 			ret = j_backend_object_open(object_backend, object->namespace, object->name, &object_handle) && ret;
 			ret = j_backend_object_status(object_backend, object_handle, modification_time, size) && ret;
@@ -916,7 +916,7 @@ j_object_sync_exec(JList* operations, JSemantics* semantics)
 		}
 		else
 		{
-			gpointer object_handle;
+			gpointer object_handle = NULL;
 
 			ret = j_backend_object_open(object_backend, object->namespace, object->name, &object_handle) && ret;
 			ret = j_backend_object_sync(object_backend, object_handle) && ret;
diff --git a/server/server.c b/server/server.c
index 08a33a1c5..1ac5a8dd9 100644
--- a/server/server.c
+++ b/server/server.c
@@ -285,7 +285,12 @@ main(int argc, char** argv)
 	};
 
 	// Explicitly enable UTF-8 since functions such as g_format_size might return UTF-8 characters.
-	setlocale(LC_ALL, "C.UTF-8");
+	g_autofree const char* local_result = setlocale(LC_ALL, "C.UTF-8");
+	if (local_result == NULL)
+	{
+		g_warning("Failed to set locale!");
+		return 1;
+	}
 
 	context = g_option_context_new(NULL);
 	g_option_context_add_main_entries(context, entries, NULL);
diff --git a/test/core/batch.c b/test/core/batch.c
index a02093f80..f8e349946 100644
--- a/test/core/batch.c
+++ b/test/core/batch.c
@@ -86,7 +86,7 @@ test_batch_execute_empty(void)
 }
 
 static void
-_test_batch_execute(gboolean async)
+helper_fn_test_batch_execute(gboolean async)
 {
 	g_autoptr(JCollection) collection = NULL;
 	g_autoptr(JItem) item = NULL;
@@ -126,7 +126,7 @@ static void
 test_batch_execute(void)
 {
 	J_TEST_TRAP_START;
-	_test_batch_execute(FALSE);
+	helper_fn_test_batch_execute(FALSE);
 	J_TEST_TRAP_END;
 }
 
@@ -134,7 +134,7 @@ static void
 test_batch_execute_async(void)
 {
 	J_TEST_TRAP_START;
-	_test_batch_execute(TRUE);
+	helper_fn_test_batch_execute(TRUE);
 	J_TEST_TRAP_END;
 }
 
diff --git a/test/item/uri.c b/test/item/uri.c
index 65a12f8d2..06f2b63fb 100644
--- a/test/item/uri.c
+++ b/test/item/uri.c
@@ -28,10 +28,11 @@
 static void
 test_uri_new_free(void)
 {
-	g_autoptr(JURI) uri = NULL;
+	JURI* uri = NULL;
 
 	J_TEST_TRAP_START;
 	uri = j_uri_new("julea://JULEA");
+	j_uri_free(uri);
 	J_TEST_TRAP_END;
 }
 
diff --git a/test/test.c b/test/test.c
index 5228febae..a540d41b1 100644
--- a/test/test.c
+++ b/test/test.c
@@ -32,7 +32,12 @@ main(int argc, char** argv)
 	gint ret;
 
 	// Explicitly enable UTF-8 since functions such as g_format_size might return UTF-8 characters.
-	setlocale(LC_ALL, "C.UTF-8");
+	g_autofree const char* local_result = setlocale(LC_ALL, "C.UTF-8");
+	if (local_result == NULL)
+	{
+		g_warning("Failed to set locale!");
+		return 1;
+	}
 
 	g_test_init(&argc, &argv, NULL);
 
diff --git a/tools/config.c b/tools/config.c
index 09c59e54e..63448a1d8 100644
--- a/tools/config.c
+++ b/tools/config.c
@@ -172,7 +172,12 @@ main(gint argc, gchar** argv)
 	};
 
 	// Explicitly enable UTF-8 since functions such as g_format_size might return UTF-8 characters.
-	setlocale(LC_ALL, "C.UTF-8");
+	g_autofree const char* local_result = setlocale(LC_ALL, "C.UTF-8");
+	if (local_result == NULL)
+	{
+		g_warning("Failed to set locale!");
+		return 1;
+	}
 
 	context = g_option_context_new(NULL);
 	g_option_context_add_main_entries(context, entries, NULL);
diff --git a/tools/statistics.c b/tools/statistics.c
index f76d820a7..c9cb57a73 100644
--- a/tools/statistics.c
+++ b/tools/statistics.c
@@ -64,12 +64,17 @@ main(int argc, char** argv)
 	JStatistics* statistics_total;
 	gchar get_all;
 
+	// Explicitly enable UTF-8 since functions such as g_format_size might return UTF-8 characters.
+	g_autofree const char* local_result = setlocale(LC_ALL, "C.UTF-8");
+	if (local_result == NULL)
+	{
+		g_warning("Failed to set locale!");
+		return 1;
+	}
+
 	(void)argc;
 	(void)argv;
 
-	// Explicitly enable UTF-8 since functions such as g_format_size might return UTF-8 characters.
-	setlocale(LC_ALL, "C.UTF-8");
-
 	get_all = 1;
 	configuration = j_configuration();
 	statistics_total = j_statistics_new(FALSE);