npm - git-sqlite-vfs - Versions diffs - 0.0.2 → 0.0.7 - Mend

git-sqlite-vfs 0.0.2 → 0.0.7

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (17) hide show

package/README.md +67 -32
package/bin/cli.js +53 -0
package/c/Makefile +31 -16
package/c/download-sqlite.cjs +17 -0
package/c/git-merge-sqlitevfs.c +210 -186
package/c/gitvfs.c +69 -21
package/downloader.js +63 -0
package/index.d.ts +14 -0
package/index.js +103 -51
package/install.js +13 -49
package/package.json +27 -3
package/c/output/git-merge-sqlitevfs +0 -0
package/c/output/gitvfs.o +0 -0
package/c/output/gitvfs.so +0 -0
package/c/output/gitvfs_test +0 -0
package/c/output/main.o +0 -0
package/test.js +0 -209

package/c/git-merge-sqlitevfs.c CHANGED Viewed

@@ -6,225 +6,249 @@
 #include "gitvfs.h"
 int main(int argc, char *argv[]) {
-    // A Git Strategy receives: <base> -- <head> <remote>
+    // A Git Driver receives: %O %A %B %P
     if (argc < 5) {
-        fprintf(stderr, "Usage: %s <base> -- <head> <remote>\n", argv[0]);
+        fprintf(stderr, "Usage: %s %%O %%A %%B %%P\n", argv[0]);
         return 1;
     }
-    const char *base = argv[1];
-    const char *other = argv[4];
+    const char *path_out = argv[2]; // %A
+    const char *path_repo = argv[4]; // %P
-    printf("VFS Merge Driver Invoked: Whole-DB Logical Merge Initiated...\n");
-    // 2. Extract MERGE_HEAD and Ancestor without triggering index-lock failures
-    system("rm -rf /tmp/gitvfs_other_db && mkdir -p /tmp/gitvfs_other_db");
-    char cmd_other[512];
-    snprintf(cmd_other, sizeof(cmd_other), "git archive %s .db/pages/ | tar -x -C /tmp/gitvfs_other_db", other);
-    int ret_other = system(cmd_other);
-    if (ret_other != 0) {
-        fprintf(stderr, "Failed to extract other database. Command: %s\n", cmd_other);
+    char base_dir[512];
+    strncpy(base_dir, path_repo, sizeof(base_dir) - 1);
+    base_dir[sizeof(base_dir) - 1] = '\0';
+    char *pages_ptr = strstr(base_dir, "/pages/");
+    if (!pages_ptr) {
+        fprintf(stderr, "Failed to parse base_dir from %s\n", path_repo);
+        return 1;
     }
-    system("rm -rf /tmp/gitvfs_ancestor_db && mkdir -p /tmp/gitvfs_ancestor_db");
-    char cmd_ancestor[512];
-    snprintf(cmd_ancestor, sizeof(cmd_ancestor), "git archive %s .db/pages/ | tar -x -C /tmp/gitvfs_ancestor_db", base);
-    int ret_ancestor = system(cmd_ancestor);
-    if (ret_ancestor != 0) {
-        fprintf(stderr, "Failed to extract ancestor database. Command: %s\n", cmd_ancestor);
+    *pages_ptr = '\0';
+    // We only need to run the logical merge once per merge operation.
+    // We can use a lock file.
+    char lock_file[512];
+    snprintf(lock_file, sizeof(lock_file), "/tmp/gitvfs_merge_%s.lock", base_dir);
+    for (size_t i=0; i<sizeof(lock_file); i++) {
+        if (lock_file[i] == '/') lock_file[i] = '_';
     }
+    if (access(lock_file, F_OK) != 0) {
+        // Create lock
+        FILE *lf = fopen(lock_file, "w");
+        if (lf) fclose(lf);
+        printf("VFS Merge Driver Invoked: Whole-DB Logical Merge Initiated for %s...\n", base_dir);
+        system("env > /tmp/gitvfs_env.txt");
+        system("ls -la .git > /tmp/gitvfs_ls.txt");
+        char merge_head_hash[64] = "";
+        extern char **environ;
+        for (char **env = environ; *env != 0; env++) {
+            if (strncmp(*env, "GITHEAD_", 8) == 0) {
+                strncpy(merge_head_hash, *env + 8, 40);
+                merge_head_hash[40] = '\0';
+                break;
+            }
+        }
+        if (strlen(merge_head_hash) == 0) {
+            fprintf(stderr, "Could not find GITHEAD_ environment variable to determine other commit.\n");
+            return 1;
+        }
-    // 3. The Logical Merge via ATTACH
-    sqlite3 *db_local;
+        char cmd_other[1024];
+        snprintf(cmd_other, sizeof(cmd_other), "git archive %s \"%s/pages/\" | tar -x -C /tmp/gitvfs_other_db", merge_head_hash, base_dir);
+        if (system(cmd_other) != 0) {
+            fprintf(stderr, "Failed to extract other database. Command: %s\n", cmd_other);
+        }
-    sqlite3_gitvfs_init_impl(NULL);
-    sqlite3_open_v2(".db", &db_local, SQLITE_OPEN_READWRITE, "gitvfs");
+        system("rm -rf /tmp/gitvfs_ancestor_db && mkdir -p /tmp/gitvfs_ancestor_db");
+        char cmd_ancestor[1024];
+        snprintf(cmd_ancestor, sizeof(cmd_ancestor), "git archive $(git merge-base HEAD %s) \"%s/pages/\" | tar -x -C /tmp/gitvfs_ancestor_db", merge_head_hash, base_dir);
+        if (system(cmd_ancestor) != 0) {
+            fprintf(stderr, "Failed to extract ancestor database. Command: %s\n", cmd_ancestor);
+        }
-    sqlite3_exec(db_local, "ATTACH DATABASE '/tmp/gitvfs_other_db/.db' AS other;", NULL, 0, NULL);
-    sqlite3_exec(db_local, "ATTACH DATABASE '/tmp/gitvfs_ancestor_db/.db' AS ancestor;", NULL, 0, NULL);
+        // The Logical Merge via ATTACH
+        sqlite3 *db_local;
+        sqlite3_gitvfs_init_impl(NULL);
+        // Ensure VFS env var is set for gitvfs_Open
+#ifdef _WIN32
+        char env_str[1024];
+        snprintf(env_str, sizeof(env_str), "GIT_SQLITE_VFS_DIR=%s", base_dir);
+        _putenv(env_str);
+#else
+        setenv("GIT_SQLITE_VFS_DIR", base_dir, 1);
+#endif
+        if (sqlite3_open_v2(base_dir, &db_local, SQLITE_OPEN_READWRITE, "gitvfs") != SQLITE_OK) {
+            fprintf(stderr, "Failed to open local DB: %s\n", sqlite3_errmsg(db_local));
+        }
-    // 3-Way DDL Merge
-    // Phase 1 (Propagate Drops)
-    sqlite3_exec(db_local, "CREATE TEMP TABLE drops AS SELECT type, name FROM main.sqlite_schema WHERE name IN (SELECT name FROM ancestor.sqlite_schema EXCEPT SELECT name FROM other.sqlite_schema) AND name NOT LIKE 'sqlite_%';", NULL, 0, NULL);
-    sqlite3_stmt *drop_stmt;
-    char *drops_to_execute = calloc(1, 1024 * 1024); // 1MB buffer
-    if (sqlite3_prepare_v2(db_local, "SELECT type, name FROM drops;", -1, &drop_stmt, NULL) == SQLITE_OK) {
-        while (sqlite3_step(drop_stmt) == SQLITE_ROW) {
-            const char *type = (const char *)sqlite3_column_text(drop_stmt, 0);
-            const char *name = (const char *)sqlite3_column_text(drop_stmt, 1);
-            if (type && name) {
-                char drop_sql[512];
-                snprintf(drop_sql, sizeof(drop_sql), "DROP %s IF EXISTS \"%s\";\n", type, name);
-                strcat(drops_to_execute, drop_sql);
+        char attach_other[1024];
+        snprintf(attach_other, sizeof(attach_other), "ATTACH DATABASE '/tmp/gitvfs_other_db/%s' AS other;", base_dir);
+        sqlite3_exec(db_local, attach_other, NULL, 0, NULL);
+        char attach_ancestor[1024];
+        snprintf(attach_ancestor, sizeof(attach_ancestor), "ATTACH DATABASE '/tmp/gitvfs_ancestor_db/%s' AS ancestor;", base_dir);
+        sqlite3_exec(db_local, attach_ancestor, NULL, 0, NULL);
+        // Phase 1 (Propagate Drops)
+        sqlite3_exec(db_local, "CREATE TEMP TABLE drops AS SELECT type, name FROM main.sqlite_schema WHERE name IN (SELECT name FROM ancestor.sqlite_schema EXCEPT SELECT name FROM other.sqlite_schema) AND name NOT LIKE 'sqlite_%';", NULL, 0, NULL);
+        sqlite3_stmt *drop_stmt;
+        char *drops_to_execute = calloc(1, 1024 * 1024); // 1MB buffer
+        if (sqlite3_prepare_v2(db_local, "SELECT type, name FROM drops;", -1, &drop_stmt, NULL) == SQLITE_OK) {
+            while (sqlite3_step(drop_stmt) == SQLITE_ROW) {
+                const char *type = (const char *)sqlite3_column_text(drop_stmt, 0);
+                const char *name = (const char *)sqlite3_column_text(drop_stmt, 1);
+                if (type && name) {
+                    char drop_sql[512];
+                    snprintf(drop_sql, sizeof(drop_sql), "DROP %s IF EXISTS \"%s\";\n", type, name);
+                    strcat(drops_to_execute, drop_sql);
+                }
             }
+            sqlite3_finalize(drop_stmt);
         }
-        sqlite3_finalize(drop_stmt);
-    }
-    if (strlen(drops_to_execute) > 0) {
-        printf("Propagating Drops:\n%s", drops_to_execute);
-        char *err_msg = NULL;
-        if (sqlite3_exec(db_local, drops_to_execute, NULL, 0, &err_msg) != SQLITE_OK) {
-            fprintf(stderr, "Error executing drop: %s\n", err_msg);
-            sqlite3_free(err_msg);
+        if (strlen(drops_to_execute) > 0) {
+            sqlite3_exec(db_local, drops_to_execute, NULL, 0, NULL);
         }
-    }
-    free(drops_to_execute);
-    sqlite3_exec(db_local, "DROP TABLE drops;", NULL, 0, NULL);
-    // Phase 2 (Propagate Additions)
-    sqlite3_exec(db_local, "CREATE TEMP TABLE adds AS SELECT sql FROM other.sqlite_schema WHERE sql IS NOT NULL AND name IN (SELECT name FROM other.sqlite_schema EXCEPT SELECT name FROM ancestor.sqlite_schema) AND name NOT IN (SELECT name FROM main.sqlite_schema) ORDER BY CASE WHEN type='table' THEN 1 ELSE 2 END;", NULL, 0, NULL);
-    sqlite3_stmt *add_stmt;
-    char *adds_to_execute = calloc(1, 1024 * 1024); // 1MB buffer
-    if (sqlite3_prepare_v2(db_local, "SELECT sql FROM adds;", -1, &add_stmt, NULL) == SQLITE_OK) {
-        while (sqlite3_step(add_stmt) == SQLITE_ROW) {
-            const char *sql = (const char *)sqlite3_column_text(add_stmt, 0);
-            if (sql) {
-                strcat(adds_to_execute, sql);
-                strcat(adds_to_execute, ";\n");
+        free(drops_to_execute);
+        sqlite3_exec(db_local, "DROP TABLE drops;", NULL, 0, NULL);
+        // Phase 2 (Propagate Additions)
+        sqlite3_exec(db_local, "CREATE TEMP TABLE adds AS SELECT sql FROM other.sqlite_schema WHERE sql IS NOT NULL AND name IN (SELECT name FROM other.sqlite_schema EXCEPT SELECT name FROM ancestor.sqlite_schema) AND name NOT IN (SELECT name FROM main.sqlite_schema) ORDER BY CASE WHEN type='table' THEN 1 ELSE 2 END;", NULL, 0, NULL);
+        sqlite3_stmt *add_stmt;
+        char *adds_to_execute = calloc(1, 1024 * 1024); // 1MB buffer
+        if (sqlite3_prepare_v2(db_local, "SELECT sql FROM adds;", -1, &add_stmt, NULL) == SQLITE_OK) {
+            while (sqlite3_step(add_stmt) == SQLITE_ROW) {
+                const char *sql = (const char *)sqlite3_column_text(add_stmt, 0);
+                if (sql) {
+                    strcat(adds_to_execute, sql);
+                    strcat(adds_to_execute, ";\n");
+                }
             }
+            sqlite3_finalize(add_stmt);
         }
-        sqlite3_finalize(add_stmt);
-    }
-    if (strlen(adds_to_execute) > 0) {
-        printf("Propagating Additions:\n%s", adds_to_execute);
-        char *err_msg = NULL;
-        if (sqlite3_exec(db_local, adds_to_execute, NULL, 0, &err_msg) != SQLITE_OK) {
-            fprintf(stderr, "Error executing addition: %s\n", err_msg);
-            sqlite3_free(err_msg);
+        if (strlen(adds_to_execute) > 0) {
+            sqlite3_exec(db_local, adds_to_execute, NULL, 0, NULL);
         }
-    }
-    free(adds_to_execute);
-    sqlite3_exec(db_local, "DROP TABLE adds;", NULL, 0, NULL);
-    // Dynamically discover and merge tables
-    sqlite3_stmt *stmt;
-    const char *query_schema = "SELECT name FROM main.sqlite_schema WHERE type='table' AND name NOT LIKE 'sqlite_%';";
-    if (sqlite3_prepare_v2(db_local, query_schema, -1, &stmt, NULL) == SQLITE_OK) {
-        while (sqlite3_step(stmt) == SQLITE_ROW) {
-            const char *table_name = (const char *)sqlite3_column_text(stmt, 0);
-            if (table_name) {
-                printf("Merging table: %s\n", table_name);
-                char pragma_query[512];
-                snprintf(pragma_query, sizeof(pragma_query), "PRAGMA main.table_info(\"%s\");", table_name);
-                sqlite3_stmt *pragma_stmt;
-                char pk_col[256] = {0};
-                int has_pk = 0;
-                if (sqlite3_prepare_v2(db_local, pragma_query, -1, &pragma_stmt, NULL) == SQLITE_OK) {
-                    while (sqlite3_step(pragma_stmt) == SQLITE_ROW) {
-                        int pk = sqlite3_column_int(pragma_stmt, 5);
-                        if (pk > 0) {
-                            const char *col_name = (const char *)sqlite3_column_text(pragma_stmt, 1);
-                            if (col_name) {
-                                strncpy(pk_col, col_name, sizeof(pk_col) - 1);
-                                has_pk = 1;
-                                break;
+        free(adds_to_execute);
+        sqlite3_exec(db_local, "DROP TABLE adds;", NULL, 0, NULL);
+        // Dynamically discover and merge tables
+        sqlite3_stmt *stmt;
+        const char *query_schema = "SELECT name FROM main.sqlite_schema WHERE type='table' AND name NOT LIKE 'sqlite_%';";
+        if (sqlite3_prepare_v2(db_local, query_schema, -1, &stmt, NULL) == SQLITE_OK) {
+            while (sqlite3_step(stmt) == SQLITE_ROW) {
+                const char *table_name = (const char *)sqlite3_column_text(stmt, 0);
+                if (table_name) {
+                    char pragma_query[512];
+                    snprintf(pragma_query, sizeof(pragma_query), "PRAGMA main.table_info(\"%s\");", table_name);
+                    sqlite3_stmt *pragma_stmt;
+                    char pk_col[256] = {0};
+                    int has_pk = 0;
+                    if (sqlite3_prepare_v2(db_local, pragma_query, -1, &pragma_stmt, NULL) == SQLITE_OK) {
+                        while (sqlite3_step(pragma_stmt) == SQLITE_ROW) {
+                            int pk = sqlite3_column_int(pragma_stmt, 5);
+                            if (pk > 0) {
+                                const char *col_name = (const char *)sqlite3_column_text(pragma_stmt, 1);
+                                if (col_name) {
+                                    strncpy(pk_col, col_name, sizeof(pk_col) - 1);
+                                    has_pk = 1;
+                                    break;
+                                }
                             }
                         }
+                        sqlite3_finalize(pragma_stmt);
                     }
-                    sqlite3_finalize(pragma_stmt);
-                } else {
-                    fprintf(stderr, "Failed to prepare PRAGMA query for table %s: %s\n", table_name, sqlite3_errmsg(db_local));
-                }
-                if (has_pk) {
-                    int exists_in_ancestor = 0;
-                    char check_anc[256];
-                    snprintf(check_anc, sizeof(check_anc), "SELECT 1 FROM ancestor.sqlite_schema WHERE type='table' AND name='%s';", table_name);
-                    sqlite3_stmt *anc_stmt;
-                    if (sqlite3_prepare_v2(db_local, check_anc, -1, &anc_stmt, NULL) == SQLITE_OK) {
-                        if (sqlite3_step(anc_stmt) == SQLITE_ROW) exists_in_ancestor = 1;
-                        sqlite3_finalize(anc_stmt);
-                    }
-                    if (exists_in_ancestor) {
-                        char drop_conflict[256];
-                        snprintf(drop_conflict, sizeof(drop_conflict), "DROP TABLE IF EXISTS temp.\"conflicted_pks_%s\";", table_name);
-                        sqlite3_exec(db_local, drop_conflict, NULL, 0, NULL);
-                        char conflict_query[1024];
-                        snprintf(conflict_query, sizeof(conflict_query),
-                            "CREATE TEMP TABLE \"conflicted_pks_%s\" AS "
-                            "SELECT \"%s\" FROM (SELECT * FROM main.\"%s\" EXCEPT SELECT * FROM ancestor.\"%s\") "
-                            "INTERSECT "
-                            "SELECT \"%s\" FROM (SELECT * FROM other.\"%s\" EXCEPT SELECT * FROM ancestor.\"%s\");",
-                            table_name,
-                            pk_col, table_name, table_name,
-                            pk_col, table_name, table_name);
-                        char *err_msg = NULL;
-                        if (sqlite3_exec(db_local, conflict_query, NULL, 0, &err_msg) != SQLITE_OK) {
-                            fprintf(stderr, "Error executing conflict query: %s\n", err_msg);
-                            sqlite3_free(err_msg);
-                        }
-                        // Identify Row-Level Clashes
-                        sqlite3_stmt *conflict_stmt;
-                        char select_conflict[256];
-                        snprintf(select_conflict, sizeof(select_conflict), "SELECT * FROM \"conflicted_pks_%s\";", table_name);
-                        if (sqlite3_prepare_v2(db_local, select_conflict, -1, &conflict_stmt, NULL) == SQLITE_OK) {
-                            while (sqlite3_step(conflict_stmt) == SQLITE_ROW) {
-                                const char *conflicted_pk_val = (const char *)sqlite3_column_text(conflict_stmt, 0);
-                                printf("WARNING: True Row Conflict detected on table '%s', PK '%s'. Preserving HEAD state.\n", table_name, conflicted_pk_val ? conflicted_pk_val : "NULL");
-                            }
-                            sqlite3_finalize(conflict_stmt);
-                        }
-                        char q1[1024];
-                        char q2[1024];
-                        // Query 1: Propagate Deletions from MERGE_HEAD
-                        snprintf(q1, sizeof(q1),
-                            "DELETE FROM main.\"%s\" WHERE \"%s\" IN (SELECT \"%s\" FROM ancestor.\"%s\" EXCEPT SELECT \"%s\" FROM other.\"%s\");",
-                            table_name, pk_col, pk_col, table_name, pk_col, table_name);
-                        if (sqlite3_exec(db_local, q1, NULL, 0, &err_msg) != SQLITE_OK) {
-                            fprintf(stderr, "Error executing deletion merge query: %s\n", err_msg);
-                            sqlite3_free(err_msg);
+                    if (has_pk) {
+                        int exists_in_ancestor = 0;
+                        char check_anc[256];
+                        snprintf(check_anc, sizeof(check_anc), "SELECT 1 FROM ancestor.sqlite_schema WHERE type='table' AND name='%s';", table_name);
+                        sqlite3_stmt *anc_stmt;
+                        if (sqlite3_prepare_v2(db_local, check_anc, -1, &anc_stmt, NULL) == SQLITE_OK) {
+                            if (sqlite3_step(anc_stmt) == SQLITE_ROW) exists_in_ancestor = 1;
+                            sqlite3_finalize(anc_stmt);
                         }
-                        // Query 2: Propagate Inserts & Updates from MERGE_HEAD, omitting row conflicts
-                        snprintf(q2, sizeof(q2),
-                            "REPLACE INTO main.\"%s\" SELECT * FROM other.\"%s\" WHERE \"%s\" IN (SELECT \"%s\" FROM (SELECT * FROM other.\"%s\" EXCEPT SELECT * FROM ancestor.\"%s\")) "
-                            "AND \"%s\" NOT IN (SELECT \"%s\" FROM \"conflicted_pks_%s\");",
-                            table_name, table_name, pk_col, pk_col, table_name, table_name, pk_col, pk_col, table_name);
-                        if (sqlite3_exec(db_local, q2, NULL, 0, &err_msg) != SQLITE_OK) {
-                            fprintf(stderr, "Error executing insert/update merge query: %s\n", err_msg);
-                            sqlite3_free(err_msg);
+                        if (exists_in_ancestor) {
+                            char drop_conflict[256];
+                            snprintf(drop_conflict, sizeof(drop_conflict), "DROP TABLE IF EXISTS temp.\"conflicted_pks_%s\";", table_name);
+                            sqlite3_exec(db_local, drop_conflict, NULL, 0, NULL);
+                            char conflict_query[1024];
+                            snprintf(conflict_query, sizeof(conflict_query),
+                                "CREATE TEMP TABLE \"conflicted_pks_%s\" AS "
+                                "SELECT \"%s\" FROM (SELECT * FROM main.\"%s\" EXCEPT SELECT * FROM ancestor.\"%s\") "
+                                "INTERSECT "
+                                "SELECT \"%s\" FROM (SELECT * FROM other.\"%s\" EXCEPT SELECT * FROM ancestor.\"%s\");",
+                                table_name,
+                                pk_col, table_name, table_name,
+                                pk_col, table_name, table_name);
+                            sqlite3_exec(db_local, conflict_query, NULL, 0, NULL);
+                            char q1[1024];
+                            char q2[1024];
+                            // Query 1: Propagate Deletions from MERGE_HEAD
+                            snprintf(q1, sizeof(q1),
+                                "DELETE FROM main.\"%s\" WHERE \"%s\" IN (SELECT \"%s\" FROM ancestor.\"%s\" EXCEPT SELECT \"%s\" FROM other.\"%s\");",
+                                table_name, pk_col, pk_col, table_name, pk_col, table_name);
+                            sqlite3_exec(db_local, q1, NULL, 0, NULL);
+                            // Query 2: Propagate Inserts & Updates from MERGE_HEAD, omitting row conflicts
+                            snprintf(q2, sizeof(q2),
+                                "REPLACE INTO main.\"%s\" SELECT * FROM other.\"%s\" WHERE \"%s\" IN (SELECT \"%s\" FROM (SELECT * FROM other.\"%s\" EXCEPT SELECT * FROM ancestor.\"%s\")) "
+                                "AND \"%s\" NOT IN (SELECT \"%s\" FROM \"conflicted_pks_%s\");",
+                                table_name, table_name, pk_col, pk_col, table_name, table_name, pk_col, pk_col, table_name);
+                            sqlite3_exec(db_local, q2, NULL, 0, NULL);
+                            sqlite3_exec(db_local, drop_conflict, NULL, 0, NULL);
+                        } else {
+                            char merge_query[512];
+                            snprintf(merge_query, sizeof(merge_query), "INSERT OR IGNORE INTO main.\"%s\" SELECT * FROM other.\"%s\";", table_name, table_name);
+                            sqlite3_exec(db_local, merge_query, NULL, 0, NULL);
                         }
-                        sqlite3_exec(db_local, drop_conflict, NULL, 0, NULL);
                     } else {
-                        // Fallback to naive 2-way append (table is new)
                         char merge_query[512];
-                        snprintf(merge_query, sizeof(merge_query),
-                                 "INSERT OR IGNORE INTO main.\"%s\" SELECT * FROM other.\"%s\";",
-                                 table_name, table_name);
+                        snprintf(merge_query, sizeof(merge_query), "INSERT OR IGNORE INTO main.\"%s\" SELECT * FROM other.\"%s\";", table_name, table_name);
                         sqlite3_exec(db_local, merge_query, NULL, 0, NULL);
                     }
-                } else {
-                    char merge_query[512];
-                    snprintf(merge_query, sizeof(merge_query),
-                             "INSERT OR IGNORE INTO main.\"%s\" SELECT * FROM other.\"%s\";",
-                             table_name, table_name);
-                    sqlite3_exec(db_local, merge_query, NULL, 0, NULL);
                 }
             }
+            sqlite3_finalize(stmt);
         }
-        sqlite3_finalize(stmt);
-    } else {
-        fprintf(stderr, "Failed to prepare schema query: %s\n", sqlite3_errmsg(db_local));
-    }
-    sqlite3_close(db_local);
+        sqlite3_close(db_local);
+        char git_add_cmd[1024];
+        snprintf(git_add_cmd, sizeof(git_add_cmd), "git add -A -f \"%s/pages/\"", base_dir);
+        if (system(git_add_cmd) != 0) {}
+        printf("Logical Merge Complete! VFS physical pages reconciled.\n");
+    }
-    if (system("git add -A -f .db/pages/") != 0) {}
-    if (system("rm -rf /tmp/gitvfs_other_db /tmp/gitvfs_ancestor_db") != 0) {}
+    // Now, copy the resulting file from the working tree to path_out (%A) so Git considers this file resolved!
+    // If the file doesn't exist anymore (deleted), we can just create an empty file or remove it.
+    char cp_cmd[1024];
+    if (access(path_repo, F_OK) == 0) {
+        snprintf(cp_cmd, sizeof(cp_cmd), "cp \"%s\" \"%s\"", path_repo, path_out);
+        if (system(cp_cmd) != 0) {
+            fprintf(stderr, "Failed to copy %s to %s\n", path_repo, path_out);
+        }
+    } else {
+        snprintf(cp_cmd, sizeof(cp_cmd), "rm -f \"%s\"", path_out);
+        if (system(cp_cmd) != 0) {}
+    }
-    printf("Logical Merge Complete! VFS physical pages reconciled.\n");
     return 0;
 }

package/c/gitvfs.c CHANGED Viewed

@@ -29,11 +29,34 @@ typedef struct gitvfs_file {
     int flat_fd;                    /* POSIX file descriptor for temp/journal files */
 } gitvfs_file;
+#ifdef _WIN32
+#include <direct.h>
+#include <io.h>
+#define MKDIR(p, m) _mkdir(p)
+ssize_t pread(int fd, void *buf, size_t count, off_t offset) {
+    off_t current = lseek(fd, 0, SEEK_CUR);
+    if (lseek(fd, offset, SEEK_SET) == (off_t)-1) return -1;
+    ssize_t ret = read(fd, buf, count);
+    lseek(fd, current, SEEK_SET);
+    return ret;
+}
+ssize_t pwrite(int fd, const void *buf, size_t count, off_t offset) {
+    off_t current = lseek(fd, 0, SEEK_CUR);
+    if (lseek(fd, offset, SEEK_SET) == (off_t)-1) return -1;
+    ssize_t ret = write(fd, buf, count);
+    lseek(fd, current, SEEK_SET);
+    return ret;
+}
+#else
+#define MKDIR(p, m) mkdir(p, m)
+#endif
 /*
- * Utility: Recursively create directories (mkdir -p behavior)
  * Helps ensure our nested sharded directory structure exists before writing.
  */
 static int mkdir_p(const char *path, mode_t mode) {
+    (void)mode;
     char tmp[GITVFS_MAX_PATH];
     char *p = NULL;
     size_t len;
@@ -47,13 +70,13 @@ static int mkdir_p(const char *path, mode_t mode) {
     for (p = tmp + 1; *p; p++) {
         if (*p == '/') {
             *p = 0;
-            if (mkdir(tmp, mode) != 0 && errno != EEXIST) {
+            if (MKDIR(tmp, mode) != 0 && errno != EEXIST) {
                 return -1;
             }
             *p = '/';
         }
     }
-    if (mkdir(tmp, mode) != 0 && errno != EEXIST) {
+    if (MKDIR(tmp, mode) != 0 && errno != EEXIST) {
         return -1;
     }
     return 0;
@@ -108,7 +131,7 @@ static void generate_gitattributes(const char *base_dir) {
     // Create the .gitattributes file
     FILE *f = fopen(attr_path, "w");
     if (f) {
-        fprintf(f, "*.bin binary\nsize.meta binary\n");
+        fprintf(f, "*.bin -text -diff merge=sqlitevfs\nsize.meta -text -diff merge=sqlitevfs\n");
         fclose(f);
     }
 }
@@ -271,7 +294,7 @@ static int gitvfs_Truncate(sqlite3_file *pFile, sqlite3_int64 size) {
         snprintf(meta_path, sizeof(meta_path), "%s/pages/size.meta", p->base_dir);
         if (new_max_page == -1) {
-            unlink(meta_path); // DB is completely empty
+            remove(meta_path); // DB is completely empty
         } else {
             FILE *f = fopen(meta_path, "w");
             if (f) {
@@ -285,6 +308,7 @@ static int gitvfs_Truncate(sqlite3_file *pFile, sqlite3_int64 size) {
 }
 static int gitvfs_Sync(sqlite3_file *pFile, int flags) {
+    (void)pFile; (void)flags;
     // Single-writer MVP relying on standard POSIX disk flushes.
     // For temp files we could call fsync(p->flat_fd).
     // Returning SQLITE_OK satisfies SQLite's expectation.
@@ -309,6 +333,7 @@ static int gitvfs_FileSize(sqlite3_file *pFile, sqlite3_int64 *pSize) {
 }
 static int gitvfs_Lock(sqlite3_file *pFile, int eLock) {
+    (void)pFile; (void)eLock;
     return SQLITE_OK; // SQLite requires lock functions to succeed
 }
@@ -318,19 +343,23 @@ static int gitvfs_Unlock(sqlite3_file *pFile, int eLock) {
 }
 static int gitvfs_CheckReservedLock(sqlite3_file *pFile, int *pResOut) {
+    (void)pFile;
     *pResOut = 0;
     return SQLITE_OK;
 }
 static int gitvfs_FileControl(sqlite3_file *pFile, int op, void *pArg) {
+    (void)pFile; (void)op; (void)pArg;
     return SQLITE_NOTFOUND;
 }
 static int gitvfs_SectorSize(sqlite3_file *pFile) {
+    (void)pFile;
     return GITVFS_PAGE_SIZE;
 }
 static int gitvfs_DeviceCharacteristics(sqlite3_file *pFile) {
+    (void)pFile;
     return 0; // Standard characteristics
 }
@@ -363,8 +392,13 @@ static const sqlite3_io_methods gitvfs_io_methods = {
 static sqlite3_vfs *orig_vfs = NULL;
 static int gitvfs_Open(sqlite3_vfs *pVfs, const char *zName, sqlite3_file *pFile, int flags, int *pOutFlags) {
+    (void)pVfs;
     if (!orig_vfs) orig_vfs = sqlite3_vfs_find(NULL);
-    if (!zName || strstr(zName, ".db") == NULL) {
+    const char *vfs_dir = getenv("GIT_SQLITE_VFS_DIR");
+    if (!vfs_dir) {
+        vfs_dir = ".db";
+    }
+    if (!zName || strstr(zName, vfs_dir) == NULL) {
         return orig_vfs->xOpen(orig_vfs, zName, pFile, flags, pOutFlags);
     }
     gitvfs_file *p = (gitvfs_file*)pFile;
@@ -376,7 +410,7 @@ static int gitvfs_Open(sqlite3_vfs *pVfs, const char *zName, sqlite3_file *pFile
     if (flags & SQLITE_OPEN_MAIN_DB) {
         p->is_main_db = 1;
-        const char *base = (zName != NULL) ? zName : ".db";
+        const char *base = (zName != NULL) ? zName : vfs_dir;
         // Strip URI parameters if they exist
         char clean_base[GITVFS_MAX_PATH];
@@ -441,36 +475,39 @@ static int gitvfs_Open(sqlite3_vfs *pVfs, const char *zName, sqlite3_file *pFile
 }
 static int gitvfs_Delete(sqlite3_vfs *pVfs, const char *zName, int syncDir) {
+    (void)pVfs; (void)syncDir;
     // Standard file deletion, primarily used for clearing out old journals
     unlink(zName);
     return SQLITE_OK;
 }
 static int gitvfs_Access(sqlite3_vfs *pVfs, const char *zName, int flags, int *pResOut) {
+    (void)pVfs; (void)flags;
     // Check if the directory or file is accessible
     *pResOut = (access(zName, F_OK) == 0) ? 1 : 0;
     return SQLITE_OK;
 }
 static int gitvfs_FullPathname(sqlite3_vfs *pVfs, const char *zName, int nOut, char *zOut) {
+    (void)pVfs;
     snprintf(zOut, nOut, "%s", zName);
     return SQLITE_OK;
 }
 /* System calls to load extensions (stubbed) */
-static void *gitvfs_DlOpen(sqlite3_vfs *pVfs, const char *zFilename) { return orig_vfs->xDlOpen(orig_vfs, zFilename); }
-static void gitvfs_DlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg) { orig_vfs->xDlError(orig_vfs, nByte, zErrMsg); }
-static void (*gitvfs_DlSym(sqlite3_vfs *pVfs, void *p, const char*zSymbol))(void) { return orig_vfs->xDlSym(orig_vfs, p, zSymbol); }
-static void gitvfs_DlClose(sqlite3_vfs *pVfs, void *pHandle) { orig_vfs->xDlClose(orig_vfs, pHandle); }
-static int gitvfs_Randomness(sqlite3_vfs *pVfs, int nByte, char *zOut) { return orig_vfs->xRandomness(orig_vfs, nByte, zOut); }
-static int gitvfs_Sleep(sqlite3_vfs *pVfs, int microseconds) { return orig_vfs->xSleep(orig_vfs, microseconds); }
-static int gitvfs_CurrentTime(sqlite3_vfs *pVfs, double *prNow) { return orig_vfs->xCurrentTime(orig_vfs, prNow); }
-static int gitvfs_GetLastError(sqlite3_vfs *pVfs, int a, char *b) { return orig_vfs->xGetLastError ? orig_vfs->xGetLastError(orig_vfs, a, b) : 0; }
-static int gitvfs_CurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p) { return orig_vfs->xCurrentTimeInt64 ? orig_vfs->xCurrentTimeInt64(orig_vfs, p) : 0; }
-static int gitvfs_SetSystemCall(sqlite3_vfs *pVfs, const char *zName, sqlite3_syscall_ptr pNew) { return orig_vfs->xSetSystemCall ? orig_vfs->xSetSystemCall(orig_vfs, zName, pNew) : SQLITE_ERROR; }
-static sqlite3_syscall_ptr gitvfs_GetSystemCall(sqlite3_vfs *pVfs, const char *zName) { return orig_vfs->xGetSystemCall ? orig_vfs->xGetSystemCall(orig_vfs, zName) : NULL; }
-static const char *gitvfs_NextSystemCall(sqlite3_vfs *pVfs, const char *zName) { return orig_vfs->xNextSystemCall ? orig_vfs->xNextSystemCall(orig_vfs, zName) : NULL; }
+static void *gitvfs_DlOpen(sqlite3_vfs *pVfs, const char *zFilename) { (void)pVfs; return orig_vfs->xDlOpen(orig_vfs, zFilename); }
+static void gitvfs_DlError(sqlite3_vfs *pVfs, int nByte, char *zErrMsg) { (void)pVfs; orig_vfs->xDlError(orig_vfs, nByte, zErrMsg); }
+static void (*gitvfs_DlSym(sqlite3_vfs *pVfs, void *p, const char*zSymbol))(void) { (void)pVfs; return orig_vfs->xDlSym(orig_vfs, p, zSymbol); }
+static void gitvfs_DlClose(sqlite3_vfs *pVfs, void *pHandle) { (void)pVfs; orig_vfs->xDlClose(orig_vfs, pHandle); }
+static int gitvfs_Randomness(sqlite3_vfs *pVfs, int nByte, char *zOut) { (void)pVfs; return orig_vfs->xRandomness(orig_vfs, nByte, zOut); }
+static int gitvfs_Sleep(sqlite3_vfs *pVfs, int microseconds) { (void)pVfs; return orig_vfs->xSleep(orig_vfs, microseconds); }
+static int gitvfs_CurrentTime(sqlite3_vfs *pVfs, double *prNow) { (void)pVfs; return orig_vfs->xCurrentTime(orig_vfs, prNow); }
+static int gitvfs_GetLastError(sqlite3_vfs *pVfs, int a, char *b) { (void)pVfs; return orig_vfs->xGetLastError ? orig_vfs->xGetLastError(orig_vfs, a, b) : 0; }
+static int gitvfs_CurrentTimeInt64(sqlite3_vfs *pVfs, sqlite3_int64 *p) { (void)pVfs; return orig_vfs->xCurrentTimeInt64 ? orig_vfs->xCurrentTimeInt64(orig_vfs, p) : 0; }
+static int gitvfs_SetSystemCall(sqlite3_vfs *pVfs, const char *zName, sqlite3_syscall_ptr pNew) { (void)pVfs; return orig_vfs->xSetSystemCall ? orig_vfs->xSetSystemCall(orig_vfs, zName, pNew) : SQLITE_ERROR; }
+static sqlite3_syscall_ptr gitvfs_GetSystemCall(sqlite3_vfs *pVfs, const char *zName) { (void)pVfs; return orig_vfs->xGetSystemCall ? orig_vfs->xGetSystemCall(orig_vfs, zName) : NULL; }
+static const char *gitvfs_NextSystemCall(sqlite3_vfs *pVfs, const char *zName) { (void)pVfs; return orig_vfs->xNextSystemCall ? orig_vfs->xNextSystemCall(orig_vfs, zName) : NULL; }
 /*
  * Entry point to register our Git VFS.
@@ -516,11 +553,22 @@ int sqlite3_gitvfs_init_impl(const char *base_dir) {
 #ifdef _WIN32
 __declspec(dllexport)
 #endif
-int sqlite3_gitvfs_init(sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi) {
+int sqlite3_extension_init(sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi) {
     (void)db; (void)pzErrMsg;
     SQLITE_EXTENSION_INIT2(pApi);
     int rc = sqlite3_gitvfs_init_impl(".db");
     return (rc == SQLITE_OK) ? SQLITE_OK_LOAD_PERMANENTLY : rc;
 }
+#ifdef _WIN32
+__declspec(dllexport)
+#endif
+int sqlite3_gitvfs_init(sqlite3 *db, char **pzErrMsg, const sqlite3_api_routines *pApi) {
+    return sqlite3_extension_init(db, pzErrMsg, pApi);
+}
 #endif