native_dynamic_relational.c

Go to the documentation of this file.

#include "native_dynamic_relational.h"
 
#include "native_dynamic_config.h"
#include "native_fs.h"
#include "native_support.h"
#include "native_yyjson_helpers.h"
 
#include <sqlite3.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
 
#define PHAROS_SQLITE_BUSY_TIMEOUT_MS_RUNTIME 15000
#ifndef _WIN32
#include <dlfcn.h>
#endif
 
/**
 * @brief Carries resolved PostgreSQL runtime connection settings.
 */
typedef struct {
  char *host;
  char *port;
  char *database;
  char *user;
  char *password_env_name;
  char *tls_mode;
  char *tls_root_cert;
  char *tls_cert;
  char *tls_key;
} NativeDynamicPostgresqlRuntimeConfig;
 
typedef struct pg_conn PGconn;
typedef struct pg_result PGresult;
 
typedef struct {
#ifndef _WIN32
  void *handle;
#endif
  PGconn *(*PQconnectdb)(const char *conninfo);
  int (*PQstatus)(const PGconn *conn);
  char *(*PQerrorMessage)(const PGconn *conn);
  PGresult *(*PQexec)(PGconn *conn, const char *query);
  int (*PQresultStatus)(const PGresult *res);
  int (*PQntuples)(const PGresult *res);
  int (*PQnfields)(const PGresult *res);
  char *(*PQgetvalue)(const PGresult *res, int row_number, int column_number);
  void (*PQclear)(PGresult *res);
  void (*PQfinish)(PGconn *conn);
} NativeDynamicLibpqApi;
 
#define PHAROS_CONN_STATUS_OK_RUNTIME 0
#define PHAROS_PGRES_COMMAND_OK_RUNTIME 1
#define PHAROS_PGRES_TUPLES_OK_RUNTIME 2
#define PHAROS_PGRES_SINGLE_TUPLE_RUNTIME 9
 
static yyjson_val *migration_backend_record_runtime_local(yyjson_val *root, const char *backend_value) {
  yyjson_val *backends = native_json_obj_get_array(root, "backends");
  yyjson_arr_iter iter;
  yyjson_val *item = NULL;
  if (backends == NULL || backend_value == NULL || !yyjson_arr_iter_init(backends, &iter)) {
    return NULL;
  }
  while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
    yyjson_val *backend = native_json_obj_get(item, "backend");
    if (yyjson_is_str(backend) && yyjson_equals_str(backend, backend_value)) {
      return item;
    }
  }
  return NULL;
}
 
static char *migration_fixture_path_dup_runtime_local(const char *app_root) {
  return app_root != NULL ? path_join(app_root, "data/framework/migration-fixture-v1.json") : NULL;
}
 
static char *runtime_state_export_sqlite_path_dup_runtime_local(const char *app_root) {
  return app_root != NULL ? path_join(app_root, "data/framework/runtime-state-export-sqlite.sql") : NULL;
}
 
static char *runtime_state_import_sqlite_path_dup_runtime_local(const char *app_root) {
  return app_root != NULL ? path_join(app_root, "data/framework/runtime-state-import-sqlite.sql") : NULL;
}
 
static char *runtime_state_export_postgresql_path_dup_runtime_local(const char *app_root) {
  return app_root != NULL ? path_join(app_root, "data/framework/runtime-state-export-postgresql.sql") : NULL;
}
 
static char *runtime_state_import_postgresql_path_dup_runtime_local(const char *app_root) {
  return app_root != NULL ? path_join(app_root, "data/framework/runtime-state-import-postgresql.sql") : NULL;
}
 
static int sqlite_configure_connection_runtime_local(sqlite3 *db) {
  if (db == NULL) {
    return 69;
  }
  sqlite3_busy_timeout(db, PHAROS_SQLITE_BUSY_TIMEOUT_MS_RUNTIME);
  if (sqlite3_exec(db, "PRAGMA journal_mode=WAL;", NULL, NULL, NULL) != SQLITE_OK) {
    return 69;
  }
  if (sqlite3_exec(db, "PRAGMA synchronous=NORMAL;", NULL, NULL, NULL) != SQLITE_OK) {
    return 69;
  }
  return 0;
}
 
static char *sqlite_exec_first_value_dup_runtime_local(const char *sqlite_path, const char *sql_text) {
  sqlite3 *db = NULL;
  sqlite3_stmt *stmt = NULL;
  char *value = NULL;
  int step_result = SQLITE_DONE;
  if (sqlite_path == NULL || sql_text == NULL) {
    return NULL;
  }
  if (sqlite3_open(sqlite_path, &db) != SQLITE_OK) {
    if (db != NULL) {
      sqlite3_close(db);
    }
    return NULL;
  }
  if (sqlite_configure_connection_runtime_local(db) != 0) {
    sqlite3_close(db);
    return NULL;
  }
  if (sqlite3_prepare_v2(db, sql_text, -1, &stmt, NULL) != SQLITE_OK) {
    sqlite3_close(db);
    return NULL;
  }
  step_result = sqlite3_step(stmt);
  if (step_result == SQLITE_ROW) {
    const unsigned char *text = sqlite3_column_text(stmt, 0);
    value = strdup(text != NULL ? (const char *)text : "");
  }
  sqlite3_finalize(stmt);
  sqlite3_close(db);
  return value;
}
 
static int sqlite_exec_runtime_local(const char *sqlite_path, const char *sql_text) {
  sqlite3 *db = NULL;
  char *error_message = NULL;
  int code = 69;
  if (sqlite_path == NULL || sql_text == NULL) {
    return 64;
  }
  if (sqlite3_open(sqlite_path, &db) != SQLITE_OK) {
    if (db != NULL) {
      sqlite3_close(db);
    }
    return 69;
  }
  if (sqlite_configure_connection_runtime_local(db) != 0) {
    sqlite3_close(db);
    return 69;
  }
  if (sqlite3_exec(db, sql_text, NULL, NULL, &error_message) == SQLITE_OK) {
    code = 0;
  }
  sqlite3_free(error_message);
  sqlite3_close(db);
  return code;
}
 
static int sqlite_apply_file_list_runtime_local(const char *sqlite_path, const char *app_root, yyjson_val *list) {
  yyjson_arr_iter iter;
  yyjson_val *item = NULL;
  if (sqlite_path == NULL || app_root == NULL || list == NULL || !yyjson_arr_iter_init(list, &iter)) {
    return 69;
  }
  while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
    char *resolved_path = NULL;
    char *sql_text = NULL;
    int code = 0;
    if (!yyjson_is_str(item)) {
      return 69;
    }
    resolved_path = resolve_relative_to(app_root, yyjson_get_str(item));
    sql_text = resolved_path != NULL ? read_file_text(resolved_path) : NULL;
    free(resolved_path);
    if (sql_text == NULL) {
      free(sql_text);
      return 66;
    }
    code = sqlite_exec_runtime_local(sqlite_path, sql_text);
    free(sql_text);
    if (code != 0) {
      return code;
    }
  }
  return 0;
}
 
static char *checksum_string_dup_runtime_local(const char *value) {
  const unsigned char *cursor = (const unsigned char *)(value != NULL ? value : "");
  unsigned long long hash = 1469598103934665603ULL;
  char *out = (char *)malloc(17);
  if (out == NULL) {
    return NULL;
  }
  while (*cursor != '\0') {
    hash ^= (unsigned long long)(*cursor++);
    hash *= 1099511628211ULL;
  }
  snprintf(out, 17, "%016llx", hash);
  return out;
}
 
static char *migration_expected_checksum_dup_runtime_local(const char *app_root, yyjson_val *migration_record, const char *backend) {
  yyjson_val *backend_files = NULL;
  yyjson_val *backend_record = NULL;
  yyjson_val *forward_files = NULL;
  yyjson_arr_iter iter;
  yyjson_val *item = NULL;
  Buffer combined;
  char *forward_checksum = NULL;
  char *migration_id = NULL;
  char *payload = NULL;
  char *result = NULL;
 
  if (app_root == NULL || migration_record == NULL || backend == NULL) {
    return NULL;
  }
 
  backend_files = native_json_obj_get(migration_record, "backend_files");
  backend_record = backend_files != NULL && yyjson_is_obj(backend_files) ? native_json_obj_get(backend_files, backend) : NULL;
  forward_files = backend_record != NULL ? native_json_obj_get_array(backend_record, "forward_sql_files") : NULL;
 
  buffer_init(&combined);
  if (forward_files != NULL && yyjson_arr_iter_init(forward_files, &iter)) {
    while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
      char *resolved_path = NULL;
      char *file_text = NULL;
      if (!yyjson_is_str(item)) {
        buffer_free(&combined);
        return NULL;
      }
      resolved_path = resolve_relative_to(app_root, yyjson_get_str(item));
      if (resolved_path != NULL && path_exists(resolved_path)) {
        file_text = read_file_text(resolved_path);
        if (file_text != NULL && buffer_append(&combined, file_text, strlen(file_text)) != 0) {
          free(file_text);
          free(resolved_path);
          buffer_free(&combined);
          return NULL;
        }
        free(file_text);
      }
      if (resolved_path != NULL) {
        if (buffer_append(&combined, "\n-- pharos-path: ", strlen("\n-- pharos-path: ")) != 0
            || buffer_append(&combined, resolved_path, strlen(resolved_path)) != 0
            || buffer_append(&combined, "\n", 1) != 0) {
          free(resolved_path);
          buffer_free(&combined);
          return NULL;
        }
      }
      free(resolved_path);
    }
  }
 
  forward_checksum = checksum_string_dup_runtime_local(combined.data != NULL ? combined.data : "");
  buffer_free(&combined);
  migration_id = native_json_obj_get_string_dup(migration_record, "migration_id");
  if (migration_id == NULL || forward_checksum == NULL) {
    free(migration_id);
    free(forward_checksum);
    return NULL;
  }
 
  payload = (char *)malloc(strlen(migration_id) + strlen(backend) + strlen(forward_checksum) + 64);
  if (payload != NULL) {
    snprintf(payload, strlen(migration_id) + strlen(backend) + strlen(forward_checksum) + 64,
      "migration_id=%s\nbackend=%s\nforward_checksum=%s",
      migration_id,
      backend,
      forward_checksum);
    result = checksum_string_dup_runtime_local(payload);
  }
 
  free(payload);
  free(migration_id);
  free(forward_checksum);
  return result;
}
 
static void free_postgresql_runtime_config_runtime_local(NativeDynamicPostgresqlRuntimeConfig *config) {
  if (config == NULL) {
    return;
  }
  free(config->host);
  free(config->port);
  free(config->database);
  free(config->user);
  free(config->password_env_name);
  free(config->tls_mode);
  free(config->tls_root_cert);
  free(config->tls_cert);
  free(config->tls_key);
  memset(config, 0, sizeof(*config));
}
 
static int load_postgresql_runtime_config_runtime_local(
  const char *app_root,
  const char *runtime_conf_path,
  NativeDynamicPostgresqlRuntimeConfig *config
) {
  if (app_root == NULL || app_root[0] == '\0' || config == NULL) {
    return 0;
  }
  memset(config, 0, sizeof(*config));
  config->host = native_dynamic_config_merged_value_dup(app_root, runtime_conf_path, "db_host");
  config->port = native_dynamic_config_merged_value_dup(app_root, runtime_conf_path, "db_port");
  config->database = native_dynamic_config_merged_value_dup(app_root, runtime_conf_path, "db_name");
  config->user = native_dynamic_config_merged_value_dup(app_root, runtime_conf_path, "db_user");
  config->password_env_name = native_dynamic_config_merged_value_dup(app_root, runtime_conf_path, "db_password_env");
  config->tls_mode = native_dynamic_config_merged_value_dup(app_root, runtime_conf_path, "db_tls_mode");
  config->tls_root_cert = native_dynamic_config_merged_value_dup(app_root, runtime_conf_path, "db_tls_root_cert");
  config->tls_cert = native_dynamic_config_merged_value_dup(app_root, runtime_conf_path, "db_tls_cert");
  config->tls_key = native_dynamic_config_merged_value_dup(app_root, runtime_conf_path, "db_tls_key");
  if (config->tls_mode == NULL || config->tls_mode[0] == '\0') {
    free(config->tls_mode);
    config->tls_mode = strdup("require");
  }
  if (config->host == NULL || config->host[0] == '\0'
      || config->port == NULL || config->port[0] == '\0'
      || config->database == NULL || config->database[0] == '\0'
      || config->user == NULL || config->user[0] == '\0'
      || config->tls_mode == NULL || config->tls_mode[0] == '\0') {
    free_postgresql_runtime_config_runtime_local(config);
    return 0;
  }
  if (!(streq(config->tls_mode, "disable") || streq(config->tls_mode, "allow") || streq(config->tls_mode, "prefer")
        || streq(config->tls_mode, "require") || streq(config->tls_mode, "verify-ca") || streq(config->tls_mode, "verify-full"))) {
    free_postgresql_runtime_config_runtime_local(config);
    return 0;
  }
  if ((config->tls_root_cert != NULL && config->tls_root_cert[0] != '\0' && !path_exists(config->tls_root_cert))
      || (config->tls_cert != NULL && config->tls_cert[0] != '\0' && !path_exists(config->tls_cert))
      || (config->tls_key != NULL && config->tls_key[0] != '\0' && !path_exists(config->tls_key))) {
    free_postgresql_runtime_config_runtime_local(config);
    return 0;
  }
  return 1;
}
 
static int conninfo_append_kv_runtime_local(Buffer *buffer, const char *key, const char *value, int escape_quotes) {
  const char *cursor = value != NULL ? value : "";
  if (buffer == NULL || key == NULL || key[0] == '\0' || value == NULL || value[0] == '\0') {
    return 0;
  }
  if (buffer->len > 0 && buffer_append(buffer, " ", 1) != 0) {
    return 0;
  }
  if (buffer_append(buffer, key, strlen(key)) != 0
      || buffer_append(buffer, "='", 2) != 0) {
    return 0;
  }
  while (*cursor != '\0') {
    if (escape_quotes && (*cursor == '\\' || *cursor == '\'')) {
      if (buffer_append(buffer, "\\", 1) != 0) {
        return 0;
      }
    }
    if (buffer_append(buffer, cursor, 1) != 0) {
      return 0;
    }
    cursor++;
  }
  return buffer_append(buffer, "'", 1) == 0;
}
 
#ifndef _WIN32
static void *open_libpq_handle_candidate_runtime_local(const char *path) {
  if (path == NULL || path[0] == '\0') {
    return NULL;
  }
  return dlopen(path, RTLD_NOW | RTLD_LOCAL);
}
#endif
 
static int load_native_libpq_api_runtime_local(NativeDynamicLibpqApi *api) {
#ifndef _WIN32
  static const char *const basenames[] = {"libpq.5.dylib", "libpq.dylib", "libpq.so.5", "libpq.so", NULL};
  const char *prefix = NULL;
  size_t index = 0;
#endif
  if (api == NULL) {
    return 0;
  }
  memset(api, 0, sizeof(*api));
#ifdef _WIN32
  return 0;
#else
  prefix = getenv("PHAROS_LIBPQ_PREFIX");
  if (prefix != NULL && prefix[0] != '\0') {
    char *lib_dir = path_join(prefix, "lib");
    if (lib_dir != NULL) {
      for (index = 0; basenames[index] != NULL && api->handle == NULL; index++) {
        char *candidate = path_join(lib_dir, basenames[index]);
        if (candidate != NULL && path_exists(candidate)) {
          api->handle = open_libpq_handle_candidate_runtime_local(candidate);
        }
        free(candidate);
      }
      free(lib_dir);
    }
  }
  for (index = 0; basenames[index] != NULL && api->handle == NULL; index++) {
    api->handle = open_libpq_handle_candidate_runtime_local(basenames[index]);
  }
  if (api->handle == NULL) {
    return 0;
  }
  api->PQconnectdb = (PGconn *(*)(const char *))dlsym(api->handle, "PQconnectdb");
  api->PQstatus = (int (*)(const PGconn *))dlsym(api->handle, "PQstatus");
  api->PQerrorMessage = (char *(*)(const PGconn *))dlsym(api->handle, "PQerrorMessage");
  api->PQexec = (PGresult *(*)(PGconn *, const char *))dlsym(api->handle, "PQexec");
  api->PQresultStatus = (int (*)(const PGresult *))dlsym(api->handle, "PQresultStatus");
  api->PQntuples = (int (*)(const PGresult *))dlsym(api->handle, "PQntuples");
  api->PQnfields = (int (*)(const PGresult *))dlsym(api->handle, "PQnfields");
  api->PQgetvalue = (char *(*)(const PGresult *, int, int))dlsym(api->handle, "PQgetvalue");
  api->PQclear = (void (*)(PGresult *))dlsym(api->handle, "PQclear");
  api->PQfinish = (void (*)(PGconn *))dlsym(api->handle, "PQfinish");
  if (api->PQconnectdb == NULL || api->PQstatus == NULL || api->PQerrorMessage == NULL || api->PQexec == NULL
      || api->PQresultStatus == NULL || api->PQntuples == NULL || api->PQnfields == NULL || api->PQgetvalue == NULL
      || api->PQclear == NULL || api->PQfinish == NULL) {
    dlclose(api->handle);
    memset(api, 0, sizeof(*api));
    return 0;
  }
  return 1;
#endif
}
 
static void free_native_libpq_api_runtime_local(NativeDynamicLibpqApi *api) {
#ifndef _WIN32
  if (api != NULL && api->handle != NULL) {
    dlclose(api->handle);
  }
#endif
  if (api != NULL) {
    memset(api, 0, sizeof(*api));
  }
}
 
static char *postgresql_conninfo_dup_runtime_local(const NativeDynamicPostgresqlRuntimeConfig *config) {
  Buffer buffer;
  const char *password_value = NULL;
  char *result = NULL;
  if (config == NULL) {
    return NULL;
  }
  buffer_init(&buffer);
  if (!conninfo_append_kv_runtime_local(&buffer, "host", config->host, 1)
      || !conninfo_append_kv_runtime_local(&buffer, "port", config->port, 1)
      || !conninfo_append_kv_runtime_local(&buffer, "dbname", config->database, 1)
      || !conninfo_append_kv_runtime_local(&buffer, "user", config->user, 1)
      || !conninfo_append_kv_runtime_local(&buffer, "sslmode", config->tls_mode, 1)) {
    buffer_free(&buffer);
    return NULL;
  }
  if (config->password_env_name != NULL && config->password_env_name[0] != '\0') {
    password_value = getenv(config->password_env_name);
    if (password_value != NULL && password_value[0] != '\0' && !conninfo_append_kv_runtime_local(&buffer, "password", password_value, 1)) {
      buffer_free(&buffer);
      return NULL;
    }
  }
  if ((config->tls_root_cert != NULL && config->tls_root_cert[0] != '\0' && !conninfo_append_kv_runtime_local(&buffer, "sslrootcert", config->tls_root_cert, 1))
      || (config->tls_cert != NULL && config->tls_cert[0] != '\0' && !conninfo_append_kv_runtime_local(&buffer, "sslcert", config->tls_cert, 1))
      || (config->tls_key != NULL && config->tls_key[0] != '\0' && !conninfo_append_kv_runtime_local(&buffer, "sslkey", config->tls_key, 1))) {
    buffer_free(&buffer);
    return NULL;
  }
  result = buffer.data;
  if (result == NULL) {
    result = strdup("");
  }
  buffer.data = NULL;
  buffer_free(&buffer);
  return result;
}
 
static int capture_postgresql_result_output_runtime_local(
  const NativeDynamicLibpqApi *api,
  PGresult *result,
  char **output_out
) {
  Buffer buffer;
  int row_count = 0;
  int column_count = 0;
  int row_index = 0;
  int column_index = 0;
  if (output_out != NULL) {
    *output_out = NULL;
  }
  if (api == NULL || result == NULL || output_out == NULL) {
    return 64;
  }
  buffer_init(&buffer);
  row_count = api->PQntuples(result);
  column_count = api->PQnfields(result);
  for (row_index = 0; row_index < row_count; row_index++) {
    for (column_index = 0; column_index < column_count; column_index++) {
      const char *value = api->PQgetvalue(result, row_index, column_index);
      if (column_index > 0 && buffer_append(&buffer, "|", 1) != 0) {
        buffer_free(&buffer);
        return 69;
      }
      if (value != NULL && buffer_append(&buffer, value, strlen(value)) != 0) {
        buffer_free(&buffer);
        return 69;
      }
    }
    if (row_index + 1 < row_count && buffer_append(&buffer, "\n", 1) != 0) {
      buffer_free(&buffer);
      return 69;
    }
  }
  *output_out = buffer.data != NULL ? buffer.data : strdup("");
  buffer.data = NULL;
  buffer_free(&buffer);
  if (*output_out == NULL) {
    return 69;
  }
  trim_in_place(*output_out);
  return 0;
}
 
static int run_postgresql_sql_capture_runtime_local(
  const NativeDynamicPostgresqlRuntimeConfig *config,
  const char *sql_text,
  int capture_output,
  char **output_out
) {
  NativeDynamicLibpqApi api = {0};
  PGconn *connection = NULL;
  PGresult *result = NULL;
  char *conninfo = NULL;
  int status = 0;
  int code = 69;
  if (output_out != NULL) {
    *output_out = NULL;
  }
  if (config == NULL || sql_text == NULL) {
    return 64;
  }
  if (!load_native_libpq_api_runtime_local(&api)) {
    return 69;
  }
  conninfo = postgresql_conninfo_dup_runtime_local(config);
  connection = conninfo != NULL ? api.PQconnectdb(conninfo) : NULL;
  if (connection == NULL || api.PQstatus(connection) != PHAROS_CONN_STATUS_OK_RUNTIME) {
    fprintf(stderr, "postgresql_runtime_error stage=connect message=%s\n", connection != NULL && api.PQerrorMessage != NULL ? api.PQerrorMessage(connection) : "connection_failed");
    goto cleanup;
  }
  result = api.PQexec(connection, sql_text);
  if (result == NULL) {
    fprintf(stderr, "postgresql_runtime_error stage=exec message=%s\n", api.PQerrorMessage != NULL ? api.PQerrorMessage(connection) : "exec_failed");
    goto cleanup;
  }
  status = api.PQresultStatus(result);
  if (capture_output) {
    if (status != PHAROS_PGRES_TUPLES_OK_RUNTIME && status != PHAROS_PGRES_SINGLE_TUPLE_RUNTIME) {
      fprintf(stderr, "postgresql_runtime_error stage=capture status=%d message=%s\n", status, api.PQerrorMessage != NULL ? api.PQerrorMessage(connection) : "capture_failed");
      goto cleanup;
    }
    code = capture_postgresql_result_output_runtime_local(&api, result, output_out);
  } else if (status == PHAROS_PGRES_COMMAND_OK_RUNTIME || status == PHAROS_PGRES_TUPLES_OK_RUNTIME || status == PHAROS_PGRES_SINGLE_TUPLE_RUNTIME) {
    code = 0;
  } else {
    fprintf(stderr, "postgresql_runtime_error stage=status status=%d message=%s\n", status, api.PQerrorMessage != NULL ? api.PQerrorMessage(connection) : "status_failed");
  }
cleanup:
  if (result != NULL) {
    api.PQclear(result);
  }
  if (connection != NULL) {
    api.PQfinish(connection);
  }
  free(conninfo);
  free_native_libpq_api_runtime_local(&api);
  return code;
}
 
static int postgresql_apply_file_list_runtime_local(
  const NativeDynamicPostgresqlRuntimeConfig *config,
  const char *app_root,
  yyjson_val *list
) {
  yyjson_arr_iter iter;
  yyjson_val *item = NULL;
  if (config == NULL || app_root == NULL || list == NULL || !yyjson_arr_iter_init(list, &iter)) {
    return 69;
  }
  while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
    char *resolved_path = NULL;
    char *sql_text = NULL;
    int code = 0;
    if (!yyjson_is_str(item)) {
      return 69;
    }
    resolved_path = resolve_relative_to(app_root, yyjson_get_str(item));
    sql_text = resolved_path != NULL ? read_file_text(resolved_path) : NULL;
    free(resolved_path);
    if (sql_text == NULL) {
      free(sql_text);
      return 66;
    }
    code = run_postgresql_sql_capture_runtime_local(config, sql_text, 0, NULL);
    free(sql_text);
    if (code != 0) {
      return code;
    }
  }
  return 0;
}
 
static char *runtime_state_placeholder_sql_dup_runtime_local(const char *sql_template, const char *escaped_state_json) {
  const char *placeholder = NULL;
  size_t prefix_len = 0;
  size_t suffix_len = 0;
  char *sql_text = NULL;
  if (sql_template == NULL || escaped_state_json == NULL) {
    return NULL;
  }
  placeholder = strstr(sql_template, "__STATE_JSON__");
  if (placeholder == NULL) {
    return NULL;
  }
  prefix_len = (size_t)(placeholder - sql_template);
  suffix_len = strlen(placeholder + strlen("__STATE_JSON__"));
  sql_text = (char *)malloc(prefix_len + strlen(escaped_state_json) + suffix_len + 1);
  if (sql_text == NULL) {
    return NULL;
  }
  memcpy(sql_text, sql_template, prefix_len);
  memcpy(sql_text + prefix_len, escaped_state_json, strlen(escaped_state_json));
  memcpy(sql_text + prefix_len + strlen(escaped_state_json), placeholder + strlen("__STATE_JSON__"), suffix_len + 1);
  return sql_text;
}
 
static char *sql_literal_escape_dup_runtime_local(const char *value) {
  const char *src = value != NULL ? value : "";
  size_t extra = 0;
  char *out = NULL;
  char *dst = NULL;
  while (*src != '\0') {
    if (*src == '\'') {
      extra++;
    }
    src++;
  }
  src = value != NULL ? value : "";
  out = (char *)malloc(strlen(src) + extra + 1);
  if (out == NULL) {
    return NULL;
  }
  dst = out;
  while (*src != '\0') {
    if (*src == '\'') {
      *dst++ = '\'';
    }
    *dst++ = *src++;
  }
  *dst = '\0';
  return out;
}
 
void native_dynamic_relational_request_sync_free(NativeDynamicRelationalRequestSync *sync) {
  if (sync == NULL) {
    return;
  }
  free(sync->before_signature);
  sync->before_signature = NULL;
  sync->enabled = 0;
}
 
char *native_dynamic_relational_backend_dup(const char *app_root, const char *runtime_conf_path) {
  char *backend = native_dynamic_config_merged_value_dup(app_root, runtime_conf_path, "db_backend");
  if (backend != NULL && (streq(backend, "sqlite") || streq(backend, "postgresql"))) {
    return backend;
  }
  free(backend);
  return NULL;
}
 
char *native_dynamic_relational_sqlite_path_dup(
  const char *app_root,
  const char *runtime_conf_path,
  const char *app_id
) {
  char *sqlite_path = NULL;
  if (app_root == NULL || app_root[0] == '\0') {
    return NULL;
  }
  sqlite_path = native_dynamic_config_merged_value_dup(app_root, runtime_conf_path, "db_path");
  if (sqlite_path != NULL && sqlite_path[0] != '\0') {
    return sqlite_path;
  }
  free(sqlite_path);
  {
    char buffer[4096];
    snprintf(buffer, sizeof(buffer), "/var/lib/pharos/%s.sqlite3", app_id != NULL && app_id[0] != '\0' ? app_id : "app");
    return strdup(buffer);
  }
}
 
int native_dynamic_relational_sqlite_runtime_ready(
  const char *app_root,
  const char *runtime_conf_path,
  const char *app_id
) {
  char *backend = native_dynamic_relational_backend_dup(app_root, runtime_conf_path);
  char *sqlite_path = NULL;
  char *parent_dir = NULL;
  int ready = 0;
  if (backend == NULL || !streq(backend, "sqlite")) {
    free(backend);
    return 0;
  }
  sqlite_path = native_dynamic_relational_sqlite_path_dup(app_root, runtime_conf_path, app_id);
  parent_dir = sqlite_path != NULL ? path_dirname(sqlite_path) : NULL;
  if (sqlite_path != NULL && parent_dir != NULL && (path_exists(sqlite_path) || ensure_directory(parent_dir) == 0)) {
    ready = 1;
  }
  free(backend);
  free(sqlite_path);
  free(parent_dir);
  return ready;
}
 
int native_dynamic_relational_postgresql_runtime_ready(
  const char *app_root,
  const char *runtime_conf_path
) {
  char *backend = native_dynamic_relational_backend_dup(app_root, runtime_conf_path);
  NativeDynamicPostgresqlRuntimeConfig config = {0};
  NativeDynamicLibpqApi api = {0};
  int ready = 0;
  if (backend != NULL && streq(backend, "postgresql")
      && load_postgresql_runtime_config_runtime_local(app_root, runtime_conf_path, &config)
      && load_native_libpq_api_runtime_local(&api)) {
    ready = 1;
  }
  free(backend);
  free_postgresql_runtime_config_runtime_local(&config);
  free_native_libpq_api_runtime_local(&api);
  return ready;
}
 
int native_dynamic_relational_postgresql_runtime_prepare(
  const char *app_root,
  const char *runtime_conf_path
) {
  char *backend = NULL;
  char *migration_fixture_path = NULL;
  yyjson_doc *migration_doc = NULL;
  yyjson_val *migration_root = NULL;
  yyjson_val *backend_record = NULL;
  yyjson_val *schema_files = NULL;
  yyjson_val *seed_files = NULL;
  yyjson_val *refresh_seed_files = NULL;
  yyjson_val *migrations = NULL;
  char *auth_present = NULL;
  char *security_present = NULL;
  char *user_count = NULL;
  NativeDynamicPostgresqlRuntimeConfig config = {0};
  int code = 69;
 
  if (app_root == NULL || app_root[0] == '\0') {
    return 64;
  }
  backend = native_dynamic_relational_backend_dup(app_root, runtime_conf_path);
  if (backend == NULL || !streq(backend, "postgresql")) {
    code = 64;
    goto cleanup;
  }
  if (!load_postgresql_runtime_config_runtime_local(app_root, runtime_conf_path, &config)) {
    code = 69;
    goto cleanup;
  }
 
  migration_fixture_path = migration_fixture_path_dup_runtime_local(app_root);
  if (migration_fixture_path == NULL) {
    code = 69;
    goto cleanup;
  }
  migration_doc = native_json_doc_load_file(migration_fixture_path);
  if (migration_doc == NULL) {
    code = 66;
    goto cleanup;
  }
  migration_root = yyjson_doc_get_root(migration_doc);
  backend_record = migration_backend_record_runtime_local(migration_root, "postgresql");
  schema_files = backend_record != NULL ? native_json_obj_get_array(backend_record, "schema_files") : NULL;
  seed_files = backend_record != NULL ? native_json_obj_get_array(backend_record, "seed_files") : NULL;
  refresh_seed_files = backend_record != NULL ? native_json_obj_get_array(backend_record, "refresh_seed_files") : NULL;
  migrations = native_json_obj_get_array(migration_root, "migrations");
 
  run_postgresql_sql_capture_runtime_local(&config,
    "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = 'auth_user');",
    1,
    &auth_present);
  run_postgresql_sql_capture_runtime_local(&config,
    "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = 'identity_password_reset');",
    1,
    &security_present);
 
  if ((auth_present == NULL || !streq(auth_present, "t")) || (security_present == NULL || !streq(security_present, "t"))) {
    code = postgresql_apply_file_list_runtime_local(&config, app_root, schema_files);
    if (code != 0) {
      goto cleanup;
    }
  }
 
  if (run_postgresql_sql_capture_runtime_local(&config, "SELECT COUNT(*) FROM auth_user;", 1, &user_count) != 0 || user_count == NULL) {
    free(user_count);
    user_count = strdup("0");
  }
  if (user_count == NULL) {
    code = 69;
    goto cleanup;
  }
  if (streq(user_count, "0")) {
    code = postgresql_apply_file_list_runtime_local(&config, app_root, seed_files);
    if (code != 0) {
      goto cleanup;
    }
  }
  code = postgresql_apply_file_list_runtime_local(&config, app_root, refresh_seed_files);
  if (code != 0) {
    goto cleanup;
  }
 
  if (migrations != NULL) {
    yyjson_arr_iter iter;
    yyjson_val *item = NULL;
    if (!yyjson_arr_iter_init(migrations, &iter)) {
      code = 69;
      goto cleanup;
    }
    while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
      yyjson_val *item_backend_files = native_json_obj_get(item, "backend_files");
      yyjson_val *item_backend = item_backend_files != NULL ? native_json_obj_get(item_backend_files, "postgresql") : NULL;
      yyjson_val *forward_files = item_backend != NULL ? native_json_obj_get_array(item_backend, "forward_sql_files") : NULL;
      char *migration_id = NULL;
      char *checksum_value = NULL;
      char *escaped_migration_id = NULL;
      char *escaped_checksum = NULL;
      char *sql = NULL;
      long schema_version = 0;
      if (forward_files == NULL || yyjson_arr_size(forward_files) == 0) {
        continue;
      }
      migration_id = native_json_obj_get_string_dup(item, "migration_id");
      schema_version = native_json_obj_get_long_default(item, "schema_version", 0, NULL);
      checksum_value = migration_expected_checksum_dup_runtime_local(app_root, item, "postgresql");
      escaped_migration_id = sql_literal_escape_dup_runtime_local(migration_id != NULL ? migration_id : "");
      escaped_checksum = sql_literal_escape_dup_runtime_local(checksum_value != NULL ? checksum_value : "");
      if (escaped_migration_id == NULL || escaped_checksum == NULL) {
        free(migration_id);
        free(checksum_value);
        free(escaped_migration_id);
        free(escaped_checksum);
        code = 69;
        goto cleanup;
      }
      sql = (char *)malloc(strlen(escaped_migration_id) * 2 + strlen(escaped_checksum) * 2 + 640);
      if (sql == NULL) {
        free(migration_id);
        free(checksum_value);
        free(escaped_migration_id);
        free(escaped_checksum);
        code = 69;
        goto cleanup;
      }
      snprintf(sql, strlen(escaped_migration_id) * 2 + strlen(escaped_checksum) * 2 + 640,
        "INSERT INTO pharos_schema_migration (migration_id, schema_version, backend, checksum_sha256) VALUES ('%s', %ld, 'postgresql', '%s') ON CONFLICT (migration_id) DO NOTHING;\nUPDATE pharos_schema_migration SET checksum_sha256 = '%s' WHERE migration_id = '%s' AND backend = 'postgresql' AND (checksum_sha256 IS NULL OR BTRIM(checksum_sha256) = '');",
        escaped_migration_id,
        schema_version,
        escaped_checksum,
        escaped_checksum,
        escaped_migration_id);
      if (run_postgresql_sql_capture_runtime_local(&config, sql, 0, NULL) != 0) {
        free(migration_id);
        free(checksum_value);
        free(escaped_migration_id);
        free(escaped_checksum);
        free(sql);
        code = 69;
        goto cleanup;
      }
      free(migration_id);
      free(checksum_value);
      free(escaped_migration_id);
      free(escaped_checksum);
      free(sql);
    }
  }
 
  code = 0;
cleanup:
  free(backend);
  free(migration_fixture_path);
  free(auth_present);
  free(security_present);
  free(user_count);
  native_json_doc_free(migration_doc);
  free_postgresql_runtime_config_runtime_local(&config);
  return code;
}
 
int native_dynamic_relational_sqlite_runtime_prepare(
  const char *app_root,
  const char *runtime_conf_path,
  const char *app_id
) {
  char *backend = NULL;
  char *sqlite_path = NULL;
  char *parent_dir = NULL;
  char *migration_fixture_path = NULL;
  yyjson_doc *migration_doc = NULL;
  yyjson_val *migration_root = NULL;
  yyjson_val *backend_record = NULL;
  yyjson_val *schema_files = NULL;
  yyjson_val *seed_files = NULL;
  yyjson_val *refresh_seed_files = NULL;
  yyjson_val *migrations = NULL;
  char *auth_present = NULL;
  char *security_present = NULL;
  char *user_count = NULL;
  int code = 69;
 
  if (app_root == NULL || app_root[0] == '\0') {
    return 64;
  }
  backend = native_dynamic_relational_backend_dup(app_root, runtime_conf_path);
  if (backend == NULL || !streq(backend, "sqlite")) {
    code = 64;
    goto cleanup;
  }
  sqlite_path = native_dynamic_relational_sqlite_path_dup(app_root, runtime_conf_path, app_id);
  parent_dir = sqlite_path != NULL ? path_dirname(sqlite_path) : NULL;
  if (sqlite_path == NULL || parent_dir == NULL || ensure_directory(parent_dir) != 0) {
    code = 69;
    goto cleanup;
  }
  migration_fixture_path = migration_fixture_path_dup_runtime_local(app_root);
  if (migration_fixture_path == NULL) {
    code = 69;
    goto cleanup;
  }
  migration_doc = native_json_doc_load_file(migration_fixture_path);
  if (migration_doc == NULL) {
    code = 66;
    goto cleanup;
  }
  migration_root = yyjson_doc_get_root(migration_doc);
  backend_record = migration_backend_record_runtime_local(migration_root, "sqlite");
  schema_files = backend_record != NULL ? native_json_obj_get_array(backend_record, "schema_files") : NULL;
  seed_files = backend_record != NULL ? native_json_obj_get_array(backend_record, "seed_files") : NULL;
  refresh_seed_files = backend_record != NULL ? native_json_obj_get_array(backend_record, "refresh_seed_files") : NULL;
  migrations = native_json_obj_get_array(migration_root, "migrations");
 
  auth_present = sqlite_exec_first_value_dup_runtime_local(sqlite_path, "SELECT name FROM sqlite_master WHERE type='table' AND name='auth_user';");
  security_present = sqlite_exec_first_value_dup_runtime_local(sqlite_path, "SELECT name FROM sqlite_master WHERE type='table' AND name='identity_password_reset';");
  if ((auth_present == NULL || auth_present[0] == '\0') || (security_present == NULL || security_present[0] == '\0')) {
    code = sqlite_apply_file_list_runtime_local(sqlite_path, app_root, schema_files);
    if (code != 0) {
      goto cleanup;
    }
  }
  user_count = sqlite_exec_first_value_dup_runtime_local(sqlite_path, "SELECT COUNT(*) FROM auth_user;");
  if (user_count == NULL || streq(user_count, "0")) {
    code = sqlite_apply_file_list_runtime_local(sqlite_path, app_root, seed_files);
    if (code != 0) {
      goto cleanup;
    }
  }
  code = sqlite_apply_file_list_runtime_local(sqlite_path, app_root, refresh_seed_files);
  if (code != 0) {
    goto cleanup;
  }
 
  if (migrations != NULL) {
    yyjson_arr_iter iter;
    yyjson_val *item = NULL;
    if (!yyjson_arr_iter_init(migrations, &iter)) {
      code = 69;
      goto cleanup;
    }
    while ((item = yyjson_arr_iter_next(&iter)) != NULL) {
      yyjson_val *item_backend_files = native_json_obj_get(item, "backend_files");
      yyjson_val *item_backend = item_backend_files != NULL ? native_json_obj_get(item_backend_files, "sqlite") : NULL;
      yyjson_val *forward_files = item_backend != NULL ? native_json_obj_get_array(item_backend, "forward_sql_files") : NULL;
      char *migration_id = NULL;
      char *checksum_value = NULL;
      char *escaped_migration_id = NULL;
      char *escaped_checksum = NULL;
      char *sql = NULL;
      long schema_version = 0;
      if (forward_files == NULL || yyjson_arr_size(forward_files) == 0) {
        continue;
      }
      migration_id = native_json_obj_get_string_dup(item, "migration_id");
      schema_version = native_json_obj_get_long_default(item, "schema_version", 0, NULL);
      checksum_value = migration_expected_checksum_dup_runtime_local(app_root, item, "sqlite");
      escaped_migration_id = sql_literal_escape_dup_runtime_local(migration_id != NULL ? migration_id : "");
      escaped_checksum = sql_literal_escape_dup_runtime_local(checksum_value != NULL ? checksum_value : "");
      if (escaped_migration_id == NULL || escaped_checksum == NULL) {
        free(migration_id);
        free(checksum_value);
        free(escaped_migration_id);
        free(escaped_checksum);
        code = 69;
        goto cleanup;
      }
      sql = (char *)malloc(strlen(escaped_migration_id) * 2 + strlen(escaped_checksum) * 2 + 512);
      if (sql == NULL) {
        free(migration_id);
        free(checksum_value);
        free(escaped_migration_id);
        free(escaped_checksum);
        code = 69;
        goto cleanup;
      }
      snprintf(sql, strlen(escaped_migration_id) * 2 + strlen(escaped_checksum) * 2 + 512,
        "INSERT OR IGNORE INTO pharos_schema_migration (migration_id, schema_version, backend, checksum_sha256) VALUES ('%s', %ld, 'sqlite', '%s');\nUPDATE pharos_schema_migration SET checksum_sha256 = '%s' WHERE migration_id = '%s' AND backend = 'sqlite' AND (checksum_sha256 IS NULL OR TRIM(checksum_sha256) = '');",
        escaped_migration_id,
        schema_version,
        escaped_checksum,
        escaped_checksum,
        escaped_migration_id);
      if (sqlite_exec_runtime_local(sqlite_path, sql) != 0) {
        free(migration_id);
        free(checksum_value);
        free(escaped_migration_id);
        free(escaped_checksum);
        free(sql);
        code = 69;
        goto cleanup;
      }
      free(migration_id);
      free(checksum_value);
      free(escaped_migration_id);
      free(escaped_checksum);
      free(sql);
    }
  }
 
  code = 0;
cleanup:
  free(backend);
  free(sqlite_path);
  free(parent_dir);
  free(migration_fixture_path);
  free(auth_present);
  free(security_present);
  free(user_count);
  native_json_doc_free(migration_doc);
  return code;
}
 
char *native_dynamic_relational_runtime_export_json_dup(
  const char *app_root,
  const char *runtime_conf_path,
  const char *app_id
) {
  char *backend = native_dynamic_relational_backend_dup(app_root, runtime_conf_path);
  char *sqlite_path = NULL;
  char *sql_path = NULL;
  char *sql_text = NULL;
  char *export_json = NULL;
  NativeDynamicPostgresqlRuntimeConfig pg = {0};
  if (backend == NULL) {
    return NULL;
  }
  if (streq(backend, "sqlite")) {
    sqlite_path = native_dynamic_relational_sqlite_path_dup(app_root, runtime_conf_path, app_id);
    sql_path = runtime_state_export_sqlite_path_dup_runtime_local(app_root);
    sql_text = sql_path != NULL ? read_file_text(sql_path) : NULL;
    if (sqlite_path == NULL || sqlite_path[0] == '\0' || sql_text == NULL) {
      goto cleanup;
    }
    export_json = sqlite_exec_first_value_dup_runtime_local(sqlite_path, sql_text);
  } else if (streq(backend, "postgresql")) {
    if (!load_postgresql_runtime_config_runtime_local(app_root, runtime_conf_path, &pg)) {
      goto cleanup;
    }
    sql_path = runtime_state_export_postgresql_path_dup_runtime_local(app_root);
    sql_text = sql_path != NULL ? read_file_text(sql_path) : NULL;
    if (sql_text == NULL || run_postgresql_sql_capture_runtime_local(&pg, sql_text, 1, &export_json) != 0) {
      free(export_json);
      export_json = NULL;
    }
  }
cleanup:
  free(backend);
  free(sqlite_path);
  free(sql_path);
  free(sql_text);
  free_postgresql_runtime_config_runtime_local(&pg);
  return export_json;
}
 
char *native_dynamic_relational_runtime_audit_count_dup(
  const char *app_root,
  const char *runtime_conf_path,
  const char *app_id
) {
  char *backend = native_dynamic_relational_backend_dup(app_root, runtime_conf_path);
  char *sqlite_path = NULL;
  char *table_present = NULL;
  char *count_text = NULL;
  NativeDynamicPostgresqlRuntimeConfig pg = {0};
  if (backend == NULL) {
    return NULL;
  }
  if (streq(backend, "sqlite")) {
    sqlite_path = native_dynamic_relational_sqlite_path_dup(app_root, runtime_conf_path, app_id);
    if (sqlite_path != NULL && sqlite_path[0] != '\0') {
      table_present = sqlite_exec_first_value_dup_runtime_local(sqlite_path, "SELECT name FROM sqlite_master WHERE type='table' AND name='audit_event';");
      if (table_present == NULL || table_present[0] == '\0') {
        count_text = strdup("0");
      } else {
        count_text = sqlite_exec_first_value_dup_runtime_local(sqlite_path, "SELECT COUNT(*) FROM audit_event;");
      }
    }
  } else if (streq(backend, "postgresql")) {
    if (load_postgresql_runtime_config_runtime_local(app_root, runtime_conf_path, &pg)) {
      char *table_exists = NULL;
      if (run_postgresql_sql_capture_runtime_local(&pg,
          "SELECT EXISTS (SELECT 1 FROM information_schema.tables WHERE table_schema = 'public' AND table_name = 'audit_event');",
          1,
          &table_exists) == 0) {
        if (table_exists != NULL && streq(table_exists, "t")) {
          run_postgresql_sql_capture_runtime_local(&pg, "SELECT COUNT(*) FROM audit_event;", 1, &count_text);
        } else {
          count_text = strdup("0");
        }
      }
      free(table_exists);
    }
  }
  free(backend);
  free(sqlite_path);
  free(table_present);
  free_postgresql_runtime_config_runtime_local(&pg);
  return count_text;
}
 
int native_dynamic_relational_runtime_import_state(
  const char *app_root,
  const char *runtime_conf_path,
  const char *app_id,
  const char *state_path,
  const char *expected_audit_count
) {
  char *backend = NULL;
  char *sqlite_path = NULL;
  char *current_audit_count = NULL;
  char *state_json = NULL;
  char *escaped_state_json = NULL;
  char *sql_template_path = NULL;
  char *sql_template = NULL;
  char *sql_text = NULL;
  NativeDynamicPostgresqlRuntimeConfig pg = {0};
  int code = 69;
  if (app_root == NULL || app_root[0] == '\0' || state_path == NULL || state_path[0] == '\0') {
    return 64;
  }
  backend = native_dynamic_relational_backend_dup(app_root, runtime_conf_path);
  if (backend == NULL) {
    return 69;
  }
  if (expected_audit_count != NULL && expected_audit_count[0] != '\0') {
    current_audit_count = native_dynamic_relational_runtime_audit_count_dup(app_root, runtime_conf_path, app_id);
    if (current_audit_count == NULL || !streq(current_audit_count, expected_audit_count)) {
      code = 73;
      goto cleanup;
    }
  }
  state_json = read_file_text(state_path);
  escaped_state_json = sql_literal_escape_dup_runtime_local(state_json != NULL ? state_json : "");
  if (streq(backend, "sqlite")) {
    sqlite_path = native_dynamic_relational_sqlite_path_dup(app_root, runtime_conf_path, app_id);
    sql_template_path = runtime_state_import_sqlite_path_dup_runtime_local(app_root);
    sql_template = sql_template_path != NULL ? read_file_text(sql_template_path) : NULL;
    sql_text = runtime_state_placeholder_sql_dup_runtime_local(sql_template, escaped_state_json != NULL ? escaped_state_json : "");
    if (sqlite_path == NULL || sqlite_path[0] == '\0' || sql_text == NULL) {
      goto cleanup;
    }
    code = sqlite_exec_runtime_local(sqlite_path, sql_text);
  } else if (streq(backend, "postgresql")) {
    if (!load_postgresql_runtime_config_runtime_local(app_root, runtime_conf_path, &pg)) {
      goto cleanup;
    }
    sql_template_path = runtime_state_import_postgresql_path_dup_runtime_local(app_root);
    sql_template = sql_template_path != NULL ? read_file_text(sql_template_path) : NULL;
    sql_text = runtime_state_placeholder_sql_dup_runtime_local(sql_template, escaped_state_json != NULL ? escaped_state_json : "");
    if (sql_text == NULL) {
      goto cleanup;
    }
    code = run_postgresql_sql_capture_runtime_local(&pg, sql_text, 0, NULL);
  }
cleanup:
  free(backend);
  free(sqlite_path);
  free(current_audit_count);
  free(state_json);
  free(escaped_state_json);
  free(sql_template_path);
  free(sql_template);
  free(sql_text);
  free_postgresql_runtime_config_runtime_local(&pg);
  return code;
}
 
char *native_dynamic_relational_file_signature_dup(const char *path) {
  unsigned char *bytes = NULL;
  size_t length = 0;
  size_t index = 0;
  unsigned long long hash = 1469598103934665603ULL;
  char *signature = NULL;
  if (path == NULL || path[0] == '\0') {
    return NULL;
  }
  if (!path_exists(path)) {
    return strdup("missing");
  }
  bytes = read_file_bytes_dup_runtime(path, &length);
  if (bytes == NULL) {
    return NULL;
  }
  for (index = 0; index < length; index++) {
    hash ^= (unsigned long long)bytes[index];
    hash *= 1099511628211ULL;
  }
  signature = (char *)malloc(40);
  if (signature != NULL) {
    snprintf(signature, 40, "%016llx:%llu", hash, (unsigned long long)length);
  }
  free(bytes);
  return signature;
}
 
int native_dynamic_relational_prepare_request_state(
  const AppRuntime *app,
  NativeDynamicRelationalRequestSync *sync
) {
  char *backend = NULL;
  char *export_json = NULL;
  char *state_dir = NULL;
  int code = 0;
  if (sync != NULL) {
    memset(sync, 0, sizeof(*sync));
  }
  if (app == NULL || app->app_root == NULL || app->state_path == NULL || sync == NULL) {
    return 0;
  }
  backend = native_dynamic_relational_backend_dup(app->app_root, app->runtime_conf_path);
  if (backend == NULL) {
    free(backend);
    return 0;
  }
  if (streq(backend, "sqlite")) {
    if (!native_dynamic_relational_sqlite_runtime_ready(app->app_root, app->runtime_conf_path, app->app_id)) {
      fprintf(stderr, "relational_prepare_failed step=sqlite_runtime_ready app_id=%s\n", app->app_id != NULL ? app->app_id : "");
      code = 69;
      goto cleanup;
    }
    code = native_dynamic_relational_sqlite_runtime_prepare(app->app_root, app->runtime_conf_path, app->app_id);
    if (code != 0) {
      fprintf(stderr, "relational_prepare_failed step=sqlite_runtime_prepare app_id=%s code=%d\n", app->app_id != NULL ? app->app_id : "", code);
    }
  } else if (streq(backend, "postgresql")) {
    if (!native_dynamic_relational_postgresql_runtime_ready(app->app_root, app->runtime_conf_path)) {
      fprintf(stderr, "relational_prepare_failed step=postgresql_runtime_ready app_id=%s\n", app->app_id != NULL ? app->app_id : "");
      code = 69;
      goto cleanup;
    }
    code = native_dynamic_relational_postgresql_runtime_prepare(app->app_root, app->runtime_conf_path);
    if (code != 0) {
      fprintf(stderr, "relational_prepare_failed step=postgresql_runtime_prepare app_id=%s code=%d\n", app->app_id != NULL ? app->app_id : "", code);
    }
  }
  if (code != 0) {
    goto cleanup;
  }
  export_json = native_dynamic_relational_runtime_export_json_dup(app->app_root, app->runtime_conf_path, app->app_id);
  if (export_json == NULL) {
    fprintf(stderr, "relational_prepare_failed step=runtime_export app_id=%s backend=%s\n", app->app_id != NULL ? app->app_id : "", backend != NULL ? backend : "");
    code = 69;
    goto cleanup;
  }
  state_dir = path_dirname(app->state_path);
  if (state_dir == NULL || ensure_directory(state_dir) != 0 || write_text_file(app->state_path, export_json) != 0) {
    fprintf(stderr, "relational_prepare_failed step=write_state app_id=%s path=%s\n", app->app_id != NULL ? app->app_id : "", app->state_path != NULL ? app->state_path : "");
    code = 69;
    goto cleanup;
  }
  sync->before_signature = native_dynamic_relational_file_signature_dup(app->state_path);
  sync->enabled = 1;
  code = sync->before_signature != NULL ? 0 : 69;
cleanup:
  free(backend);
  free(export_json);
  free(state_dir);
  if (code != 0) {
    native_dynamic_relational_request_sync_free(sync);
  }
  return code;
}
 
int native_dynamic_relational_sync_back_if_changed(
  const AppRuntime *app,
  const NativeDynamicRelationalRequestSync *sync
) {
  char *after_signature = NULL;
  int code = 0;
  if (app == NULL || sync == NULL || !sync->enabled) {
    return 0;
  }
  after_signature = native_dynamic_relational_file_signature_dup(app->state_path);
  if (after_signature == NULL) {
    return 69;
  }
  if (sync->before_signature != NULL && !streq(after_signature, sync->before_signature)) {
    code = native_dynamic_relational_runtime_import_state(
      app->app_root,
      app->runtime_conf_path,
      app->app_id,
      app->state_path,
      NULL
    );
    if (code != 0) {
      fprintf(stderr, "relational_sync_back_failed app_id=%s code=%d\n", app->app_id != NULL ? app->app_id : "", code);
    }
  }
  free(after_signature);
  return code;
}