Merged in issue-90-shared-cache (pull request #10)

Issue 90 shared cache

Approved-by: Igor Sereda [ALM Works] <sereda@almworks.com>

Author: Jonathan Hamm

java/com/almworks/sqlite4java/SQLiteConnection.java

@@ -59,6 +59,11 @@ public final class SQLiteConnection {
    */
   private final File myFile;
 
+  /**
+   * Flag to preserve the cache shared mode when connection was created
+   */
+  private final boolean mySharedCacheMemoryConnection;
+
   /**
    * An incremental number of the instance, used for debugging purposes.
    */
@@ -168,15 +173,21 @@ public final class SQLiteConnection {
    */
   private int myOpenFlags;
 
+  private SQLiteConnection(File dbfile, boolean sharedCacheMemoryConnection) {
+    assert dbfile == null || !sharedCacheMemoryConnection : dbfile + " " + sharedCacheMemoryConnection;
+    myFile = dbfile;
+    mySharedCacheMemoryConnection = sharedCacheMemoryConnection;
+    Internal.logInfo(this, "instantiated [" + myFile + "]");
+  }
+
   /**
    * Creates a connection to the database located in the specified file.
    * Database is not opened by the constructor, and the calling thread is insignificant.
    *
    * @param dbfile database file, or null to create an in-memory database
    */
   public SQLiteConnection(File dbfile) {
-    myFile = dbfile;
-    Internal.logInfo(this, "instantiated [" + myFile + "]");
+    this(dbfile, false);
   }
 
   /**
@@ -186,7 +197,21 @@ public SQLiteConnection(File dbfile) {
    * @see #SQLiteConnection(java.io.File)
    */
   public SQLiteConnection() {
-    this(null);
+    this(null, false);
+  }
+
+  /**
+   * <p>Creates a connection to an in-memory temporary database, allowing the user to set the "shared cache" flag.
+   * All in-memory databases opened with {@code sharedCache} equal to {@code true} will share the same data.
+   * </p>
+   *
+   * <p>Database is not opened by the constructor, and the calling thread is insignificant.</p>
+   *
+   * @see #SQLiteConnection()
+   * @see <a href="https://www.sqlite.org/sharedcache.html">Shared Cache in SQLite</a>
+   */
+  public SQLiteConnection(boolean sharedCache) {
+    this(null, sharedCache);
   }
 
   /**
@@ -1586,7 +1611,14 @@ private void configureConnection(SWIGTYPE_p_sqlite3 handle) {
   }
 
   private String getSqliteDbName() {
-    return myFile == null ? ":memory:" : myFile.getAbsolutePath();
+    if (myFile == null) {
+      if (mySharedCacheMemoryConnection) {
+        return "file::memory:?cache=shared";
+      } else {
+        return ":memory:";
+      }
+    }
+    return myFile.getAbsolutePath();
   }
 
   int getStatementCount() {

test/com/almworks/sqlite4java/SQLiteConnectionTests.java

@@ -5,6 +5,9 @@
 import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import static com.almworks.sqlite4java.SQLiteConstants.SQLITE_OPEN_READWRITE;
+import static com.almworks.sqlite4java.SQLiteConstants.SQLITE_OPEN_URI;
+
 public class SQLiteConnectionTests extends SQLiteConnectionFixture {
   public void testOpenFile() throws SQLiteException {
     SQLiteConnection connection = fileDb();
@@ -211,6 +214,35 @@ public void testIsReadOnly() throws Exception {
     }
   }
 
+  public void testSharedCacheShouldPass() throws Exception {
+    SQLiteConnection connection1 = new SQLiteConnection(true);
+    connection1.openV2(SQLITE_OPEN_READWRITE | SQLITE_OPEN_URI);
+    connection1.exec("create table test(id varchar primary key, value varchar)");
+    connection1.exec("insert into test(id, value) values('id1', 'value')");
+    SQLiteConnection connection2 = new SQLiteConnection(true);
+    connection2.openV2(SQLITE_OPEN_READWRITE | SQLITE_OPEN_URI);
+    connection2.exec("select * from test");
+    connection1.dispose();
+    connection2.dispose();
+  }
+
+  public void testSharedCacheShouldFail() throws Exception {
+    try {
+      SQLiteConnection connection1 = new SQLiteConnection();
+      connection1.openV2(SQLITE_OPEN_READWRITE | SQLITE_OPEN_URI);
+      connection1.exec("create table test(id varchar primary key, value varchar)");
+      connection1.exec("insert into test(id, value) values('id1', 'value')");
+      SQLiteConnection connection2 = new SQLiteConnection();
+      connection2.openV2(SQLITE_OPEN_READWRITE | SQLITE_OPEN_URI);
+      connection2.exec("select * from test");
+      connection1.dispose();
+      connection2.dispose();
+      throw new Exception("should throw SQLiteException");
+    } catch (SQLiteException e) {
+      //norm
+    }
+  }
+
   /**
    * Test sqlite3_db_cacheflush(). This is an attempt to produce a state where the flush occurs
    * during a write-transaction with dirty pages and an exclusive lock. Producing this state