Merge "Drop support for device configurable "compatibility WAL"." (01794b57) · Commits · e / os / android_frameworks_base

api/test-current.txt

+0 −1

Original line number	Diff line number	Diff line
		@@ -684,7 +684,6 @@ package android.database.sqlite {
		method public static int getWALAutoCheckpoint();
		method public static int getWALConnectionPoolSize();
		method public static String getWALSyncMode();
		method public static boolean isCompatibilityWalSupported();
		method public static int releaseMemory();
		}

core/java/android/database/sqlite/SQLiteCompatibilityWalFlags.java

+16 −20

Original line number	Diff line number	Diff line
		@@ -40,8 +40,7 @@ public class SQLiteCompatibilityWalFlags {
		private static final String TAG = "SQLiteCompatibilityWalFlags";

		private static volatile boolean sInitialized;
		private static volatile boolean sFlagsSet;
		private static volatile boolean sCompatibilityWalSupported;
		private static volatile boolean sLegacyCompatibilityWalEnabled;
		private static volatile String sWALSyncMode;
		private static volatile long sTruncateSize = -1;
		// This flag is used to avoid recursive initialization due to circular dependency on Settings
		@@ -54,26 +53,25 @@ public class SQLiteCompatibilityWalFlags {
		* @hide
		*/
		@VisibleForTesting
		public static boolean areFlagsSet() {
		public static boolean isLegacyCompatibilityWalEnabled() {
		initIfNeeded();
		return sFlagsSet;
		return sLegacyCompatibilityWalEnabled;
		}

		/**
		* @hide
		*/
		@VisibleForTesting
		public static boolean isCompatibilityWalSupported() {
		public static String getWALSyncMode() {
		initIfNeeded();
		return sCompatibilityWalSupported;
		// The configurable WAL sync mode should only ever be used if the legacy compatibility
		// WAL is enabled. It should not have any effect if app developers explicitly turn on
		// WAL for their database using setWriteAheadLoggingEnabled. Throwing an exception here
		// adds an extra layer of checking that we never use it in the wrong place.
		if (!sLegacyCompatibilityWalEnabled) {
		throw new IllegalStateException("isLegacyCompatibilityWalEnabled() == false");
		}

		/**
		* @hide
		*/
		@VisibleForTesting
		public static String getWALSyncMode() {
		initIfNeeded();
		return sWALSyncMode;
		}

		@@ -131,13 +129,12 @@ public class SQLiteCompatibilityWalFlags {
		sInitialized = true;
		return;
		}
		sCompatibilityWalSupported = parser.getBoolean("compatibility_wal_supported",
		SQLiteGlobal.isCompatibilityWalSupported());
		sLegacyCompatibilityWalEnabled = parser.getBoolean(
		"legacy_compatibility_wal_enabled", false);
		sWALSyncMode = parser.getString("wal_syncmode", SQLiteGlobal.getWALSyncMode());
		sTruncateSize = parser.getInt("truncate_size", -1);
		Log.i(TAG, "Read compatibility WAL flags: compatibility_wal_supported="
		+ sCompatibilityWalSupported + ", wal_syncmode=" + sWALSyncMode);
		sFlagsSet = true;
		Log.i(TAG, "Read compatibility WAL flags: legacy_compatibility_wal_enabled="
		+ sLegacyCompatibilityWalEnabled + ", wal_syncmode=" + sWALSyncMode);
		sInitialized = true;
		}

		@@ -148,8 +145,7 @@ public class SQLiteCompatibilityWalFlags {
		@TestApi
		public static void reset() {
		sInitialized = false;
		sFlagsSet = false;
		sCompatibilityWalSupported = false;
		sLegacyCompatibilityWalEnabled = false;
		sWALSyncMode = null;
		}
		}

core/java/android/database/sqlite/SQLiteConnection.java

+5 −4

Original line number	Diff line number	Diff line
		@@ -300,12 +300,13 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen
		(mConfiguration.openFlags & SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING) != 0;
		// Use compatibility WAL unless an app explicitly set journal/synchronous mode
		// or DISABLE_COMPATIBILITY_WAL flag is set
		final boolean useCompatibilityWal = mConfiguration.useCompatibilityWal();
		if (walEnabled \|\| useCompatibilityWal) {
		final boolean isCompatibilityWalEnabled =
		mConfiguration.isLegacyCompatibilityWalEnabled();
		if (walEnabled \|\| isCompatibilityWalEnabled) {
		setJournalMode("WAL");
		if (mConfiguration.syncMode != null) {
		setSyncMode(mConfiguration.syncMode);
		} else if (useCompatibilityWal && SQLiteCompatibilityWalFlags.areFlagsSet()) {
		} else if (isCompatibilityWalEnabled) {
		setSyncMode(SQLiteCompatibilityWalFlags.getWALSyncMode());
		} else {
		setSyncMode(SQLiteGlobal.getWALSyncMode());
		@@ -504,7 +505,7 @@ public final class SQLiteConnection implements CancellationSignal.OnCancelListen
		!= mConfiguration.foreignKeyConstraintsEnabled;
		boolean walModeChanged = ((configuration.openFlags ^ mConfiguration.openFlags)
		& (SQLiteDatabase.ENABLE_WRITE_AHEAD_LOGGING
		\| SQLiteDatabase.DISABLE_COMPATIBILITY_WAL)) != 0;
		\| SQLiteDatabase.ENABLE_LEGACY_COMPATIBILITY_WAL)) != 0;
		boolean localeChanged = !configuration.locale.equals(mConfiguration.locale);

		// Update configuration parameters.

core/java/android/database/sqlite/SQLiteConnectionPool.java

+5 −6

Original line number	Diff line number	Diff line
		@@ -321,7 +321,7 @@ public final class SQLiteConnectionPool implements Closeable {
		// We should do in-place switching when transitioning from compatibility WAL
		// to rollback journal. Otherwise transient connection state will be lost
		boolean onlyCompatWalChanged = (mConfiguration.openFlags ^ configuration.openFlags)
		== SQLiteDatabase.DISABLE_COMPATIBILITY_WAL;
		== SQLiteDatabase.ENABLE_LEGACY_COMPATIBILITY_WAL;

		if (!onlyCompatWalChanged && mConfiguration.openFlags != configuration.openFlags) {
		// If we are changing open flags and WAL mode at the same time, then
		@@ -1113,19 +1113,18 @@ public final class SQLiteConnectionPool implements Closeable {
		if (directories != null) {
		directories.add(new File(mConfiguration.path).getParent());
		}
		boolean isCompatibilityWalEnabled = mConfiguration.isLegacyCompatibilityWalEnabled();
		printer.println("Connection pool for " + mConfiguration.path + ":");
		printer.println(" Open: " + mIsOpen);
		printer.println(" Max connections: " + mMaxConnectionPoolSize);
		printer.println(" Total execution time: " + mTotalExecutionTimeCounter);
		printer.println(" Configuration: openFlags=" + mConfiguration.openFlags
		+ ", useCompatibilityWal=" + mConfiguration.useCompatibilityWal()
		+ ", isLegacyCompatibilityWalEnabled=" + isCompatibilityWalEnabled
		+ ", journalMode=" + TextUtils.emptyIfNull(mConfiguration.journalMode)
		+ ", syncMode=" + TextUtils.emptyIfNull(mConfiguration.syncMode));

		if (SQLiteCompatibilityWalFlags.areFlagsSet()) {
		printer.println(" Compatibility WAL settings: compatibility_wal_supported="
		+ SQLiteCompatibilityWalFlags
		.isCompatibilityWalSupported() + ", wal_syncmode="
		if (isCompatibilityWalEnabled) {
		printer.println(" Compatibility WAL enabled: wal_syncmode="
		+ SQLiteCompatibilityWalFlags.getWALSyncMode());
		}
		if (mConfiguration.isLookasideConfigSet()) {

core/java/android/database/sqlite/SQLiteDatabase.java

+17 −11

Original line number	Diff line number	Diff line
		@@ -266,12 +266,17 @@ public final class SQLiteDatabase extends SQLiteClosable {
		*/
		public static final int ENABLE_WRITE_AHEAD_LOGGING = 0x20000000;


		// Note: The below value was only used on Android Pie.
		// public static final int DISABLE_COMPATIBILITY_WAL = 0x40000000;

		/**
		* Open flag: Flag for {@link #openDatabase} to disable Compatibility WAL when opening database.
		* Open flag: Flag for {@link #openDatabase} to enable the legacy Compatibility WAL when opening
		* database.
		*
		* @hide
		*/
		public static final int DISABLE_COMPATIBILITY_WAL = 0x40000000;
		public static final int ENABLE_LEGACY_COMPATIBILITY_WAL = 0x80000000;

		/**
		* Absolute max value that can be set by {@link #setMaxSqlCacheSize(int)}.
		@@ -309,10 +314,8 @@ public final class SQLiteDatabase extends SQLiteClosable {
		mConfigurationLocked.idleConnectionTimeoutMs = effectiveTimeoutMs;
		mConfigurationLocked.journalMode = journalMode;
		mConfigurationLocked.syncMode = syncMode;
		if (!SQLiteGlobal.isCompatibilityWalSupported() \|\| (
		SQLiteCompatibilityWalFlags.areFlagsSet() && !SQLiteCompatibilityWalFlags
		.isCompatibilityWalSupported())) {
		mConfigurationLocked.openFlags \|= DISABLE_COMPATIBILITY_WAL;
		if (SQLiteCompatibilityWalFlags.isLegacyCompatibilityWalEnabled()) {
		mConfigurationLocked.openFlags \|= ENABLE_LEGACY_COMPATIBILITY_WAL;
		}
		}

		@@ -2123,15 +2126,18 @@ public final class SQLiteDatabase extends SQLiteClosable {
		throwIfNotOpenLocked();

		final int oldFlags = mConfigurationLocked.openFlags;
		final boolean walDisabled = (oldFlags & ENABLE_WRITE_AHEAD_LOGGING) == 0;
		final boolean compatibilityWalDisabled = (oldFlags & DISABLE_COMPATIBILITY_WAL) != 0;
		if (walDisabled && compatibilityWalDisabled) {
		final boolean walEnabled = (oldFlags & ENABLE_WRITE_AHEAD_LOGGING) != 0;
		final boolean compatibilityWalEnabled =
		(oldFlags & ENABLE_LEGACY_COMPATIBILITY_WAL) != 0;
		// WAL was never enabled for this database, so there's nothing left to do.
		if (!walEnabled && !compatibilityWalEnabled) {
		return;
		}

		// If an app explicitly disables WAL, it takes priority over any directive
		// to use the legacy "compatibility WAL" mode.
		mConfigurationLocked.openFlags &= ~ENABLE_WRITE_AHEAD_LOGGING;
		// If an app explicitly disables WAL, compatibility mode should be disabled too
		mConfigurationLocked.openFlags \|= DISABLE_COMPATIBILITY_WAL;
		mConfigurationLocked.openFlags &= ~ENABLE_LEGACY_COMPATIBILITY_WAL;

		try {
		mConnectionPoolLocked.reconfigure(mConfigurationLocked);