X-Git-Url: https://git.ktnx.net/?p=mobile-ledger.git;a=blobdiff_plain;f=app%2Fsrc%2Fmain%2Fjava%2Fnet%2Fktnx%2Fmobileledger%2Fdb%2FDB.java;h=482628888b1b021c9b78d53eb159ab974c479d2e;hp=9c2bc113311088b3e34d97a2f68243fd8e4f6f08;hb=833544eb24cb630dc1ce221e4aa3dedb3f6341e3;hpb=ac02090e6042d34afc00e2dde45e70f49e2dbedc diff --git a/app/src/main/java/net/ktnx/mobileledger/db/DB.java b/app/src/main/java/net/ktnx/mobileledger/db/DB.java index 9c2bc113..48262888 100644 --- a/app/src/main/java/net/ktnx/mobileledger/db/DB.java +++ b/app/src/main/java/net/ktnx/mobileledger/db/DB.java @@ -17,16 +17,244 @@ package net.ktnx.mobileledger.db; +import android.content.res.Resources; +import android.database.Cursor; +import android.database.SQLException; + +import androidx.annotation.NonNull; +import androidx.lifecycle.MutableLiveData; import androidx.room.Database; +import androidx.room.Room; import androidx.room.RoomDatabase; +import androidx.room.migration.Migration; +import androidx.sqlite.db.SupportSQLiteDatabase; +import net.ktnx.mobileledger.App; +import net.ktnx.mobileledger.dao.AccountDAO; +import net.ktnx.mobileledger.dao.AccountValueDAO; import net.ktnx.mobileledger.dao.CurrencyDAO; -import net.ktnx.mobileledger.dao.PatternAccountDAO; -import net.ktnx.mobileledger.dao.PatternHeaderDAO; +import net.ktnx.mobileledger.dao.OptionDAO; +import net.ktnx.mobileledger.dao.ProfileDAO; +import net.ktnx.mobileledger.dao.TemplateAccountDAO; +import net.ktnx.mobileledger.dao.TemplateHeaderDAO; +import net.ktnx.mobileledger.dao.TransactionAccountDAO; +import net.ktnx.mobileledger.dao.TransactionDAO; +import net.ktnx.mobileledger.utils.Logger; + +import org.jetbrains.annotations.NotNull; + +import java.io.BufferedReader; +import java.io.IOException; +import java.io.InputStream; +import java.io.InputStreamReader; +import java.util.Locale; +import java.util.UUID; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +import static net.ktnx.mobileledger.utils.Logger.debug; -@Database(version = 49, entities = {PatternHeader.class, PatternAccount.class, Currency.class}) +@Database(version = DB.REVISION, + entities = {TemplateHeader.class, TemplateAccount.class, Currency.class, Account.class, + Profile.class, Option.class, AccountValue.class, Transaction.class, + TransactionAccount.class + }) abstract public class DB extends RoomDatabase { - public abstract PatternHeaderDAO getPatternDAO(); - public abstract PatternAccountDAO getPatternAccountDAO(); + public static final int REVISION = 65; + public static final String DB_NAME = "MoLe.db"; + public static final MutableLiveData initComplete = new MutableLiveData<>(false); + private static DB instance; + public static DB get() { + if (instance != null) + return instance; + synchronized (DB.class) { + if (instance != null) + return instance; + + RoomDatabase.Builder builder = + Room.databaseBuilder(App.instance, DB.class, DB_NAME); + builder.addMigrations( + new Migration[]{singleVersionMigration(17), singleVersionMigration(18), + singleVersionMigration(19), singleVersionMigration(20), + multiVersionMigration(20, 22), multiVersionMigration(22, 30), + multiVersionMigration(30, 32), multiVersionMigration(32, 34), + multiVersionMigration(34, 40), singleVersionMigration(41), + multiVersionMigration(41, 58), singleVersionMigration(59), + singleVersionMigration(60), singleVersionMigration(61), + singleVersionMigration(62), singleVersionMigration(63), + singleVersionMigration(64), new Migration(64, 65) { + @Override + public void migrate(@NonNull @NotNull SupportSQLiteDatabase database) { + try (Cursor c = database.query( + "SELECT id, description FROM transactions")) + { + while (c.moveToNext()) { + final long id = c.getLong(0); + final String description = c.getString(1); + database.execSQL( + "UPDATE transactions SET description_uc=? WHERE id=?", + new Object[]{description.toUpperCase(), id + }); + } + } + } + } + }) + .addCallback(new Callback() { + @Override + public void onOpen(@NonNull SupportSQLiteDatabase db) { + super.onOpen(db); + db.execSQL("PRAGMA foreign_keys = ON"); + db.execSQL("pragma case_sensitive_like" + "=ON;"); + + } + }); + +// if (BuildConfig.DEBUG) +// builder.setQueryCallback(((sqlQuery, bindArgs) -> Logger.debug("room", sqlQuery)), +// Executors.newSingleThreadExecutor()); + + return instance = builder.build(); + } + } + private static Migration singleVersionMigration(int toVersion) { + return new Migration(toVersion - 1, toVersion) { + @Override + public void migrate(@NonNull SupportSQLiteDatabase db) { + String fileName = String.format(Locale.US, "db_%d", toVersion); + + applyRevisionFile(db, fileName); + + // when migrating to version 59, migrate profile/theme options to the + // SharedPreferences + if (toVersion == 59) { + try (Cursor c = db.query( + "SELECT p.id, p.theme FROM profiles p WHERE p.id=(SELECT o.value " + + "FROM options o WHERE o.profile_id=0 AND o.name=?)", + new Object[]{"profile_id"})) + { + if (c.moveToFirst()) { + long currentProfileId = c.getLong(0); + int currentTheme = c.getInt(1); + + if (currentProfileId >= 0 && currentTheme >= 0) { + App.storeStartupProfileAndTheme(currentProfileId, currentTheme); + } + } + } + } + if (toVersion == 63) { + try (Cursor c = db.query("SELECT id FROM templates")) { + while (c.moveToNext()) { + db.execSQL("UPDATE templates SET uuid=? WHERE id=?", + new Object[]{UUID.randomUUID().toString(), c.getLong(0)}); + } + } + } + } + }; + } + private static Migration dummyVersionMigration(int toVersion) { + return new Migration(toVersion - 1, toVersion) { + @Override + public void migrate(@NonNull SupportSQLiteDatabase db) { + Logger.debug("db", + String.format(Locale.ROOT, "Dummy DB migration to version %d", toVersion)); + } + }; + } + private static Migration multiVersionMigration(int fromVersion, int toVersion) { + return new Migration(fromVersion, toVersion) { + @Override + public void migrate(@NonNull SupportSQLiteDatabase db) { + String fileName = String.format(Locale.US, "db_%d_%d", fromVersion, toVersion); + + applyRevisionFile(db, fileName); + } + }; + } + public static void applyRevisionFile(@NonNull SupportSQLiteDatabase db, String fileName) { + final Resources rm = App.instance.getResources(); + int res_id = rm.getIdentifier(fileName, "raw", App.instance.getPackageName()); + if (res_id == 0) + throw new SQLException(String.format(Locale.US, "No resource for %s", fileName)); + + try (InputStream res = rm.openRawResource(res_id)) { + debug("db", "Applying " + fileName); + InputStreamReader isr = new InputStreamReader(res); + BufferedReader reader = new BufferedReader(isr); + + Pattern endOfStatement = Pattern.compile(";\\s*(?:--.*)?$"); + + String line; + String sqlStatement = null; + int lineNo = 0; + while ((line = reader.readLine()) != null) { + lineNo++; + if (line.startsWith("--")) + continue; + if (line.isEmpty()) + continue; + + if (sqlStatement == null) + sqlStatement = line; + else + sqlStatement = sqlStatement.concat(" " + line); + + Matcher m = endOfStatement.matcher(line); + if (!m.find()) + continue; + + try { + db.execSQL(sqlStatement); + sqlStatement = null; + } + catch (Exception e) { + throw new RuntimeException( + String.format("Error applying %s, line %d, statement: %s", fileName, + lineNo, sqlStatement), e); + } + } + + if (sqlStatement != null) + throw new RuntimeException(String.format( + "Error applying %s: EOF after continuation. Line %s, Incomplete " + + "statement: %s", fileName, lineNo, sqlStatement)); + + } + catch (IOException e) { + throw new RuntimeException(String.format("Error opening raw resource for %s", fileName), + e); + } + } + public abstract TemplateHeaderDAO getTemplateDAO(); + + public abstract TemplateAccountDAO getTemplateAccountDAO(); + public abstract CurrencyDAO getCurrencyDAO(); + + public abstract AccountDAO getAccountDAO(); + + public abstract AccountValueDAO getAccountValueDAO(); + + public abstract TransactionDAO getTransactionDAO(); + + public abstract TransactionAccountDAO getTransactionAccountDAO(); + + public abstract OptionDAO getOptionDAO(); + + public abstract ProfileDAO getProfileDAO(); + + @androidx.room.Transaction + public void deleteAllSync() { + getTransactionAccountDAO().deleteAllSync(); + getTransactionDAO().deleteAllSync(); + getAccountValueDAO().deleteAllSync(); + getAccountDAO().deleteAllSync(); + getTemplateAccountDAO().deleteAllSync(); + getTemplateDAO().deleteAllSync(); + getCurrencyDAO().deleteAllSync(); + getOptionDAO().deleteAllSync(); + getProfileDAO().deleteAllSync(); + } }