feat: add write-cache and some stuff | functional

Author: superstrellaa

build.gradle

@@ -1,6 +1,5 @@
 plugins {
 	id 'net.fabricmc.fabric-loom-remap' version "${loom_version}"
-	id 'maven-publish'
 }
 
 version = "${project.mod_version}+${project.minecraft_version}"

src/main/java/es/superstrellaa/storagemanager/StorageManagerAPI.java

@@ -1,6 +1,7 @@
 package es.superstrellaa.storagemanager;
 
 import es.superstrellaa.storagemanager.internal.SQLiteBackend;
+import es.superstrellaa.storagemanager.internal.cache.WriteCache;
 import es.superstrellaa.storagemanager.internal.lifecycle.ShutdownHook;
 import net.fabricmc.api.ModInitializer;
 import org.slf4j.Logger;
@@ -11,11 +12,14 @@ public class StorageManagerAPI implements ModInitializer {
 	public static final String MOD_ID = "storagemanager-api";
 	public static final Logger LOGGER = LoggerFactory.getLogger(MOD_ID);
 
+	//TODO General: Optimizar algo más, separar clases grandes en varias pequeñas y nuevas funcionalidades(añadir sistema de usar otro tipo de Backend aparte de SQLite, como texto plano(json, xml...) o PostgreSQL/MySQL)
+
 	@Override
 	public void onInitialize() {
 		SQLiteBackend.init();
+		WriteCache.getInstance().start();
 		ShutdownHook.register();
 
-		LOGGER.info("StorageManager API initialized");
+		LOGGER.info("StorageManager API initialized with write-behind cache");
 	}
-}
+}

src/main/java/es/superstrellaa/storagemanager/api/StorageManager.java

@@ -3,27 +3,78 @@
 import es.superstrellaa.storagemanager.api.data.RowData;
 import es.superstrellaa.storagemanager.api.schema.TableSchema;
 import es.superstrellaa.storagemanager.internal.TableExecutor;
+import es.superstrellaa.storagemanager.internal.cache.WriteCache;
 
 import java.util.List;
 import java.util.Map;
 
+/**
+ * API principal para interactuar con StorageManager.
+ *
+ * Por defecto, todas las operaciones de escritura usan un sistema de caché
+ * que agrupa operaciones y las ejecuta en lotes cada 5 segundos.
+ *
+ * Para datos críticos que necesitas guardar inmediatamente, usa los métodos *Immediate
+ * o llama a flush() manualmente.
+ */
 public final class StorageManager {
 
+    /**
+     * Registra una tabla en la base de datos
+     */
     public static void registerTable(TableSchema schema) {
         TableExecutor.createTable(schema);
     }
 
+    /**
+     * Inserta datos (modo async con caché, recomendado para la mayoría de casos)
+     */
     public static void insert(String table, RowData data) {
-        TableExecutor.insert(table, data);
+        TableExecutor.insert(table, data, false);
     }
 
+    /**
+     * Inserta datos inmediatamente sin usar caché (para datos críticos)
+     */
+    public static void insertImmediate(String table, RowData data) {
+        TableExecutor.insert(table, data, true);
+    }
+
+    /**
+     * Selecciona datos de una tabla.
+     * Automáticamente hace flush de la caché antes de leer.
+     */
     public static List<RowData> select(String table, Map<String, Object> where) {
         return TableExecutor.select(table, where);
     }
 
+    /**
+     * Elimina datos (modo async con caché)
+     */
     public static void delete(String table, Map<String, Object> where) {
-        TableExecutor.delete(table, where);
+        TableExecutor.delete(table, where, false);
+    }
+
+    /**
+     * Elimina datos inmediatamente sin usar caché
+     */
+    public static void deleteImmediate(String table, Map<String, Object> where) {
+        TableExecutor.delete(table, where, true);
+    }
+
+    /**
+     * Fuerza el guardado de todas las operaciones pendientes de una tabla específica
+     */
+    public static void flush(String table) {
+        WriteCache.getInstance().flushTable(table);
+    }
+
+    /**
+     * Fuerza el guardado de todas las operaciones pendientes de todas las tablas
+     */
+    public static void flushAll() {
+        WriteCache.getInstance().flushAll();
     }
 
     private StorageManager() {}
-}
+}

src/main/java/es/superstrellaa/storagemanager/internal/SQLiteBackend.java

@@ -12,8 +12,6 @@ public final class SQLiteBackend {
 
     private static Connection connection;
 
-    //TODO: Separar esta barbaridad en otras clases auxiliares
-
     public static void init() {
         try {
             Path dbPath = StoragePaths.getDatabasePath();

src/main/java/es/superstrellaa/storagemanager/internal/TableExecutor.java

@@ -4,6 +4,7 @@
 import es.superstrellaa.storagemanager.api.data.RowData;
 import es.superstrellaa.storagemanager.api.schema.Column;
 import es.superstrellaa.storagemanager.api.schema.TableSchema;
+import es.superstrellaa.storagemanager.internal.cache.WriteCache;
 
 import java.sql.*;
 import java.util.ArrayList;
@@ -13,6 +14,9 @@
 
 public final class TableExecutor {
 
+    /**
+     * Crea una tabla según el esquema proporcionado
+     */
     public static void createTable(TableSchema schema) {
         StringBuilder sql = new StringBuilder();
         sql.append("CREATE TABLE IF NOT EXISTS ")
@@ -46,7 +50,29 @@ public static void createTable(TableSchema schema) {
         execute(sql.toString());
     }
 
+    /**
+     * Inserta datos usando la caché (modo async, más rápido)
+     */
     public static void insert(String table, RowData data) {
+        insert(table, data, false);
+    }
+
+    /**
+     * Inserta datos con opción de bypass de caché
+     * @param immediate si es true, escribe inmediatamente a DB sin usar caché
+     */
+    public static void insert(String table, RowData data, boolean immediate) {
+        if (immediate) {
+            insertImmediate(table, data);
+        } else {
+            WriteCache.getInstance().queueInsert(table, data);
+        }
+    }
+
+    /**
+     * Inserción inmediata sin caché (para datos críticos)
+     */
+    private static void insertImmediate(String table, RowData data) {
         StringJoiner columns = new StringJoiner(", ");
         StringJoiner values = new StringJoiner(", ");
 
@@ -72,7 +98,14 @@ public static void insert(String table, RowData data) {
         }
     }
 
+    /**
+     * SELECT siempre lee directamente de la DB
+     * Antes de leer, hace flush de la tabla para asegurar que los datos estén actualizados
+     */
     public static List<RowData> select(String table, Map<String, Object> where) {
+        // Flush antes de leer para tener datos actualizados por si acaso
+        WriteCache.getInstance().flushTable(table);
+
         List<RowData> results = new ArrayList<>();
 
         StringBuilder sql = new StringBuilder("SELECT * FROM ").append(table);
@@ -108,11 +141,29 @@ public static List<RowData> select(String table, Map<String, Object> where) {
         return results;
     }
 
+    /**
+     * Elimina usando caché por defecto
+     */
     public static void delete(String table, Map<String, Object> where) {
+        delete(table, where, false);
+    }
+
+    /**
+     * Elimina con opción de inmediatez
+     */
+    public static void delete(String table, Map<String, Object> where, boolean immediate) {
         if (where.isEmpty()) {
             throw new IllegalArgumentException("DELETE without WHERE is not allowed");
         }
 
+        if (immediate) {
+            deleteImmediate(table, where);
+        } else {
+            WriteCache.getInstance().queueDelete(table, where);
+        }
+    }
+
+    private static void deleteImmediate(String table, Map<String, Object> where) {
         String sql = "DELETE FROM " + table +
                 " WHERE " + buildWhereClause(where) + ";";
 
@@ -151,4 +202,4 @@ private static void execute(String sql) {
     }
 
     private TableExecutor() {}
-}
+}