Merge with some older changes I made but forgot to push :(

Author: enebo

lib/arjdbc/abstract/database_statements.rb

@@ -87,11 +87,7 @@ def execute(sql, name = nil, async: false, allow_retry: false, materialize_trans
 
         mark_transaction_written_if_write(sql)
 
-        log(sql, name, async: async) do
-          with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
-            conn.execute(sql)
-          end
-        end
+        raw_execute(sql, name, async: async, allow_retry: allow_retry, materialize_transactions: materialize_transactions)
       end
 
       # overridden to support legacy binds
@@ -108,6 +104,16 @@ def convert_legacy_binds_to_attributes(binds)
         end
       end
 
+      def raw_execute(sql, name, async: false, allow_retry: false, materialize_transactions: false)
+        log(sql, name, async: async) do
+          with_raw_connection(allow_retry: allow_retry, materialize_transactions: materialize_transactions) do |conn|
+            # We sometimes return an ActiveRecord::Result and sometimes a raw, so force to raw
+            result = conn.execute(sql)
+            result.is_a?(ActiveRecord::Result) ? result.to_a : result
+          end
+        end
+      end
+
     end
   end
 end

lib/arjdbc/sqlite3/adapter.rb

@@ -90,38 +90,6 @@ def dealloc(stmt)
       end
     end
 
-    def initialize(...)
-      super
-
-      @memory_database = false
-      case @config[:database].to_s
-      when ""
-        raise ArgumentError, "No database file specified. Missing argument: database"
-      when ":memory:"
-        @memory_database = true
-      when /\Afile:/
-      else
-        # Otherwise we have a path relative to Rails.root
-        @config[:database] = File.expand_path(@config[:database], Rails.root) if defined?(Rails.root)
-        dirname = File.dirname(@config[:database])
-        unless File.directory?(dirname)
-          begin
-            Dir.mkdir(dirname)
-          rescue Errno::ENOENT => error
-            if error.message.include?("No such file or directory")
-              raise ActiveRecord::NoDatabaseError.new(connection_pool: @pool)
-            else
-              raise
-            end
-          end
-        end
-      end
-
-      @config[:strict] = ConnectionAdapters::SQLite3Adapter.strict_strings_by_default unless @config.key?(:strict)
-      @connection_parameters = @config.merge(database: @config[:database].to_s, results_as_hash: true)
-      @use_insert_returning = @config.key?(:insert_returning) ? self.class.type_cast_config_to_boolean(@config[:insert_returning]) : true
-    end
-
     def self.database_exists?(config)
       @config[:database] == ":memory:" || File.exist?(@config[:database].to_s)
     end
@@ -321,7 +289,7 @@ def change_column_default(table_name, column_name, default_or_changes) #:nodoc:
 
     def change_column_null(table_name, column_name, null, default = nil) #:nodoc:
       validate_change_column_null_argument!(null)
-      
+
       unless null || default.nil?
         internal_exec_query("UPDATE #{quote_table_name(table_name)} SET #{quote_column_name(column_name)}=#{quote(default)} WHERE #{quote_column_name(column_name)} IS NULL")
       end
@@ -635,6 +603,11 @@ def translate_exception(exception, message:, sql:, binds:)
       elsif exception.message.match?(/called on a closed database/i)
         # DIFFERENCE: FQN
         ::ActiveRecord::ConnectionNotEstablished.new(exception, connection_pool: @pool)
+      elsif exception.message.match?(/sql error/i)
+        ::ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
+      elsif exception.message.match?(/write a readonly database/i)
+        message = message.sub('org.sqlite.SQLiteException', 'SQLite3::ReadOnlyException')
+        ::ActiveRecord::StatementInvalid.new(message, sql: sql, binds: binds, connection_pool: @pool)
       else
         super
       end
@@ -710,6 +683,44 @@ def reconnect
       end
     end
 
+    def configure_connection
+      if @config[:timeout] && @config[:retries]
+        raise ArgumentError, "Cannot specify both timeout and retries arguments"
+      elsif @config[:timeout]
+        # FIXME: missing from adapter
+        # @raw_connection.busy_timeout(self.class.type_cast_config_to_integer(@config[:timeout]))
+      elsif @config[:retries]
+        retries = self.class.type_cast_config_to_integer(@config[:retries])
+        raw_connection.busy_handler do |count|
+          count <= retries
+        end
+      end
+
+      # Enforce foreign key constraints
+      # https://www.sqlite.org/pragma.html#pragma_foreign_keys
+      # https://www.sqlite.org/foreignkeys.html
+      raw_execute("PRAGMA foreign_keys = ON", "SCHEMA")
+      unless @memory_database
+        # Journal mode WAL allows for greater concurrency (many readers + one writer)
+        # https://www.sqlite.org/pragma.html#pragma_journal_mode
+        raw_execute("PRAGMA journal_mode = WAL", "SCHEMA")
+        # Set more relaxed level of database durability
+        # 2 = "FULL" (sync on every write), 1 = "NORMAL" (sync every 1000 written pages) and 0 = "NONE"
+        # https://www.sqlite.org/pragma.html#pragma_synchronous
+        raw_execute("PRAGMA synchronous = NORMAL", "SCHEMA")
+        # Set the global memory map so all processes can share some data
+        # https://www.sqlite.org/pragma.html#pragma_mmap_size
+        # https://www.sqlite.org/mmap.html
+        raw_execute("PRAGMA mmap_size = #{128.megabytes}", "SCHEMA")
+      end
+      # Impose a limit on the WAL file to prevent unlimited growth
+      # https://www.sqlite.org/pragma.html#pragma_journal_size_limit
+      raw_execute("PRAGMA journal_size_limit = #{64.megabytes}", "SCHEMA")
+      # Set the local connection cache to 2000 pages
+      # https://www.sqlite.org/pragma.html#pragma_cache_size
+      raw_execute("PRAGMA cache_size = 2000", "SCHEMA")
+    end
+
     def configure_connection
       if @config[:timeout] && @config[:retries]
         raise ArgumentError, "Cannot specify both timeout and retries arguments"
@@ -775,9 +786,7 @@ class SQLite3Adapter < AbstractAdapter
     # If you wish to enable this mode you can add the following line to your application.rb file:
     #
     #   config.active_record.sqlite3_adapter_strict_strings_by_default = true
-    class_attribute :strict_strings_by_default, default: false
-
-
+    class_attribute :strict_strings_by_default, default: false # Does not actually do anything right now
 
     def self.represent_boolean_as_integer=(value) # :nodoc:
       if value == false