feat: do not create temporary file before opening connection

prior behaviour was to temporarily create a non-existing db-file to test for write-permission
removed such test, and rely on the native code to throw an error if permissions are insufficient

Closes: xerial#1260

Author: hofmandl1

src/main/java/org/sqlite/SQLiteConnection.java

@@ -251,26 +251,7 @@ private static DB open(String url, String origFileName, Properties props) throws
                     throw new SQLException(String.format("failed to load %s: %s", resourceName, e));
                 }
             } else {
-                File file = new File(fileName).getAbsoluteFile();
-                File parent = file.getParentFile();
-                if (parent != null && !parent.exists()) {
-                    for (File up = parent; up != null && !up.exists(); ) {
-                        parent = up;
-                        up = up.getParentFile();
-                    }
-                    throw new SQLException(
-                            "path to '" + fileName + "': '" + parent + "' does not exist");
-                }
-
-                // check write access if file does not exist
-                try {
-                    // The extra check to exists() is necessary as createNewFile()
-                    // does not follow the JavaDoc when used on read-only shares.
-                    if (!file.exists() && file.createNewFile()) file.delete();
-                } catch (Exception e) {
-                    throw new SQLException("opening db: '" + fileName + "': " + e.getMessage());
-                }
-                fileName = file.getAbsolutePath();
+                fileName = new File(fileName).getAbsolutePath();
             }
         }
 

src/test/java/org/sqlite/ConnectionTest.java

@@ -6,6 +6,10 @@
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
+import java.nio.file.AccessDeniedException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.sql.*;
 import java.util.ArrayList;
 import java.util.Properties;
@@ -14,6 +18,8 @@
 import java.util.concurrent.Executors;
 import java.util.concurrent.Future;
 import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.condition.DisabledOnOs;
+import org.junit.jupiter.api.condition.OS;
 import org.junit.jupiter.api.io.TempDir;
 import org.sqlite.SQLiteConfig.JournalMode;
 import org.sqlite.SQLiteConfig.Pragma;
@@ -409,4 +415,49 @@ public void overrideURIPragmaValuesWithProperties() throws Exception {
         stat.close();
         conn.close();
     }
+
+    @Test
+    public void openNonExistingFileNoCreate() {
+        Path nonExisting = Paths.get("non_existing.db").toAbsolutePath();
+        assertThat(Files.exists(nonExisting)).isFalse();
+        SQLiteConfig cfg = new SQLiteConfig();
+        cfg.resetOpenMode(SQLiteOpenMode.CREATE);
+        assertThatExceptionOfType(SQLiteException.class)
+                .isThrownBy(
+                        () -> {
+                            @SuppressWarnings({"resource", "unused"})
+                            Connection _c = cfg.createConnection("jdbc:sqlite:" + nonExisting);
+                        })
+                .satisfies(
+                        e ->
+                                assertThat(e.getResultCode())
+                                        .isEqualTo(SQLiteErrorCode.SQLITE_CANTOPEN));
+        assertThat(Files.exists(nonExisting)).isFalse();
+    }
+
+    @DisabledOnOs(OS.WINDOWS) // File.setReadOnly doesn't seem to work here
+    @Test
+    public void openNonExistingFileInReadOnlyDirectory(@TempDir Path tmpDir) {
+        assertThat(tmpDir.toFile().setReadOnly()).isTrue();
+        assertThat(Files.exists(tmpDir)).isTrue();
+        Path nonExisting = tmpDir.resolve("non_existing.db").toAbsolutePath();
+        assertThatThrownBy(() -> Files.createFile(nonExisting))
+                .isInstanceOf(AccessDeniedException.class);
+        assertThat(Files.exists(nonExisting)).isFalse();
+        SQLiteConfig cfg = new SQLiteConfig();
+        assertThatExceptionOfType(SQLiteException.class)
+                .isThrownBy(
+                        () -> {
+                            @SuppressWarnings({"resource", "unused"})
+                            Connection _c = cfg.createConnection("jdbc:sqlite:" + nonExisting);
+                        })
+                .satisfies(
+                        e ->
+                                // It would be nice, if the native error code were more specific on
+                                // why the file can't be
+                                // opened, but this is what we get:
+                                assertThat(e.getResultCode())
+                                        .isEqualTo(SQLiteErrorCode.SQLITE_CANTOPEN));
+        assertThat(Files.exists(nonExisting)).isFalse();
+    }
 }