273 lines
9.8 KiB
Ziran
273 lines
9.8 KiB
Ziran
sqlite3_lib :: #system_library "sqlite3";
|
|
c :: #system_library "c";
|
|
time :: (t: *s64) -> s64 #foreign c;
|
|
LOG_INFO :: 3
|
|
LOG_WARNING :: 4
|
|
LOG_ERROR :: 5
|
|
NativeTraceLog :: (level: s32, message: *u8, args: ..any) #foreign c "TraceLog";
|
|
sqlite3_open_v2 :: (path: *u8, database: **void, flags: s32, vfs: *u8) -> s32 #foreign sqlite3_lib "sqlite3_open_v2";
|
|
sqlite3_busy_timeout :: (database: *void, milliseconds: s32) -> s32 #foreign sqlite3_lib "sqlite3_busy_timeout";
|
|
sqlite3_total_changes64 :: (database: *void) -> s64 #foreign sqlite3_lib "sqlite3_total_changes64";
|
|
|
|
// Counts database opens and closes, so memoized reads can tell a reopened
|
|
// connection, whose change counter starts again at zero, from the old one.
|
|
storage_connection_generation: s64;
|
|
|
|
// Rows changed through the open connection since it opened. The app has one
|
|
// writing connection, so an unchanged value means no stored data changed.
|
|
storage_connection_changes :: () -> s64 {
|
|
if storage_state_handle().db == null { return -1 }
|
|
return sqlite3_total_changes64(storage_state_handle().db)
|
|
}
|
|
|
|
// SQLite's data version moves with commits from any connection, such as
|
|
// another process editing the same profile, which this connection's own
|
|
// change count does not see.
|
|
sqlite3_file_control :: (db: *void, name: *u8, op: s32, arg: *void) -> s32 #foreign sqlite3_lib "sqlite3_file_control";
|
|
SQLITE_FCNTL_DATA_VERSION :: 35
|
|
|
|
storage_connection_data_version :: () -> s64 {
|
|
if storage_state_handle().db == null { return -1 }
|
|
main: [5]u8 = .[109, 97, 105, 110, 0]
|
|
version: u32 = 0
|
|
if sqlite3_file_control(storage_state_handle().db, *main[0], SQLITE_FCNTL_DATA_VERSION,
|
|
cast(*void)*version) != 0 {
|
|
return -1
|
|
}
|
|
return cast(s64)version
|
|
}
|
|
|
|
storage_revision_value: s64;
|
|
storage_revision_generation: s64 = -1;
|
|
storage_revision_changes: s64 = -1;
|
|
storage_revision_data_version: s64 = -1;
|
|
|
|
// A revision that advances whenever stored data may have changed: after any
|
|
// row change on the app's connection or a commit by another, or after a
|
|
// reopen. Caches of
|
|
// stored values compare it for equality; it runs no query, so screens and
|
|
// per-frame work can check it freely. Timestamps cannot serve here: several
|
|
// writes share one second.
|
|
storage_data_revision :: () -> s64 {
|
|
changes := storage_connection_changes()
|
|
data_version := storage_connection_data_version()
|
|
if changes != storage_revision_changes || data_version != storage_revision_data_version ||
|
|
storage_connection_generation != storage_revision_generation {
|
|
storage_revision_value += 1
|
|
storage_revision_changes = changes
|
|
storage_revision_data_version = data_version
|
|
storage_revision_generation = storage_connection_generation
|
|
}
|
|
return storage_revision_value
|
|
}
|
|
sqlite3_db_cacheflush :: (db: *void) -> s32 #foreign sqlite3_lib "sqlite3_db_cacheflush";
|
|
storage_sqlite_errmsg :: (db: *void) -> *u8 #foreign sqlite3_lib "sqlite3_errmsg";
|
|
STORAGE_PATH_SIZE :: 1024
|
|
|
|
|
|
#import, file "state.zi";
|
|
#import, file "storage_layout.zi";
|
|
#import, file "path_join.zi";
|
|
#import, file "paths.zi";
|
|
#import, file "database_upgrade.zi";
|
|
#import, file "schema.zi";
|
|
storage_migrate_default_habit_ids :: () -> s32 #foreign c;
|
|
storage_migrate_habit_ids_to_uuid :: () -> s32 #foreign c;
|
|
storage_migrate_default_meditation_activity_mask :: () -> s32 #foreign c;
|
|
storage_migrate_sync_enabled_flag :: () -> s32 #foreign c;
|
|
storage_migrate_lumi_collection :: () -> s32 #foreign c;
|
|
storage_migrate_habit_settings :: () -> s32 #foreign c;
|
|
storage_materialize_session_habit_days :: () -> s32 #foreign c;
|
|
migrate_legacy_file_sessions_once :: (root: *u8) -> s32 #foreign c;
|
|
#import, file "user.zi";
|
|
#import, file "../app/text_buffers.zi";
|
|
#import, file "sqlite.zi";
|
|
#import, file "sql_transaction.zi";
|
|
|
|
LogStorage :: (level: s32, message: string) {
|
|
buffer: [256]u8
|
|
if AppCopyText(message, buffer[:]) {
|
|
NativeTraceLog(level, *buffer[0])
|
|
}
|
|
}
|
|
|
|
LogStorageText :: (level: s32, message: string, detail: string) {
|
|
buffer: [256]u8
|
|
if !AppCopyText(message, buffer[:]) { return }
|
|
used: s32 = cast(s32)message.count
|
|
index: s32 = 0
|
|
while index < cast(s32)detail.count && used + 1 < 256 {
|
|
byte := detail[index]
|
|
if byte == cast(u8)0 { break }
|
|
buffer[used] = byte
|
|
used += 1
|
|
index += 1
|
|
}
|
|
buffer[used] = cast(u8)0
|
|
NativeTraceLog(level, *buffer[0])
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
WIN32 :: #defined(_WIN32)
|
|
ANDROID :: #defined(ANDROID_BUILD)
|
|
EMSCRIPTEN :: #defined(__EMSCRIPTEN__)
|
|
WEB :: #defined(PLATFORM_WEB)
|
|
|
|
#program_export
|
|
exec_sql :: (sql: string) -> s32 {
|
|
result := SqliteExecTransaction(storage_state_handle().db, sql)
|
|
if result == 0 {
|
|
// SQLite's reason makes a failure in a user's log diagnosable.
|
|
reason := ""
|
|
if storage_state_handle().db != null {
|
|
reason = AppTextFromCString(storage_sqlite_errmsg(storage_state_handle().db), 200)
|
|
}
|
|
LogStorageText(LOG_ERROR, "STORAGE: SQL failed: ", reason)
|
|
}
|
|
return result
|
|
}
|
|
|
|
// Meta values can be long, so they get their own buffer; the user id buffer
|
|
// holds 64 bytes and lives in the middle of the shared storage state.
|
|
storage_meta_value_bytes: [8192]u8;
|
|
|
|
#program_export
|
|
storage_meta_text_buffer :: () -> *u8 {
|
|
return *storage_meta_value_bytes[0]
|
|
}
|
|
|
|
#program_export
|
|
now_seconds :: () -> s64 {
|
|
return cast(s64)time(null)
|
|
}
|
|
|
|
#program_export
|
|
bind_text :: (stmt: *void, index: s32, text: string) -> s32 {
|
|
if text.count > 2147483647 {
|
|
return 0
|
|
}
|
|
if SqliteBindTextString(stmt, index, text, cast(s32)text.count) == SQLITE_OK {
|
|
return 1
|
|
}
|
|
return 0
|
|
}
|
|
|
|
DatabaseSidecarName :: (database_name: string, suffix: string,
|
|
output: []u8) -> bool {
|
|
if database_name.count == 0 || suffix.count == 0 ||
|
|
database_name.count + suffix.count >= output.count {
|
|
return false
|
|
}
|
|
index: s64 = 0
|
|
while index < cast(s64)database_name.count {
|
|
output[index] = database_name[index]
|
|
index += 1
|
|
}
|
|
offset: s64 = 0
|
|
while offset < cast(s64)suffix.count {
|
|
output[index + offset] = suffix[offset]
|
|
offset += 1
|
|
}
|
|
output[index + offset] = cast(u8)0
|
|
return true
|
|
}
|
|
|
|
#program_export
|
|
storage_init :: (root: string) -> s32 {
|
|
legacy_path: [STORAGE_PATH_SIZE] u8
|
|
current_path: [STORAGE_PATH_SIZE] u8
|
|
marker_path: [STORAGE_PATH_SIZE] u8
|
|
temporary_path: [STORAGE_PATH_SIZE] u8
|
|
marker_name: [64]u8
|
|
temporary_name: [64]u8
|
|
|
|
if root.count == 0 {
|
|
return 0
|
|
}
|
|
state: *StorageState = storage_state_handle()
|
|
state.pending_sync_outbox_seq = 0
|
|
state.last_sync_changed = 0
|
|
if !AppCopyText(root, g_storage.root[:]) { return 0 }
|
|
root_text: string = AppTextFromCString(*state.root[0], STORAGE_PATH_SIZE)
|
|
if storage_ensure_dir(root_text) == 0 {
|
|
LogStorage(LOG_ERROR, "STORAGE: failed to create root directory")
|
|
return 0
|
|
}
|
|
legacy_name: [32] u8
|
|
current_name: [32] u8
|
|
if !AppCopyText(PreviousDatabaseName, legacy_name[:]) ||
|
|
!AppCopyText(CurrentDatabaseName, current_name[:]) ||
|
|
!DatabaseSidecarName(CurrentDatabaseName, ".migrated", marker_name[:]) ||
|
|
!DatabaseSidecarName(CurrentDatabaseName, ".migrating", temporary_name[:]) {
|
|
return 0
|
|
}
|
|
if storage_join_path(*legacy_path[0], cast(u64)size_of(type_of(legacy_path)),
|
|
*storage_state_handle().root[0], *legacy_name[0]) == 0 || storage_join_path(*current_path[0], cast(u64)size_of(type_of(current_path)),
|
|
*storage_state_handle().root[0], *current_name[0]) == 0 ||
|
|
storage_join_path(*marker_path[0], cast(u64)size_of(type_of(marker_path)),
|
|
*storage_state_handle().root[0], *marker_name[0]) == 0 ||
|
|
storage_join_path(*temporary_path[0], cast(u64)size_of(type_of(temporary_path)),
|
|
*storage_state_handle().root[0], *temporary_name[0]) == 0 {
|
|
LogStorage(LOG_ERROR, "STORAGE: database path is too long")
|
|
return 0
|
|
}
|
|
if select_database_path(*legacy_path[0], *current_path[0], *marker_path[0],
|
|
*temporary_path[0], *current_name[0], *storage_state_handle().db_path[0],
|
|
cast(u64)size_of(type_of(storage_state_handle().db_path))) == 0 {
|
|
LogStorage(LOG_ERROR, "STORAGE: database migration could not select a safe path")
|
|
return 0
|
|
}
|
|
if sqlite3_open_v2(*storage_state_handle().db_path[0], *storage_state_handle().db,
|
|
SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE | SQLITE_OPEN_FULLMUTEX,
|
|
null) != SQLITE_OK {
|
|
LogStorage(LOG_ERROR, "STORAGE: failed to open database")
|
|
unused SqliteClose(storage_state_handle().db)
|
|
storage_state_handle().db = null
|
|
return 0
|
|
}
|
|
storage_connection_generation += 1
|
|
sqlite3_busy_timeout(storage_state_handle().db, 1000)
|
|
if schema_create() == 0 || migrate_schema() == 0 || load_or_create_user() == 0 {
|
|
unused SqliteClose(storage_state_handle().db)
|
|
storage_state_handle().db = null
|
|
return 0
|
|
}
|
|
storage_migrate_default_habit_ids()
|
|
storage_migrate_habit_ids_to_uuid()
|
|
storage_migrate_default_meditation_activity_mask()
|
|
storage_migrate_sync_enabled_flag()
|
|
if storage_migrate_lumi_collection() == 0 || storage_migrate_habit_settings() == 0 {
|
|
unused SqliteClose(storage_state_handle().db)
|
|
storage_state_handle().db = null
|
|
return 0
|
|
}
|
|
storage_materialize_session_habit_days()
|
|
if migrate_legacy_file_sessions_once(*storage_state_handle().root[0]) == 0 {
|
|
LogStorage(LOG_WARNING, "STORAGE: historical session import deferred; source files retained")
|
|
}
|
|
return 1
|
|
}
|
|
|
|
#program_export
|
|
storage_close :: () {
|
|
storage_connection_generation += 1
|
|
if storage_state_handle().db != null {
|
|
unused SqliteClose(storage_state_handle().db)
|
|
storage_state_handle().db = null
|
|
}
|
|
storage_state_handle().pending_sync_outbox_seq = 0
|
|
storage_state_handle().last_sync_changed = 0
|
|
}
|
|
|
|
#program_export
|
|
storage_db_path :: () -> string {
|
|
return AppTextFromCString(*storage_state_handle().db_path[0], 512)
|
|
}
|