pact_broker 2.119.0 → 2.121.0

data/lib/pact_broker/api/resources/pacticipants_for_label.rb

@@ -1,10 +1,12 @@
 require "pact_broker/api/resources/base_resource"
 require "pact_broker/api/decorators/pacticipants_decorator"
+require "pact_broker/api/resources/pagination_methods"
 
 module PactBroker
   module Api
     module Resources
       class PacticipantsForLabel < BaseResource
+        include PaginationMethods
 
         def content_types_provided
           [["application/hal+json", :to_json]]
@@ -14,8 +16,18 @@ module PactBroker
           ["GET", "OPTIONS"]
         end
 
+        def malformed_request?
+          if super
+            true
+          elsif request.get? && validation_errors_for_schema?(schema, request.query)
+            true
+          else
+            false
+          end
+        end
+
         def to_json
-          generate_json(pacticipant_service.find identifier_from_path )
+          generate_json(pacticipant_service.find_all_pacticipants(filter_options, pagination_options, eager_load_associations))
         end
 
         def generate_json pacticipants
@@ -25,6 +37,22 @@ module PactBroker
         def policy_name
           :'pacticipants::pacticipants'
         end
+
+        private
+
+        def schema
+          PactBroker::Api::Contracts::PaginationQueryParamsSchema
+        end
+
+        def eager_load_associations
+          decorator_class(:pacticipants_decorator).eager_load_associations
+        end
+
+        def filter_options
+          options = { label_name: identifier_from_path[:label_name] }
+          options[:query_string] = request.query["q"] if request.query.has_key?("q")
+          options
+        end
       end
     end
   end

data/lib/pact_broker/api/resources/tag_versions.rb

@@ -30,7 +30,7 @@ module PactBroker
 
         def to_json
           decorator_class(:versions_decorator).new(tag_versions)
-            .to_json(**decorator_options(deployed_versions: deployed_versions))
+            .to_json(**decorator_options(identifier_from_path.merge(deployed_versions: deployed_versions, released_versions: released_versions)))
         end
 
         private
@@ -39,6 +39,10 @@ module PactBroker
           @deployed_versions ||= deployed_version_service.find_deployed_versions_for_versions(tag_versions)
         end
 
+        def released_versions
+          @released_versions ||= released_version_service.find_released_versions_for_versions(tag_versions)
+        end
+
         def tag_versions
           @versions ||= version_service.find_by_ids_in_reverse_order(@tags.select_map(:version_id), pagination_options, decorator_class(:versions_decorator).eager_load_associations)
         end

data/lib/pact_broker/api/resources/version.rb

@@ -54,7 +54,7 @@ module PactBroker
         end
 
         def to_json
-          decorator_class(:version_decorator).new(version).to_json(**decorator_options(environments: environments, deployed_versions: deployed_versions))
+          decorator_class(:version_decorator).new(version).to_json(**decorator_options(environments: environments, deployed_versions: deployed_versions, released_versions: released_versions))
         end
 
         def delete_resource
@@ -87,6 +87,10 @@ module PactBroker
           @deployed_versions ||= deployed_version_service.find_deployed_versions_for_version(version)
         end
 
+        def released_versions
+          @released_versions ||= released_version_service.find_released_versions_for_version(version)
+        end
+
         def version
           @version ||= version_service.find_by_pacticipant_name_and_number(identifier_from_path)
         end

data/lib/pact_broker/api/resources/versions.rb

@@ -27,7 +27,7 @@ module PactBroker
         end
 
         def to_json
-          decorator_class(:versions_decorator).new(versions).to_json(**decorator_options(identifier_from_path.merge(deployed_versions: deployed_versions)))
+          decorator_class(:versions_decorator).new(versions).to_json(**decorator_options(identifier_from_path.merge(deployed_versions: deployed_versions, released_versions: released_versions)))
         end
 
         def versions
@@ -38,6 +38,10 @@ module PactBroker
           @deployed_versions ||= deployed_version_service.find_deployed_versions_for_versions(versions)
         end
 
+        def released_versions
+          @released_versions ||= released_version_service.find_released_versions_for_versions(versions)
+        end
+
         def policy_name
           :'versions::versions'
         end

data/lib/pact_broker/api.rb

@@ -104,7 +104,9 @@ module PactBroker
 
         # Versions
         add ["pacticipants", :pacticipant_name, "versions"], Api::Resources::Versions, {resource_name: "pacticipant_versions"}
+        add ["pacticipants", :pacticipant_name, "deployed-or-released", "versions"], Api::Resources::DeployedOrReleasedVersions, {resource_name: "pacticipant_deployed_or_released_versions"}
         add ["pacticipants", :pacticipant_name, "branches", :branch_name, "versions"], Api::Resources::BranchVersions, {resource_name: "pacticipant_branch_versions"}
+        add ["pacticipants", :pacticipant_name, "environments", :environment_uuid, "versions"], Api::Resources::EnvironmentVersions, {resource_name: "pacticipant_environment_versions"}
         add ["pacticipants", :pacticipant_name, "versions", :pacticipant_version_number], Api::Resources::Version, {resource_name: "pacticipant_version"}
         add ["pacticipants", :pacticipant_name, "latest-version", :tag], Api::Resources::LatestVersion, {resource_name: "latest_tagged_pacticipant_version"}
         add ["pacticipants", :pacticipant_name, "latest-version", :tag, "can-i-deploy", "to", :to], Api::Resources::CanIDeployPacticipantVersionByTagToTag, { resource_name: "can_i_deploy_latest_tagged_version_to_tag" }

data/lib/pact_broker/app.rb

@@ -148,7 +148,6 @@ module PactBroker
       configuration.database_connection ||= PactBroker.create_database_connection(configuration.database_configuration, configuration.logger)
       PactBroker::DB.connection = configuration.database_connection
       PactBroker::DB.validate_connection_config if configuration.validate_database_connection_config
-      PactBroker::DB.set_mysql_strict_mode_if_mysql
       PactBroker::DB.connection.extension(:pagination)
       PactBroker::DB.connection.extension(:statement_timeout)
       PactBroker::DB.connection.extension(:any_not_empty)

data/lib/pact_broker/config/runtime_configuration.rb

@@ -40,6 +40,7 @@ module PactBroker
         log_stream: :file,
         log_level: :info,
         log_format: nil,
+        log_otel_enabled: :auto,
         warning_error_class_names: ["Sequel::ForeignKeyConstraintViolation"],
         hide_pactflow_messages: false,
         log_configuration_on_startup: true,
@@ -129,6 +130,10 @@ module PactBroker
         super(log_format&.to_sym)
       end
 
+      def log_otel_enabled= value
+        super(coerce_log_otel_enabled(value))
+      end
+
       def custom_log_formatters= custom_log_formatters
         super(custom_log_formatters&.symbolize_keys)
       end
@@ -215,12 +220,26 @@ module PactBroker
         if log_stream == :file && log_dir.blank?
           raise_validation_error("Must specify log_dir if log_stream is set to file")
         end
+
+        unless [:auto, true, false].include?(log_otel_enabled)
+          raise_validation_error("log_otel_enabled must be one of: auto, true, false")
+        end
       end
 
       def raise_validation_error(msg)
         raise PactBroker::ConfigurationError, msg
       end
 
+      def coerce_log_otel_enabled(value)
+        case value
+        when nil, "", "auto", :auto then :auto
+        when true, "true", "1", 1 then true
+        when false, "false", "0", 0 then false
+        else value
+        end
+      end
+      private :coerce_log_otel_enabled
+
       def set_webhook_attribute_defaults
         # can't set a default on this, or anyway config blows up when trying to merge the
         # hash from the env vars into an array/nil.

data/lib/pact_broker/configuration.rb

@@ -3,6 +3,8 @@ require "pact_broker/error"
 require "semantic_logger"
 require "forwardable"
 require "pact_broker/config/runtime_configuration"
+require "pact_broker/logging/open_telemetry_appender_setup"
+require "pact_broker/logging/trace_aware_json_formatter"
 require "anyway/auto_cast"
 require "request_store"
 
@@ -98,17 +100,28 @@ module PactBroker
     def logger_from_runtime_configuration
       @logger_from_runtime_configuration ||= begin
         SemanticLogger.default_level = runtime_configuration.log_level
+        formatter = resolve_log_formatter(runtime_configuration.log_format)
         if runtime_configuration.log_stream == :file
           path = runtime_configuration.log_dir + "/pact_broker.log"
           FileUtils.mkdir_p(runtime_configuration.log_dir)
-          @default_appender = SemanticLogger.add_appender(file_name: path, formatter: runtime_configuration.log_format)
+          @default_appender = SemanticLogger.add_appender(file_name: path, formatter: formatter)
         else
-          @default_appender = SemanticLogger.add_appender(io: $stdout, formatter: runtime_configuration.log_format)
+          @default_appender = SemanticLogger.add_appender(io: $stdout, formatter: formatter)
         end
+        PactBroker::Logging::OpenTelemetryAppenderSetup.call(runtime_configuration)
         @logger_from_runtime_configuration = SemanticLogger["pact-broker"]
       end
     end
 
+    def resolve_log_formatter(log_format)
+      if log_format == :json
+        PactBroker::Logging::TraceAwareJsonFormatter.new
+      else
+        log_format
+      end
+    end
+    private :resolve_log_formatter
+
     def logger
       custom_logger || logger_from_runtime_configuration
     end

data/lib/pact_broker/dataset.rb

@@ -8,10 +8,6 @@ module PactBroker
     module Helpers
       extend self
 
-      def mysql?
-        Sequel::Model.db.adapter_scheme.to_s =~ /mysql/
-      end
-
       def postgres?
         Sequel::Model.db.adapter_scheme.to_s =~ /postgres/
       end
@@ -32,14 +28,9 @@ module PactBroker
 
     def name_like column_name, value
       if PactBroker.configuration.use_case_sensitive_resource_names
-        if mysql?
-          # sigh, mysql, this is the only way to perform a case sensitive search
-          Sequel.like(column_name, value.gsub("_", "\\_"), { case_insensitive: false })
-        else
-          { column_name => value }
-        end
+        { column_name => value }
       else
-        Sequel.like(column_name, value.gsub("_", "\\_"), { case_insensitive: true })
+        Sequel.like(column_name, escape_wildcards(value), { case_insensitive: true })
       end
     end
 
@@ -82,12 +73,7 @@ module PactBroker
     end
 
     def select_for_subquery column
-      if mysql? #stoopid mysql doesn't allow you to modify datasets with subqueries
-        column_name = column.respond_to?(:alias) ? column.alias : column
-        select(column).collect{ | it | it[column_name] }
-      else
-        select(column)
-      end
+      select(column)
     end
 
     def no_columns_selected?
@@ -109,12 +95,7 @@ module Sequel
   # This has been used inconsistently, and in the next major version, support for case insensitive names will be dropped.
   def self.name_like(column_name, value)
     if PactBroker.configuration.use_case_sensitive_resource_names
-      if PactBroker::Dataset::Helpers.mysql?
-        # sigh, mysql, this is the only way to perform a case sensitive search
-        Sequel.like(column_name, PactBroker::Dataset::Helpers.escape_wildcards(value), { case_insensitive: false })
-      else
-        { column_name => value }
-      end
+      { column_name => value }
     else
       Sequel.like(column_name, PactBroker::Dataset::Helpers.escape_wildcards(value), { case_insensitive: true })
     end

data/lib/pact_broker/db/clean/branch_selector.rb

@@ -0,0 +1,40 @@
+require "pact_broker/hash_refinements"
+
+module PactBroker
+  module DB
+    class Clean
+      class BranchSelector
+        using PactBroker::HashRefinements
+
+        ATTRIBUTES = [:max_age, :branch]
+
+        attr_accessor(*ATTRIBUTES)
+
+        def initialize(attributes = {})
+          attributes.each do | (name, value) |
+            instance_variable_set("@#{name}", value) if respond_to?(name)
+          end
+          @source_hash = attributes[:source_hash]
+        end
+
+        def self.from_hash(hash)
+          standard_hash = hash.symbolize_keys.snakecase_keys
+          new_hash = standard_hash.slice(*ATTRIBUTES)
+          new_hash[:source_hash] = hash
+          new(new_hash.compact)
+        end
+
+        def to_hash
+          ATTRIBUTES.each_with_object({}) do | key, hash |
+            hash[key] = send(key)
+          end.compact
+        end
+        alias_method :to_h, :to_hash
+
+        def to_json(_opts = nil)
+          (@source_hash || to_hash).to_json
+        end
+      end
+    end
+  end
+end

data/lib/pact_broker/db/clean.rb

@@ -2,6 +2,7 @@ require "sequel"
 require "pact_broker/project_root"
 require "pact_broker/logging"
 require "pact_broker/db/clean/selector"
+require "pact_broker/db/clean/branch_selector"
 
 module PactBroker
   module DB
@@ -130,6 +131,9 @@ module PactBroker
         delete_orphan_tags
         delete_orphan_versions
 
+        deleted_counts[:stale_branches] = delete_stale_branches
+        kept_counts[:stale_branches] = db[:branches].count
+
         { kept: kept_counts, deleted: deleted_counts }
       end
 
@@ -180,6 +184,47 @@ module PactBroker
         db[:versions].where(id: referenced_version_ids).invert.delete
       end
 
+      def delete_stale_branches
+        return 0 unless keep_branches && !keep_branches.empty?
+
+        db[:branches].where(id: stale_branch_ids_to_delete.from_self.select(:id)).delete
+      end
+
+      def stale_branch_ids_to_delete
+        db[:branches]
+          .select(Sequel[:branches][:id])
+          .left_outer_join(stale_branch_ids_to_keep, { Sequel[:branches][:id] => Sequel[:keep_branches][:id] }, table_alias: :keep_branches)
+          .where(Sequel[:keep_branches][:id] => nil)
+      end
+
+      def stale_branch_ids_to_keep
+        queries = [main_branch_ids_to_keep]
+
+        keep_branches.each do | selector |
+          if selector.max_age
+            cutoff = Date.today - selector.max_age
+            queries << db[:branches].where { updated_at >= cutoff }.select(:id)
+          end
+          if selector.branch
+            queries << db[:branches].where(name: Array(selector.branch)).select(:id)
+          end
+        end
+
+        queries.reduce(:union)
+      end
+
+      def main_branch_ids_to_keep
+        db[:branches]
+          .join(:pacticipants, id: Sequel[:branches][:pacticipant_id])
+          .exclude(Sequel[:pacticipants][:main_branch] => nil)
+          .where(Sequel[:branches][:name] => Sequel[:pacticipants][:main_branch])
+          .select(Sequel[:branches][:id])
+      end
+
+      def keep_branches
+        @keep_branches ||= options[:keep_branches]&.collect { | selector_hash | BranchSelector.from_hash(selector_hash.to_hash) }
+      end
+
       def delete_overwritten_verifications
         verification_ids = db[:verifications].select(:id).where(id: db[:latest_verification_id_for_pact_version_and_provider_version].select(:verification_id)).invert
         deleted_counts = { verification_results: verification_ids.count }

data/lib/pact_broker/db/clean_incremental.rb

@@ -2,6 +2,7 @@ require "pact_broker/logging"
 require "pact_broker/matrix/unresolved_selector"
 require "pact_broker/date_helper"
 require "pact_broker/db/clean/selector"
+require "pact_broker/db/clean/branch_selector"
 
 module PactBroker
   module DB
@@ -14,7 +15,10 @@ module PactBroker
         PactBroker::DB::Clean::Selector.new(released: true),
         PactBroker::DB::Clean::Selector.new(max_age: 90)
       ]
-      TABLES = [:versions, :pact_publications, :pact_versions, :verifications, :triggered_webhooks, :webhook_executions]
+      DEFAULT_KEEP_BRANCH_SELECTORS = [
+        PactBroker::DB::Clean::BranchSelector.new(max_age: 90)
+      ]
+      TABLES = [:versions, :pact_publications, :pact_versions, :verifications, :triggered_webhooks, :webhook_executions, :branches]
 
       def self.call database_connection, options = {}
         new(database_connection, options).call
@@ -42,6 +46,7 @@ module PactBroker
       def execute_clean
         db.transaction do
           before_counts = current_counts
+          delete_stale_branches
           PactBroker::Domain::Version.where(id: versions_to_delete.from_self.select_map(:id)).delete
           delete_orphan_pact_versions
           after_counts = current_counts
@@ -68,10 +73,22 @@ module PactBroker
                   end
       end
 
+      def keep_branches
+        @keep_branches ||= if options.key?(:keep_branches)
+                             options[:keep_branches]&.collect { | selector_hash | PactBroker::DB::Clean::BranchSelector.from_hash(selector_hash.to_hash) }
+                           else
+                             DEFAULT_KEEP_BRANCH_SELECTORS
+                           end
+      end
+
       def limit
         options[:limit] || 1000
       end
 
+      def branch_limit
+        options[:branch_limit] || limit
+      end
+
       def versions_to_delete(columns = [:id])
         fully_qualified_columns = columns.collect { |col| Sequel[:versions][col] }
         PactBroker::Domain::Version
@@ -96,13 +113,50 @@ module PactBroker
         options[:dry_run]
       end
 
+      def delete_stale_branches
+        return unless keep_branches && !keep_branches.empty?
+
+        # Wrap the dataset in a derived table with `from_self` before selecting
+        # the ids for deletion, to avoid referencing the target table directly
+        # in the subquery.
+        PactBroker::Versions::Branch.where(id: stale_branch_ids_to_delete.from_self.select(:id)).delete
+      end
+
+      def stale_branch_ids_to_delete
+        PactBroker::Versions::Branch
+          .select(Sequel[:branches][:id])
+          .left_outer_join(stale_branch_ids_to_keep, { Sequel[:branches][:id] => Sequel[:keep_branches][:id] }, table_alias: :keep_branches)
+          .where(Sequel[:keep_branches][:id] => nil)
+          .limit(branch_limit)
+      end
+
+      def stale_branch_ids_to_keep
+        # Always keep main branches for each pacticipant
+        queries = [main_branch_ids_to_keep]
+
+        keep_branches.each do | selector |
+          if selector.max_age
+            cutoff = Date.today - selector.max_age
+            queries << PactBroker::Versions::Branch.where { updated_at >= cutoff }.select(Sequel[:branches][:id])
+          end
+          if selector.branch
+            queries << PactBroker::Versions::Branch.where(name: Array(selector.branch)).select(Sequel[:branches][:id])
+          end
+        end
+
+        queries.reduce(&:union)
+      end
+
+      def main_branch_ids_to_keep
+        PactBroker::Versions::Branch
+          .join(:pacticipants, id: Sequel[:branches][:pacticipant_id])
+          .exclude(Sequel[:pacticipants][:main_branch] => nil)
+          .where(Sequel[:branches][:name] => Sequel[:pacticipants][:main_branch])
+          .select(Sequel[:branches][:id])
+      end
+
       def delete_orphan_pact_versions
         db[:pact_versions].where(id: orphan_pact_versions).delete
-      rescue Sequel::DatabaseError => e
-        raise unless e.cause.class.name == "Mysql2::Error"
-
-        ids = orphan_pact_versions.map { |row| row[:id] }
-        db[:pact_versions].where(id: ids).delete
       end
 
       def orphan_pact_versions
@@ -142,19 +196,29 @@ module PactBroker
           }
         end
 
+        {
+          "counts" => dry_run_counts(kept_per_selector),
+          "versionSummary" => pacticipant_results
+        }
+      end
+
+      def dry_run_counts(kept_per_selector)
         total_versions_count = PactBroker::Domain::Version.count
         versions_to_keep_count = version_ids_to_keep.count
         versions_to_delete_count = versions_to_delete.count
 
+        total_branches_count = PactBroker::Versions::Branch.count
+        branches_to_delete_count = keep_branches && !keep_branches.empty? ? stale_branch_ids_to_delete.count : 0
+
         {
-          "counts" => {
-            "totalVersions" => total_versions_count,
-            "versionsToDelete" => versions_to_delete_count,
-            "versionsNotToKeep" => total_versions_count - versions_to_keep_count,
-            "versionsToKeep" => versions_to_keep_count,
-            "versionsToKeepBySelector" => kept_per_selector,
-          },
-          "versionSummary" => pacticipant_results
+          "totalVersions" => total_versions_count,
+          "versionsToDelete" => versions_to_delete_count,
+          "versionsNotToKeep" => total_versions_count - versions_to_keep_count,
+          "versionsToKeep" => versions_to_keep_count,
+          "versionsToKeepBySelector" => kept_per_selector,
+          "totalBranches" => total_branches_count,
+          "branchesToDelete" => branches_to_delete_count,
+          "branchesToKeep" => total_branches_count - branches_to_delete_count
         }
       end
 

data/lib/pact_broker/db.rb

@@ -57,12 +57,5 @@ module PactBroker
       PactBroker::DB::ValidateEncoding.(connection)
     end
 
-    def self.set_mysql_strict_mode_if_mysql
-      connection.run("SET sql_mode='STRICT_TRANS_TABLES';") if mysql?
-    end
-
-    def self.mysql?
-      connection.adapter_scheme =~ /mysql/
-    end
   end
 end

data/lib/pact_broker/deployments/released_version_service.rb

@@ -46,6 +46,20 @@ module PactBroker
           .single_record
       end
 
+      def self.find_released_versions_for_version(version)
+        scope_for(ReleasedVersion)
+          .where(version_id: version.id)
+          .eager(:environment)
+          .all
+      end
+
+      def self.find_released_versions_for_versions(versions_array)
+        scope_for(ReleasedVersion)
+          .where(version_id: versions_array.map(&:id))
+          .eager(:environment)
+          .to_hash_groups(:version_id)
+      end
+
       def self.record_version_support_ended(released_version)
         released_version.record_support_ended
       end

data/lib/pact_broker/domain/version.rb

@@ -12,6 +12,7 @@ module PactBroker
 
       plugin :timestamps, update_on_create: true
       plugin :age
+      plugin :insert_ignore, identifying_columns: [:pacticipant_id, :number]
       plugin :upsert, { identifying_columns: [:pacticipant_id, :number], ignore_columns_on_update: [:id, :created_at, :order] }
 
       one_to_many :pact_publications, order: :revision_number, class: "PactBroker::Pacts::PactPublication", key: :consumer_version_id
@@ -241,9 +242,11 @@ module PactBroker
         # @return Sequel::Dataset<PactBroker::Domain::Version>
         def ids_for_selectors(unresolved_selectors)
           # Need the select at the start and at the end to stop extra columns being returned (eg. branch name, environment name)
+          # from_self: false keeps this a single flat UNION. Sequel's default would wrap the
+          # accumulated dataset in a new subquery for every selector, nesting it N-1 deep.
           unresolved_selectors
             .collect{ |selector| self.select(Sequel[:versions][:id]).for_selector(selector).select(:id) }
-            .reduce(&:union)
+            .reduce { |all_ids, ids| all_ids.union(ids, from_self: false) }
         end
 
         def pacticipants_set
@@ -272,10 +275,11 @@ module PactBroker
       end
 
       # Isn't called on upsert when the record is updated with Sqlite
-      # Is called with Postgres/MySQL
+      # Is called with Postgres
       # Haven't had time to dig into why
       def after_create
         super
+        return unless id
         OrderVersions.(self) unless self.order
         refresh
       end

data/lib/pact_broker/initializers/database_connection.rb

@@ -1,9 +1,14 @@
 require "sequel"
 require "pact_broker/db/log_quietener"
 require "fileutils"
+require "pact_broker/error"
 
 module PactBroker
   def self.create_database_connection(config, logger = nil)
+    if config[:adapter].to_s =~ /mysql/
+      raise PactBroker::Error.new("MySQL is no longer supported. Please use PostgreSQL.")
+    end
+
     logger&.info("Connecting to database:", config.merge(password: "*****"))
 
     sequel_config = config.dup

data/lib/pact_broker/integrations/repository.rb

@@ -74,7 +74,7 @@ module PactBroker
       def set_contract_data_updated_at_for_multiple_integrations(objects_with_consumer_and_provider)
         consumer_and_provider_ids = objects_with_consumer_and_provider.collect{ | object | { consumer_id: object.consumer&.id, provider_id: object.provider.id }.compact }.uniq
 
-        # MySQL doesn't support an UPDATE with a subquery. FFS. Really need to do a major version release and delete the support code.
+        # Not all supported databases handle an UPDATE with a subquery, so branch on SKIP LOCKED support.
         criteria =  if Integration.dataset.supports_skip_locked?
                       integration_ids_to_update = Integration
                                                   .select(:id)

data/lib/pact_broker/integrations/service.rb

@@ -55,9 +55,7 @@ module PactBroker
             model.truncate(cascade: true)
           else
             logger.info("Deleting all from ", model.table_name)
-            # Mysql adapter needs to support cascade truncate
-            # https://travis-ci.org/pact-foundation/pact_broker/jobs/633050220#L841
-            # https://travis-ci.org/pact-foundation/pact_broker/jobs/633053228#L849
+            # SQLite does not support cascade truncate, so delete instead
             model.dataset.delete
           end
         end