activerecord 7.1.0.beta1 → 7.1.0.rc1

data/lib/active_record/connection_adapters/abstract/transaction.rb

@@ -78,21 +78,24 @@ module ActiveRecord
       def initialize(payload = {})
         @handle = nil
         @started = false
-        @payload = payload
+        @payload = nil
+        @base_payload = payload
       end
 
       def start
         return if @started
         @started = true
 
+        @payload = @base_payload.dup
         @handle = ActiveSupport::Notifications.instrumenter.build_handle("transaction.active_record", @payload)
         @handle.start
       end
 
-      def finish
+      def finish(outcome)
         return unless @started
         @started = false
 
+        @payload[:outcome] = outcome
         @handle.finish
       end
     end
@@ -163,7 +166,7 @@ module ActiveRecord
       end
 
       def incomplete!
-        @instrumenter.finish
+        @instrumenter.finish(:incomplete)
       end
 
       def materialize!
@@ -334,7 +337,7 @@ module ActiveRecord
       def restart
         return unless materialized?
 
-        @instrumenter.finish
+        @instrumenter.finish(:restart)
         @instrumenter.start
 
         connection.rollback_to_savepoint(savepoint_name)
@@ -345,13 +348,13 @@ module ActiveRecord
           connection.rollback_to_savepoint(savepoint_name) if materialized?
         end
         @state.rollback!
-        @instrumenter.finish
+        @instrumenter.finish(:rollback)
       end
 
       def commit
         connection.release_savepoint(savepoint_name) if materialized?
         @state.commit!
-        @instrumenter.finish
+        @instrumenter.finish(:commit)
       end
 
       def full_rollback?; false; end
@@ -372,7 +375,7 @@ module ActiveRecord
       def restart
         return unless materialized?
 
-        @instrumenter.finish
+        @instrumenter.finish(:restart)
 
         if connection.supports_restart_db_transaction?
           @instrumenter.start
@@ -386,13 +389,13 @@ module ActiveRecord
       def rollback
         connection.rollback_db_transaction if materialized?
         @state.full_rollback!
-        @instrumenter.finish
+        @instrumenter.finish(:rollback)
       end
 
       def commit
         connection.commit_db_transaction if materialized?
         @state.full_commit!
-        @instrumenter.finish
+        @instrumenter.finish(:commit)
       end
     end
 

data/lib/active_record/connection_adapters/abstract_adapter.rb

@@ -498,7 +498,7 @@ module ActiveRecord
       end
 
       # Does this adapter support creating unique constraints?
-      def supports_unique_keys?
+      def supports_unique_constraints?
         false
       end
 

data/lib/active_record/connection_adapters/abstract_mysql_adapter.rb

@@ -531,6 +531,13 @@ module ActiveRecord
             expression = row["expression"]
             expression = expression[1..-2] if expression.start_with?("(") && expression.end_with?(")")
             expression = strip_whitespace_characters(expression)
+
+            unless mariadb?
+              # MySQL returns check constraints expression in an already escaped form.
+              # This leads to duplicate escaping later (e.g. when the expression is used in the SchemaDumper).
+              expression = expression.gsub("\\'", "'")
+            end
+
             CheckConstraintDefinition.new(table_name, expression, options)
           end
         else

data/lib/active_record/connection_adapters/mysql/schema_statements.rb

@@ -36,7 +36,7 @@ module ActiveRecord
               end
 
               if row[:Expression]
-                expression = row[:Expression]
+                expression = row[:Expression].gsub("\\'", "'")
                 expression = +"(#{expression})" unless expression.start_with?("(")
                 indexes.last[-2] << expression
                 indexes.last[-1][:expressions] ||= {}

data/lib/active_record/connection_adapters/pool_manager.rb

@@ -8,7 +8,7 @@ module ActiveRecord
       end
 
       def shard_names
-        @role_to_shard_mapping.values.flat_map { |shard_map| shard_map.keys }
+        @role_to_shard_mapping.values.flat_map { |shard_map| shard_map.keys }.uniq
       end
 
       def role_names

data/lib/active_record/connection_adapters/postgresql/database_statements.rb

@@ -75,22 +75,6 @@ module ActiveRecord
         end
         alias :exec_update :exec_delete
 
-        def sql_for_insert(sql, pk, binds, returning) # :nodoc:
-          if pk.nil?
-            # Extract the table from the insert sql. Yuck.
-            table_ref = extract_table_ref_from_insert_sql(sql)
-            pk = primary_key(table_ref) if table_ref
-          end
-
-          returning_columns = returning || Array(pk)
-
-          returning_columns_statement = returning_columns.map { |c| quote_column_name(c) }.join(", ")
-          sql = "#{sql} RETURNING #{returning_columns_statement}" if returning_columns.any?
-
-          super
-        end
-        private :sql_for_insert
-
         def exec_insert(sql, name = nil, binds = [], pk = nil, sequence_name = nil, returning: nil) # :nodoc:
           if use_insert_returning? || pk == false
             super

data/lib/active_record/connection_adapters/postgresql/schema_creation.rb

@@ -12,8 +12,8 @@ module ActiveRecord
             sql << o.constraint_validations.map { |fk| visit_ValidateConstraint fk }.join(" ")
             sql << o.exclusion_constraint_adds.map { |con| visit_AddExclusionConstraint con }.join(" ")
             sql << o.exclusion_constraint_drops.map { |con| visit_DropExclusionConstraint con }.join(" ")
-            sql << o.unique_key_adds.map { |con| visit_AddUniqueKey con }.join(" ")
-            sql << o.unique_key_drops.map { |con| visit_DropUniqueKey con }.join(" ")
+            sql << o.unique_constraint_adds.map { |con| visit_AddUniqueConstraint con }.join(" ")
+            sql << o.unique_constraint_drops.map { |con| visit_DropUniqueConstraint con }.join(" ")
           end
 
           def visit_AddForeignKey(o)
@@ -49,7 +49,7 @@ module ActiveRecord
             sql.join(" ")
           end
 
-          def visit_UniqueKeyDefinition(o)
+          def visit_UniqueConstraintDefinition(o)
             column_name = Array(o.column).map { |column| quote_column_name(column) }.join(", ")
 
             sql = ["CONSTRAINT"]
@@ -77,11 +77,11 @@ module ActiveRecord
             "DROP CONSTRAINT #{quote_column_name(name)}"
           end
 
-          def visit_AddUniqueKey(o)
+          def visit_AddUniqueConstraint(o)
             "ADD #{accept(o)}"
           end
 
-          def visit_DropUniqueKey(name)
+          def visit_DropUniqueConstraint(name)
             "DROP CONSTRAINT #{quote_column_name(name)}"
           end
 

data/lib/active_record/connection_adapters/postgresql/schema_definitions.rb

@@ -211,7 +211,7 @@ module ActiveRecord
         end
       end
 
-      UniqueKeyDefinition = Struct.new(:table_name, :column, :options) do
+      UniqueConstraintDefinition = Struct.new(:table_name, :column, :options) do
         def name
           options[:name]
         end
@@ -239,12 +239,12 @@ module ActiveRecord
       class TableDefinition < ActiveRecord::ConnectionAdapters::TableDefinition
         include ColumnMethods
 
-        attr_reader :exclusion_constraints, :unique_keys, :unlogged
+        attr_reader :exclusion_constraints, :unique_constraints, :unlogged
 
         def initialize(*, **)
           super
           @exclusion_constraints = []
-          @unique_keys = []
+          @unique_constraints = []
           @unlogged = ActiveRecord::ConnectionAdapters::PostgreSQLAdapter.create_unlogged_tables
         end
 
@@ -252,8 +252,8 @@ module ActiveRecord
           exclusion_constraints << new_exclusion_constraint_definition(expression, options)
         end
 
-        def unique_key(column_name, **options)
-          unique_keys << new_unique_key_definition(column_name, options)
+        def unique_constraint(column_name, **options)
+          unique_constraints << new_unique_constraint_definition(column_name, options)
         end
 
         def new_exclusion_constraint_definition(expression, options) # :nodoc:
@@ -261,9 +261,9 @@ module ActiveRecord
           ExclusionConstraintDefinition.new(name, expression, options)
         end
 
-        def new_unique_key_definition(column_name, options) # :nodoc:
-          options = @conn.unique_key_options(name, column_name, options)
-          UniqueKeyDefinition.new(name, column_name, options)
+        def new_unique_constraint_definition(column_name, options) # :nodoc:
+          options = @conn.unique_constraint_options(name, column_name, options)
+          UniqueConstraintDefinition.new(name, column_name, options)
         end
 
         def new_column_definition(name, type, **options) # :nodoc:
@@ -315,36 +315,36 @@ module ActiveRecord
           @base.remove_exclusion_constraint(name, *args)
         end
 
-        # Adds an unique constraint.
+        # Adds a unique constraint.
         #
-        #  t.unique_key(:position, name: 'unique_position', deferrable: :deferred)
+        #  t.unique_constraint(:position, name: 'unique_position', deferrable: :deferred)
         #
-        # See {connection.add_unique_key}[rdoc-ref:SchemaStatements#add_unique_key]
-        def unique_key(*args)
-          @base.add_unique_key(name, *args)
+        # See {connection.add_unique_constraint}[rdoc-ref:SchemaStatements#add_unique_constraint]
+        def unique_constraint(*args)
+          @base.add_unique_constraint(name, *args)
         end
 
         # Removes the given unique constraint from the table.
         #
-        #  t.remove_unique_key(name: "unique_position")
+        #  t.remove_unique_constraint(name: "unique_position")
         #
-        # See {connection.remove_unique_key}[rdoc-ref:SchemaStatements#remove_unique_key]
-        def remove_unique_key(*args)
-          @base.remove_unique_key(name, *args)
+        # See {connection.remove_unique_constraint}[rdoc-ref:SchemaStatements#remove_unique_constraint]
+        def remove_unique_constraint(*args)
+          @base.remove_unique_constraint(name, *args)
         end
       end
 
       # = Active Record PostgreSQL Adapter Alter \Table
       class AlterTable < ActiveRecord::ConnectionAdapters::AlterTable
-        attr_reader :constraint_validations, :exclusion_constraint_adds, :exclusion_constraint_drops, :unique_key_adds, :unique_key_drops
+        attr_reader :constraint_validations, :exclusion_constraint_adds, :exclusion_constraint_drops, :unique_constraint_adds, :unique_constraint_drops
 
         def initialize(td)
           super
           @constraint_validations = []
           @exclusion_constraint_adds = []
           @exclusion_constraint_drops = []
-          @unique_key_adds = []
-          @unique_key_drops = []
+          @unique_constraint_adds = []
+          @unique_constraint_drops = []
         end
 
         def validate_constraint(name)
@@ -359,12 +359,12 @@ module ActiveRecord
           @exclusion_constraint_drops << constraint_name
         end
 
-        def add_unique_key(column_name, options)
-          @unique_key_adds << @td.new_unique_key_definition(column_name, options)
+        def add_unique_constraint(column_name, options)
+          @unique_constraint_adds << @td.new_unique_constraint_definition(column_name, options)
         end
 
-        def drop_unique_key(unique_key_name)
-          @unique_key_drops << unique_key_name
+        def drop_unique_constraint(unique_constraint_name)
+          @unique_constraint_drops << unique_constraint_name
         end
       end
     end

data/lib/active_record/connection_adapters/postgresql/schema_dumper.rb

@@ -28,6 +28,17 @@ module ActiveRecord
             end
           end
 
+          def schemas(stream)
+            schema_names = @connection.schema_names - ["public"]
+
+            if schema_names.any?
+              schema_names.sort.each do |name|
+                stream.puts "  create_schema #{name.inspect}"
+              end
+              stream.puts
+            end
+          end
+
           def exclusion_constraints_in_create(table, stream)
             if (exclusion_constraints = @connection.exclusion_constraints(table)).any?
               add_exclusion_constraint_statements = exclusion_constraints.map do |exclusion_constraint|
@@ -50,23 +61,23 @@ module ActiveRecord
             end
           end
 
-          def unique_keys_in_create(table, stream)
-            if (unique_keys = @connection.unique_keys(table)).any?
-              add_unique_key_statements = unique_keys.map do |unique_key|
+          def unique_constraints_in_create(table, stream)
+            if (unique_constraints = @connection.unique_constraints(table)).any?
+              add_unique_constraint_statements = unique_constraints.map do |unique_constraint|
                 parts = [
-                  "t.unique_key #{unique_key.column.inspect}"
+                  "t.unique_constraint #{unique_constraint.column.inspect}"
                 ]
 
-                parts << "deferrable: #{unique_key.deferrable.inspect}" if unique_key.deferrable
+                parts << "deferrable: #{unique_constraint.deferrable.inspect}" if unique_constraint.deferrable
 
-                if unique_key.export_name_on_schema_dump?
-                  parts << "name: #{unique_key.name.inspect}"
+                if unique_constraint.export_name_on_schema_dump?
+                  parts << "name: #{unique_constraint.name.inspect}"
                 end
 
                 "    #{parts.join(', ')}"
               end
 
-              stream.puts add_unique_key_statements.sort.join("\n")
+              stream.puts add_unique_constraint_statements.sort.join("\n")
             end
           end
 

data/lib/active_record/connection_adapters/postgresql/schema_statements.rb

@@ -640,12 +640,12 @@ module ActiveRecord
         end
 
         # Returns an array of unique constraints for the given table.
-        # The unique constraints are represented as UniqueKeyDefinition objects.
-        def unique_keys(table_name)
+        # The unique constraints are represented as UniqueConstraintDefinition objects.
+        def unique_constraints(table_name)
           scope = quoted_scope(table_name)
 
           unique_info = internal_exec_query(<<~SQL, "SCHEMA", allow_retry: true, materialize_transactions: false)
-            SELECT c.conname, c.conindid, c.condeferrable, c.condeferred
+            SELECT c.conname, c.conrelid, c.conkey, c.condeferrable, c.condeferred
             FROM pg_constraint c
             JOIN pg_class t ON c.conrelid = t.oid
             JOIN pg_namespace n ON n.oid = c.connamespace
@@ -655,21 +655,17 @@ module ActiveRecord
           SQL
 
           unique_info.map do |row|
-            deferrable = extract_constraint_deferrable(row["condeferrable"], row["condeferred"])
+            conkey = row["conkey"].delete("{}").split(",").map(&:to_i)
+            columns = column_names_from_column_numbers(row["conrelid"], conkey)
 
-            columns = query_values(<<~SQL, "SCHEMA")
-              SELECT a.attname
-              FROM pg_attribute a
-              WHERE a.attrelid = #{row['conindid']}
-              ORDER BY a.attnum
-            SQL
+            deferrable = extract_constraint_deferrable(row["condeferrable"], row["condeferred"])
 
             options = {
               name: row["conname"],
               deferrable: deferrable
             }
 
-            UniqueKeyDefinition.new(table_name, columns, options)
+            UniqueConstraintDefinition.new(table_name, columns, options)
           end
         end
 
@@ -721,7 +717,7 @@ module ActiveRecord
 
         # Adds a new unique constraint to the table.
         #
-        #   add_unique_key :sections, [:position], deferrable: :deferred, name: "unique_position"
+        #   add_unique_constraint :sections, [:position], deferrable: :deferred, name: "unique_position"
         #
         # generates:
         #
@@ -729,7 +725,7 @@ module ActiveRecord
         #
         # If you want to change an existing unique index to deferrable, you can use :using_index to create deferrable unique constraints.
         #
-        #   add_unique_key :sections, deferrable: :deferred, name: "unique_position", using_index: "index_sections_on_position"
+        #   add_unique_constraint :sections, deferrable: :deferred, name: "unique_position", using_index: "index_sections_on_position"
         #
         # The +options+ hash can include the following keys:
         # [<tt>:name</tt>]
@@ -738,15 +734,15 @@ module ActiveRecord
         #   Specify whether or not the unique constraint should be deferrable. Valid values are +false+ or +:immediate+ or +:deferred+ to specify the default behavior. Defaults to +false+.
         # [<tt>:using_index</tt>]
         #   To specify an existing unique index name. Defaults to +nil+.
-        def add_unique_key(table_name, column_name = nil, **options)
-          options = unique_key_options(table_name, column_name, options)
+        def add_unique_constraint(table_name, column_name = nil, **options)
+          options = unique_constraint_options(table_name, column_name, options)
           at = create_alter_table(table_name)
-          at.add_unique_key(column_name, options)
+          at.add_unique_constraint(column_name, options)
 
           execute schema_creation.accept(at)
         end
 
-        def unique_key_options(table_name, column_name, options) # :nodoc:
+        def unique_constraint_options(table_name, column_name, options) # :nodoc:
           assert_valid_deferrable(options[:deferrable])
 
           if column_name && options[:using_index]
@@ -754,22 +750,22 @@ module ActiveRecord
           end
 
           options = options.dup
-          options[:name] ||= unique_key_name(table_name, column: column_name, **options)
+          options[:name] ||= unique_constraint_name(table_name, column: column_name, **options)
           options
         end
 
         # Removes the given unique constraint from the table.
         #
-        #   remove_unique_key :sections, name: "unique_position"
+        #   remove_unique_constraint :sections, name: "unique_position"
         #
         # The +column_name+ parameter will be ignored if present. It can be helpful
         # to provide this in a migration's +change+ method so it can be reverted.
-        # In that case, +column_name+ will be used by #add_unique_key.
-        def remove_unique_key(table_name, column_name = nil, **options)
-          unique_name_to_delete = unique_key_for!(table_name, column: column_name, **options).name
+        # In that case, +column_name+ will be used by #add_unique_constraint.
+        def remove_unique_constraint(table_name, column_name = nil, **options)
+          unique_name_to_delete = unique_constraint_for!(table_name, column: column_name, **options).name
 
           at = create_alter_table(table_name)
-          at.drop_unique_key(unique_name_to_delete)
+          at.drop_unique_constraint(unique_name_to_delete)
 
           execute schema_creation.accept(at)
         end
@@ -1042,7 +1038,7 @@ module ActiveRecord
               raise(ArgumentError, "Table '#{table_name}' has no exclusion constraint for #{expression || options}")
           end
 
-          def unique_key_name(table_name, **options)
+          def unique_constraint_name(table_name, **options)
             options.fetch(:name) do
               column_or_index = Array(options[:column] || options[:using_index]).map(&:to_s)
               identifier = "#{table_name}_#{column_or_index * '_and_'}_unique"
@@ -1052,13 +1048,13 @@ module ActiveRecord
             end
           end
 
-          def unique_key_for(table_name, **options)
-            name = unique_key_name(table_name, **options) unless options.key?(:column)
-            unique_keys(table_name).detect { |unique_key| unique_key.defined_for?(name: name, **options) }
+          def unique_constraint_for(table_name, **options)
+            name = unique_constraint_name(table_name, **options) unless options.key?(:column)
+            unique_constraints(table_name).detect { |unique_constraint| unique_constraint.defined_for?(name: name, **options) }
           end
 
-          def unique_key_for!(table_name, column: nil, **options)
-            unique_key_for(table_name, column: column, **options) ||
+          def unique_constraint_for!(table_name, column: nil, **options)
+            unique_constraint_for(table_name, column: column, **options) ||
               raise(ArgumentError, "Table '#{table_name}' has no unique constraint for #{column || options}")
           end
 

data/lib/active_record/connection_adapters/postgresql_adapter.rb

@@ -226,7 +226,7 @@ module ActiveRecord
         true
       end
 
-      def supports_unique_keys?
+      def supports_unique_constraints?
         true
       end
 
@@ -1089,11 +1089,6 @@ module ActiveRecord
           SQL
         end
 
-        def extract_table_ref_from_insert_sql(sql)
-          sql[/into\s("[A-Za-z0-9_."\[\]\s]+"|[A-Za-z0-9_."\[\]]+)\s*/im]
-          $1.strip if $1
-        end
-
         def arel_visitor
           Arel::Visitors::PostgreSQL.new(self)
         end

data/lib/active_record/connection_adapters/sqlite3/database_statements.rb

@@ -138,10 +138,6 @@ module ActiveRecord
             end
           end
 
-          def last_inserted_id(result)
-            @raw_connection.last_insert_row_id
-          end
-
           def build_fixture_statements(fixture_set)
             fixture_set.flat_map do |table_name, fixtures|
               next if fixtures.empty?
@@ -152,6 +148,10 @@ module ActiveRecord
           def build_truncate_statement(table_name)
             "DELETE FROM #{quote_table_name(table_name)}"
           end
+
+          def returning_column_values(result)
+            result.rows.first
+          end
       end
     end
   end

data/lib/active_record/connection_adapters/sqlite3_adapter.rb

@@ -126,6 +126,7 @@ module ActiveRecord
 
         @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 database_exists?
@@ -180,6 +181,10 @@ module ActiveRecord
         database_version >= "3.8.3"
       end
 
+      def supports_insert_returning?
+        database_version >= "3.35.0"
+      end
+
       def supports_insert_on_conflict?
         database_version >= "3.24.0"
       end
@@ -195,6 +200,10 @@ module ActiveRecord
         @raw_connection && !@raw_connection.closed?
       end
 
+      def return_value_after_insert?(column) # :nodoc:
+        column.auto_populated?
+      end
+
       alias :reset! :reconnect!
 
       # Disconnects from the database if already connected. Otherwise, this
@@ -393,6 +402,7 @@ module ActiveRecord
           end
         end
 
+        sql << " RETURNING #{insert.returning}" if insert.returning
         sql
       end
 
@@ -400,6 +410,10 @@ module ActiveRecord
         @config.fetch(:flags, 0).anybits?(::SQLite3::Constants::Open::SHAREDCACHE)
       end
 
+      def use_insert_returning?
+        @use_insert_returning
+      end
+
       def get_database_version # :nodoc:
         SQLite3Adapter::Version.new(query_value("SELECT sqlite_version(*)", "SCHEMA"))
       end
@@ -451,10 +465,10 @@ module ActiveRecord
           when /^null$/i
             nil
           # Quoted types
-          when /^'(.*)'$/m
+          when /^'([^|]*)'$/m
             $1.gsub("''", "'")
           # Quoted types
-          when /^"(.*)"$/m
+          when /^"([^|]*)"$/m
             $1.gsub('""', '"')
           # Numeric types
           when /\A-?\d+(\.\d*)?\z/
@@ -474,7 +488,7 @@ module ActiveRecord
         end
 
         def has_default_function?(default_value, default)
-          !default_value && %r{\w+\(.*\)|CURRENT_TIME|CURRENT_DATE|CURRENT_TIMESTAMP}.match?(default)
+          !default_value && %r{\w+\(.*\)|CURRENT_TIME|CURRENT_DATE|CURRENT_TIMESTAMP|\|\|}.match?(default)
         end
 
         # See: https://www.sqlite.org/lang_altertable.html
@@ -698,9 +712,40 @@ module ActiveRecord
         end
 
         def configure_connection
-          @raw_connection.busy_timeout(self.class.type_cast_config_to_integer(@config[:timeout])) if @config[:timeout]
+          if @config[:timeout] && @config[:retries]
+            raise ArgumentError, "Cannot specify both timeout and retries arguments"
+          elsif @config[:timeout]
+            @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
     end
     ActiveSupport.run_load_hooks(:active_record_sqlite3adapter, SQLite3Adapter)