query_sql.rb

# frozen_string_literal: true

# auto-generated by sqlc - do not edit
require 'connection_pool'
require 'mysql2'
require 'bigdecimal'
require 'date'
require 'tempfile'
require_relative 'connection'
require_relative 'models'

module Mysql2Codegen
  GET_AUTHOR_SQL = <<~'SQL'
    SELECT id, name, bio FROM authors
    WHERE id = ? LIMIT 1
  SQL

  class GetAuthorRow < ::Data.define(:id, :name, :bio)
  end

  LIST_AUTHORS_SQL = <<~'SQL'
    SELECT id, name, bio FROM authors
    ORDER BY name
  SQL

  class ListAuthorsRow < ::Data.define(:id, :name, :bio)
  end

  CREATE_AUTHOR_SQL = <<~'SQL'
    INSERT INTO authors (
      name, bio
    ) VALUES (
      ?, ? 
    )
  SQL

  UPDATE_AUTHOR_SQL = <<~'SQL'
    UPDATE authors 
    SET bio = ?
    WHERE id = ?
  SQL

  CREATE_AUTHOR_RETURN_ID_SQL = <<~'SQL'
    INSERT INTO authors (
        name, bio
    ) VALUES (
        ?, ?
    )
  SQL

  DELETE_AUTHOR_SQL = <<~'SQL'
    DELETE FROM authors
    WHERE id = ?
  SQL

  INSERT_MYSQL_NUMERIC_TYPES_SQL = <<~'SQL'
    INSERT INTO mysql_numeric_types (
      id, c_bool, c_boolean, c_tinyint, c_smallint, c_mediumint, c_int, c_integer, c_bigint, c_bigint_unsigned, c_decimal, c_dec, c_numeric, c_fixed, c_decimal_wide, c_float, c_double, c_double_precision
    ) VALUES (
      ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
    )
  SQL

  GET_MYSQL_NUMERIC_TYPES_SQL = <<~'SQL'
    SELECT id, c_bool, c_boolean, c_tinyint, c_smallint, c_mediumint, c_int, c_integer, c_bigint, c_bigint_unsigned, c_serial, c_decimal, c_dec, c_numeric, c_fixed, c_decimal_wide, c_float, c_double, c_double_precision FROM mysql_numeric_types WHERE id = ?
  SQL

  class GetMysqlNumericTypesRow < ::Data.define(
    :id,
    :c_bool,
    :c_boolean,
    :c_tinyint,
    :c_smallint,
    :c_mediumint,
    :c_int,
    :c_integer,
    :c_bigint,
    :c_bigint_unsigned,
    :c_serial,
    :c_decimal,
    :c_dec,
    :c_numeric,
    :c_fixed,
    :c_decimal_wide,
    :c_float,
    :c_double,
    :c_double_precision
  )
  end

  INSERT_MYSQL_STRING_TYPES_SQL = <<~'SQL'
    INSERT INTO mysql_string_types (
      id, c_char, c_nchar, c_national_char, c_varchar, c_tinytext, c_text, c_mediumtext, c_longtext, c_json
    ) VALUES (
      ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
    )
  SQL

  GET_MYSQL_STRING_TYPES_SQL = <<~'SQL'
    SELECT id, c_char, c_nchar, c_national_char, c_varchar, c_tinytext, c_text, c_mediumtext, c_longtext, c_json FROM mysql_string_types WHERE id = ?
  SQL

  class GetMysqlStringTypesRow < ::Data.define(
    :id,
    :c_char,
    :c_nchar,
    :c_national_char,
    :c_varchar,
    :c_tinytext,
    :c_text,
    :c_mediumtext,
    :c_longtext,
    :c_json
  )
  end

  INSERT_MYSQL_DATETIME_TYPES_SQL = <<~'SQL'
    INSERT INTO mysql_datetime_types (
      id, c_date, c_time, c_datetime, c_datetime_6, c_timestamp, c_year
    ) VALUES (
      ?, ?, ?, ?, ?, ?, ?
    )
  SQL

  GET_MYSQL_DATETIME_TYPES_SQL = <<~'SQL'
    SELECT id, c_date, c_time, c_datetime, c_datetime_6, c_timestamp, c_year FROM mysql_datetime_types WHERE id = ?
  SQL

  # rubocop:disable Naming/VariableNumber
  class GetMysqlDatetimeTypesRow < ::Data.define(
    :id,
    :c_date,
    :c_time,
    :c_datetime,
    :c_datetime_6,
    :c_timestamp,
    :c_year
  )
  end
  # rubocop:enable Naming/VariableNumber

  # rubocop:disable Naming/VariableNumber
  class CopyMysqlDatetimeTypesArgs < ::Data.define(:id, :c_datetime_6)
  end
  # rubocop:enable Naming/VariableNumber

  INSERT_MYSQL_BINARY_TYPES_SQL = <<~'SQL'
    INSERT INTO mysql_binary_types (
      id, c_bit, c_bit_16, c_binary, c_varbinary, c_tinyblob, c_blob, c_mediumblob, c_longblob
    ) VALUES (
      ?, ?, ?, ?, ?, ?, ?, ?, ?
    )
  SQL

  GET_MYSQL_BINARY_TYPES_SQL = <<~'SQL'
    SELECT id, c_bit, c_bit_16, c_binary, c_varbinary, c_tinyblob, c_blob, c_mediumblob, c_longblob FROM mysql_binary_types WHERE id = ?
  SQL

  # rubocop:disable Naming/VariableNumber
  class GetMysqlBinaryTypesRow < ::Data.define(
    :id,
    :c_bit,
    :c_bit_16,
    :c_binary,
    :c_varbinary,
    :c_tinyblob,
    :c_blob,
    :c_mediumblob,
    :c_longblob
  )
  end
  # rubocop:enable Naming/VariableNumber

  LIST_AUTHORS_PAGED_SQL = <<~'SQL'
    SELECT id, name, bio FROM authors
    ORDER BY name
    LIMIT ? OFFSET ?
  SQL

  class ListAuthorsPagedRow < ::Data.define(:id, :name, :bio)
  end

  GET_AUTHOR_BY_NAME_PATTERN_SQL = <<~'SQL'
    SELECT id, name, bio FROM authors
    WHERE name LIKE COALESCE(?, '%')
  SQL

  class GetAuthorByNamePatternRow < ::Data.define(:id, :name, :bio)
  end

  GET_AUTHORS_BY_OPTIONAL_NAME_SQL = <<~'SQL'
    SELECT id, name, bio FROM authors
    WHERE (? IS NULL OR name = ?)
    ORDER BY id
    LIMIT ?
  SQL

  class GetAuthorsByOptionalNameRow < ::Data.define(:id, :name, :bio)
  end

  PAUSE_QUERY_SQL = <<~'SQL'
    SELECT SLEEP(?)
  SQL

  class PauseQueryRow < ::Data.define(:sleep)
  end

  UPDATE_AUTHOR_BIOS_SQL = <<~'SQL'
    UPDATE authors
    SET bio = ?
    WHERE bio IS NOT NULL
  SQL

  GET_AUTHORS_BY_IDS_SQL = <<~'SQL'
    SELECT id, name, bio FROM authors WHERE id IN (/*SLICE:ids*/?)
  SQL

  class GetAuthorsByIdsRow < ::Data.define(:id, :name, :bio)
  end

  GET_AUTHORS_BY_IDS_AND_NAMES_SQL = <<~'SQL'
    SELECT id, name, bio FROM authors WHERE id IN (/*SLICE:ids*/?) AND name IN (/*SLICE:names*/?)
  SQL

  class GetAuthorsByIdsAndNamesRow < ::Data.define(:id, :name, :bio)
  end

  class CopyAuthorsArgs < ::Data.define(:name, :bio)
  end

  TRUNCATE_AUTHORS_SQL = <<~'SQL'
    DELETE FROM authors
  SQL

  CREATE_BOOK_SQL = <<~'SQL'
    INSERT INTO books (name, author_id) VALUES (?, ?)
  SQL

  LIST_ALL_AUTHORS_BOOKS_SQL = <<~'SQL'
    SELECT authors.id, authors.name, authors.bio, books.id, books.name, books.author_id, books.description
    FROM authors JOIN books ON authors.id = books.author_id
    ORDER BY authors.name
  SQL

  class ListAllAuthorsBooksRow < ::Data.define(:author, :book)
  end

  GET_DUPLICATE_AUTHORS_SQL = <<~'SQL'
    SELECT authors1.id, authors1.name, authors1.bio, authors2.id, authors2.name, authors2.bio
    FROM authors authors1 JOIN authors authors2 ON authors1.name = authors2.name
    WHERE authors1.id < authors2.id
  SQL

  class GetDuplicateAuthorsRow < ::Data.define(:author, :author2)
  end

  GET_AUTHORS_BY_BOOK_NAME_SQL = <<~'SQL'
    SELECT authors.id, authors.name, authors.bio, books.id, books.name, books.author_id, books.description
    FROM authors JOIN books ON authors.id = books.author_id
    WHERE books.name = ?
  SQL

  class GetAuthorsByBookNameRow < ::Data.define(:id, :name, :bio, :book)
  end

  CREATE_EXTENDED_BIO_SQL = <<~'SQL'
    INSERT INTO extended_bios (author_name, name, bio_type, author_type) VALUES (?, ?, ?, ?)
  SQL

  GET_FIRST_EXTENDED_BIO_BY_TYPE_SQL = <<~'SQL'
    SELECT author_name, name, bio_type, author_type FROM extended_bios WHERE bio_type = ? LIMIT 1
  SQL

  class GetFirstExtendedBioByTypeRow < ::Data.define(:author_name, :name, :bio_type, :author_type)
  end

  TRUNCATE_EXTENDED_BIOS_SQL = <<~'SQL'
    DELETE FROM extended_bios
  SQL

  CREATE_AUTHOR_RESULT_SQL = <<~'SQL'
    INSERT INTO authors (name, bio) VALUES (?, ?)
  SQL

  CREATE_AUTHORS_BATCH_SQL = <<~'SQL'
    INSERT INTO authors (name, bio) VALUES (?, ?)
  SQL

  class CreateAuthorsBatchArgs < ::Data.define(:name, :bio)
  end

  GET_AUTHOR_BATCH_SQL = <<~'SQL'
    SELECT id, name, bio FROM authors WHERE id = ?
  SQL

  class GetAuthorBatchRow < ::Data.define(:id, :name, :bio)
  end

  class GetAuthorBatchArgs < ::Data.define(:id)
  end

  LIST_AUTHORS_BY_NAME_BATCH_SQL = <<~'SQL'
    SELECT id, name, bio FROM authors WHERE name = ? ORDER BY id
  SQL

  class ListAuthorsByNameBatchRow < ::Data.define(:id, :name, :bio)
  end

  class ListAuthorsByNameBatchArgs < ::Data.define(:name)
  end

  COUNT_REGRESSIONS_BY_TEXT_SQL = <<~'SQL'
    SELECT count(*) FROM regressions WHERE `order` = ? OR note = ?
  SQL

  class CountRegressionsByTextRow < ::Data.define(:count)
  end

  LIST_REGRESSIONS_BY_IDS_SQL = <<~'SQL'
    SELECT id, `order`, note FROM regressions WHERE id IN (?, ?, ?) ORDER BY id
  SQL

  class ListRegressionsByIdsRow < ::Data.define(:id, :order, :note)
  end

  class CopyRegressionsArgs < ::Data.define(:order, :note)
  end

  class CopyRegressionRowsArgs < ::Data.define(:id, :order, :note, :payload)
  end

  SET_REGRESSION_STEP_SQL = <<~'SQL'
    UPDATE regressions SET step = ? WHERE id = ?
  SQL

  GET_REGRESSION_STEP_SQL = <<~'SQL'
    SELECT step FROM regressions WHERE id = ?
  SQL

  class GetRegressionStepRow < ::Data.define(:step)
  end

  LIST_REGRESSION_ROWS_SQL = <<~'SQL'
    SELECT id, `order`, note, payload, code, doc, flags, amount FROM regressions ORDER BY id
  SQL

  class ListRegressionRowsRow < ::Data.define(
    :id,
    :order,
    :note,
    :payload,
    :code,
    :doc,
    :flags,
    :amount
  )
  end

  LIST_AUTHORS_WITH_OPTIONAL_BOOK_SQL = <<~'SQL'
    SELECT authors.id, authors.name, authors.bio, books.id, books.name, books.author_id, books.description
    FROM authors
    LEFT JOIN books ON authors.id = books.author_id
    ORDER BY authors.id
  SQL

  class ListAuthorsWithOptionalBookRow < ::Data.define(:author, :book)
  end

  TRUNCATE_REGRESSIONS_SQL = <<~'SQL'
    TRUNCATE TABLE regressions
  SQL

  class CopyRegressionTypesArgs < ::Data.define(
    :id,
    :code,
    :doc,
    :flags,
    :amount
  )
  end

  class CopyRegressionsIgnoreArgs < ::Data.define(:id, :code)
  end

  class CopyRegressionsReplaceArgs < ::Data.define(:id, :code)
  end

  CREATE_REGRESSIONS_BATCH_SQL = <<~'SQL'
    INSERT INTO regressions (id, code, flags, amount) VALUES (?, ?, ?, ?)
  SQL

  class CreateRegressionsBatchArgs < ::Data.define(:id, :code, :flags, :amount)
  end

  COUNT_REGRESSIONS_BY_CODES_SQL = <<~'SQL'
    SELECT count(*) AS matches FROM regressions WHERE code = ? OR code = ?
  SQL

  class CountRegressionsByCodesRow < ::Data.define(:matches)
  end

  # rubocop:disable Naming/VariableNumber
  class CountRegressionsByCodesArgs < ::Data.define(:code, :code_2)
  end
  # rubocop:enable Naming/VariableNumber

  FIND_AUTHORS_BY_EXACT_NAME_SQL = <<~'SQL'
    SELECT id FROM authors WHERE name = ?
  SQL

  class FindAuthorsByExactNameRow < ::Data.define(:id)
  end

  GET_AUTHOR_WITH_QUESTION_MARKS_SQL = <<~'SQL'
    SELECT id FROM authors AS `?`
    WHERE name = ? AND '?' = '?' AND "?" = "?" /* ? */
    ORDER BY id
  SQL

  class GetAuthorWithQuestionMarksRow < ::Data.define(:id)
  end

  INSERT_NAME_CASE_SQL = <<~'SQL'
    INSERT INTO name_cases (id, `class`, `end`, `hash`, `method`, `count`, `camelCase`, `HTTPServer`, `initialize`)
    VALUES (?, ?, ?, ?, ?, ?,
            ?, ?, ?)
  SQL

  GET_NAME_CASE_SQL = <<~'SQL'
    SELECT id, class, end, hash, method, count, camelcase, httpserver, initialize FROM name_cases
    WHERE id = ? AND `class` = ? AND `end` = ? AND `hash` = ?
      AND `method` = ? AND `count` = ?
      AND `HTTPServer` = ? AND `camelCase` = ?
      AND `initialize` = ?
  SQL

  class GetNameCaseRow < ::Data.define(
    :id,
    :class_,
    :end,
    :hash_,
    :method_,
    :count,
    :camelcase,
    :httpserver,
    :initialize_
  )
  end

  GET_HTTP_SERVER_SQL = <<~'SQL'
    SELECT id, class, end, hash, method, count, camelcase, httpserver, initialize FROM name_cases WHERE id = ?
  SQL

  class GetHTTPServerRow < ::Data.define(
    :id,
    :class_,
    :end,
    :hash_,
    :method_,
    :count,
    :camelcase,
    :httpserver,
    :initialize_
  )
  end

  TRUNCATE_NAME_CASES_SQL = <<~'SQL'
    TRUNCATE TABLE name_cases
  SQL

  class CopyMixedCaseCopiesArgs < ::Data.define(:id, :somevalue)
  end

  class CopyMixedCaseCopiesUnquotedArgs < ::Data.define(:somevalue, :id)
  end

  LIST_MIXED_CASE_COPIES_SQL = <<~'SQL'
    SELECT id, somevalue FROM `MixedCaseCopies` ORDER BY `Id`
  SQL

  class ListMixedCaseCopiesRow < ::Data.define(:id, :somevalue)
  end

  TRUNCATE_MIXED_CASE_COPIES_SQL = <<~'SQL'
    TRUNCATE TABLE `MixedCaseCopies`
  SQL

  GET_UNNAMED_COLUMNS_SQL = <<~'SQL'
    SELECT 1, 'two'
  SQL

  # rubocop:disable Naming/VariableNumber
  class GetUnnamedColumnsRow < ::Data.define(:column_1, :column_2)
  end
  # rubocop:enable Naming/VariableNumber

  GET_QUOTED_ALIAS_SQL = <<~'SQL'
    SELECT 1 AS `it's`
  SQL

  class GetQuotedAliasRow < ::Data.define(:it_s)
  end

  GET_AUTHORS_NOT_IN_IDS_SQL = <<~'SQL'
    SELECT id, name, bio FROM authors WHERE id NOT IN (/*SLICE:ids*/?) ORDER BY id
  SQL

  class GetAuthorsNotInIdsRow < ::Data.define(:id, :name, :bio)
  end

  CREATE_EXCEPTION_SQL = <<~'SQL'
    INSERT INTO exceptions (id) VALUES (NULL)
  SQL

  COUNT_EXCEPTIONS_SQL = <<~'SQL'
    SELECT COUNT(*) AS n FROM exceptions
  SQL

  class CountExceptionsRow < ::Data.define(:n)
  end

  TRUNCATE_EXCEPTIONS_SQL = <<~'SQL'
    TRUNCATE TABLE exceptions
  SQL

  HAS_AUTHORS_SQL = <<~'SQL'
    SELECT EXISTS (SELECT 1 FROM authors) AS has_any
  SQL

  class HasAuthorsRow < ::Data.define(:has_any)
  end

  class QuerySql
    # Raised by the bang variants (get_author!) when the query returns no row.
    class NotFound < ::StandardError; end

    # Opens a pool of connections: QuerySql.connect({ database: 'app' }, size: 5, timeout: 5, logger: Logger.new($stdout))
    # (pool_options go to ConnectionPool.new). To share an existing pool use QuerySql.new(pool).
    def self.connect(mysql2_params, logger: nil, **pool_options)
      new(::ConnectionPool.new(**pool_options) { ::Mysql2::Client.new(**mysql2_params) }, logger: logger)
    end

    # db: a ConnectionPool (or anything that responds to #with and yields a Mysql2::Client).
    # logger: optional, anything with #debug (Logger, Rails.logger); logs the name and duration of every query.
    def initialize(db, logger: nil)
      @db = db
      @logger = logger
    end

    # Runs the block in a transaction on one connection and returns its value: COMMIT when the block returns
    # (also through break / return / throw), ROLLBACK when it raises or the thread is killed. A nested call
    # becomes a SAVEPOINT. Yields a copy of self whose queries run in the transaction, also from other fibers and
    # threads (Enumerator, Async tasks); it raises TransactionEnded when used after the transaction.
    def transaction(isolation: nil)
      raise ::ArgumentError, "unknown isolation level: #{isolation.inspect}" unless isolation.nil? || ISOLATION_LEVELS.key?(isolation)

      with_client('transaction') do |client|
        outermost = !client.in_transaction
        raise ::ArgumentError, 'isolation: cannot be set on a nested transaction' if isolation && !outermost

        savepoint = outermost ? nil : "sqlc_sp_#{rand(0xffff_ffff).to_s(16)}"
        level = "SET TRANSACTION ISOLATION LEVEL #{ISOLATION_LEVELS.fetch(isolation)}" if isolation
        rollback = outermost ? 'ROLLBACK' : "ROLLBACK TO SAVEPOINT #{savepoint}"
        # Timeout / Thread#raise / Thread#kill wait while BEGIN, COMMIT and ROLLBACK run and only interrupt the
        # block: the connection never goes back to the pool inside a transaction.
        bound = TransactionConnection.new(client) unless @db.is_a?(TransactionConnection)
        ::Thread.handle_interrupt(::Object => :never) do
          started = false
          failed = false
          begin
            if outermost
              client.in_transaction = true
              client.query(level) if level
              client.query('BEGIN')
            else
              client.query("SAVEPOINT #{savepoint}")
            end
            started = true
            ::Thread.handle_interrupt(::Object => :immediate) do
              bound ? yield(bound_to(bound)) : @db.unlocked { yield self }
            end
          rescue ::Exception => e # rubocop:disable Lint/RescueException
            failed = true
            bound&.close
            begin
              client.query(rollback) if (started || outermost) && !client.rolled_back_by
            rescue ::Mysql2::Error
              # a deadlock / lock wait timeout already rolled back the transaction: its savepoints are gone;
              # an interrupted query closed the connection: the server rolls back
              raise unless e.is_a?(::Mysql2::Error) || client.closed?
            end
            raise
          ensure
            bound&.close
            begin
              unless failed
                if ::Thread.current.status == 'aborting' && client.query_running?
                  # Thread#kill interrupted a query: the client still waits for its result and cannot send
                  # ROLLBACK. Closing it makes the server roll back; #with_client discards it.
                  client.close
                elsif client.rolled_back_by
                  # the server already rolled the whole transaction back (its savepoints too): COMMIT would only
                  # end the statements run since, so raise instead of reporting a commit
                  raise client.rolled_back_error if ::Thread.current.status != 'aborting'
                else
                  commit = outermost ? 'COMMIT' : "RELEASE SAVEPOINT #{savepoint}"
                  begin
                    client.query(::Thread.current.status == 'aborting' ? rollback : commit)
                  rescue ::Exception # rubocop:disable Lint/RescueException
                    # COMMIT did not run: roll back instead of leaving the transaction open (a closed client is
                    # discarded and the server rolls back)
                    begin
                      client.query('ROLLBACK') if outermost && !client.closed?
                    rescue ::Mysql2::Error
                      nil
                    end
                    raise
                  end
                end
              end
            ensure
              if outermost
                client.in_transaction = false
                client.rolled_back_by = nil
              end
            end
          end
        end
      end
    end

    class ExecResult < ::Data.define(:rows_affected, :last_insert_id)
    end

    # Returns the author with the given id, or nil when there is none.
    def get_author(id:)
      with_client('get_author') do |client|
        query_params = [id]
        result = client.query(bind_params(client, GET_AUTHOR_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        row = result.first
        row && GetAuthorRow.new(row[0], row[1], row[2])
      end
    end

    # Like #get_author, but raises NotFound when there is no row.
    def get_author!(...)
      get_author(...) || raise(NotFound, 'GetAuthor returned no row')
    end

    def list_authors
      with_client('list_authors') do |client|
        result = client.query(bind_params(client, LIST_AUTHORS_SQL, []), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          ListAuthorsRow.new(row[0], row[1], row[2])
        end
      end
    end

    def create_author(name:, bio:)
      with_client('create_author') do |client|
        query_params = [name, bio]
        client.query(bind_params(client, CREATE_AUTHOR_SQL, query_params))
        nil
      end
    end

    def update_author(bio:, id:)
      with_client('update_author') do |client|
        query_params = [bio, id]
        client.query(bind_params(client, UPDATE_AUTHOR_SQL, query_params))
        nil
      end
    end

    def create_author_return_id(name:, bio:)
      with_client('create_author_return_id') do |client|
        query_params = [name, bio]
        client.query(bind_params(client, CREATE_AUTHOR_RETURN_ID_SQL, query_params))
        client.last_id
      end
    end

    def delete_author(id:)
      with_client('delete_author') do |client|
        query_params = [id]
        client.query(bind_params(client, DELETE_AUTHOR_SQL, query_params))
        nil
      end
    end

    def insert_mysql_numeric_types(id:, c_bool:, c_boolean:, c_tinyint:, c_smallint:, c_mediumint:, c_int:, c_integer:, c_bigint:, c_bigint_unsigned:, c_decimal:, c_dec:, c_numeric:, c_fixed:, c_decimal_wide:, c_float:, c_double:, c_double_precision:)
      with_client('insert_mysql_numeric_types') do |client|
        query_params = [
          id,
          c_bool,
          c_boolean,
          c_tinyint,
          c_smallint,
          c_mediumint,
          c_int,
          c_integer,
          c_bigint,
          c_bigint_unsigned,
          c_decimal,
          c_dec,
          c_numeric,
          c_fixed,
          c_decimal_wide,
          c_float,
          c_double,
          c_double_precision
        ]
        client.query(bind_params(client, INSERT_MYSQL_NUMERIC_TYPES_SQL, query_params))
        nil
      end
    end

    def get_mysql_numeric_types(id:)
      with_client('get_mysql_numeric_types') do |client|
        query_params = [id]
        result = client.query(bind_params(client, GET_MYSQL_NUMERIC_TYPES_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        row = result.first
        row && GetMysqlNumericTypesRow.new(
          row[0],
          row[1],
          row[2],
          row[3],
          row[4],
          row[5],
          row[6],
          row[7],
          row[8],
          row[9],
          row[10],
          row[11],
          row[12],
          row[13],
          row[14],
          row[15],
          row[16],
          row[17],
          row[18]
        )
      end
    end

    # Like #get_mysql_numeric_types, but raises NotFound when there is no row.
    def get_mysql_numeric_types!(...)
      get_mysql_numeric_types(...) || raise(NotFound, 'GetMysqlNumericTypes returned no row')
    end

    def insert_mysql_string_types(id:, c_char:, c_nchar:, c_national_char:, c_varchar:, c_tinytext:, c_text:, c_mediumtext:, c_longtext:, c_json:)
      with_client('insert_mysql_string_types') do |client|
        query_params = [
          id,
          c_char,
          c_nchar,
          c_national_char,
          c_varchar,
          c_tinytext,
          c_text,
          c_mediumtext,
          c_longtext,
          c_json
        ]
        client.query(bind_params(client, INSERT_MYSQL_STRING_TYPES_SQL, query_params))
        nil
      end
    end

    def get_mysql_string_types(id:)
      with_client('get_mysql_string_types') do |client|
        query_params = [id]
        result = client.query(bind_params(client, GET_MYSQL_STRING_TYPES_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        row = result.first
        row && GetMysqlStringTypesRow.new(
          row[0],
          row[1],
          row[2],
          row[3],
          row[4],
          row[5],
          row[6],
          row[7],
          row[8],
          row[9]
        )
      end
    end

    # Like #get_mysql_string_types, but raises NotFound when there is no row.
    def get_mysql_string_types!(...)
      get_mysql_string_types(...) || raise(NotFound, 'GetMysqlStringTypes returned no row')
    end

    def insert_mysql_datetime_types(id:, c_date:, c_time:, c_datetime:, c_datetime_6:, c_timestamp:, c_year:)
      with_client('insert_mysql_datetime_types') do |client|
        query_params = [
          id,
          c_date,
          c_time,
          c_datetime,
          c_datetime_6,
          c_timestamp,
          c_year
        ]
        client.query(bind_params(client, INSERT_MYSQL_DATETIME_TYPES_SQL, query_params))
        nil
      end
    end

    def get_mysql_datetime_types(id:)
      with_client('get_mysql_datetime_types') do |client|
        query_params = [id]
        result = client.query(bind_params(client, GET_MYSQL_DATETIME_TYPES_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        row = result.first
        row && GetMysqlDatetimeTypesRow.new(
          row[0],
          row[1],
          row[2],
          row[3],
          row[4],
          row[5],
          row[6]
        )
      end
    end

    # Like #get_mysql_datetime_types, but raises NotFound when there is no row.
    def get_mysql_datetime_types!(...)
      get_mysql_datetime_types(...) || raise(NotFound, 'GetMysqlDatetimeTypes returned no row')
    end

    def copy_mysql_datetime_types(rows)
      with_client('copy_mysql_datetime_types') do |client|
        ::Tempfile.create(['copy_mysql_datetime_types', '.csv']) do |file|
          rows.each do |row|
            file.write(csv_line(client, [row.id, row.c_datetime_6]))
          end
          file.flush
          load_data(client, "LOAD DATA LOCAL INFILE '#{client.escape(file.path)}' INTO TABLE `mysql_datetime_types` CHARACTER SET binary FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' ESCAPED BY '\\\\' LINES TERMINATED BY '\\n' (`id`, `c_datetime_6`)") if file.pos.positive?
        end
        nil
      end
    end

    def insert_mysql_binary_types(id:, c_bit:, c_bit_16:, c_binary:, c_varbinary:, c_tinyblob:, c_blob:, c_mediumblob:, c_longblob:)
      with_client('insert_mysql_binary_types') do |client|
        query_params = [
          id,
          c_bit,
          c_bit_16,
          c_binary,
          c_varbinary,
          c_tinyblob,
          c_blob,
          c_mediumblob,
          c_longblob
        ]
        client.query(bind_params(client, INSERT_MYSQL_BINARY_TYPES_SQL, query_params))
        nil
      end
    end

    def get_mysql_binary_types(id:)
      with_client('get_mysql_binary_types') do |client|
        query_params = [id]
        result = client.query(bind_params(client, GET_MYSQL_BINARY_TYPES_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        row = result.first
        row && GetMysqlBinaryTypesRow.new(
          row[0],
          row[1],
          row[2],
          row[3],
          row[4],
          row[5],
          row[6],
          row[7],
          row[8]
        )
      end
    end

    # Like #get_mysql_binary_types, but raises NotFound when there is no row.
    def get_mysql_binary_types!(...)
      get_mysql_binary_types(...) || raise(NotFound, 'GetMysqlBinaryTypes returned no row')
    end

    def list_authors_paged(limit:, offset:)
      with_client('list_authors_paged') do |client|
        query_params = [limit, offset]
        result = client.query(bind_params(client, LIST_AUTHORS_PAGED_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          ListAuthorsPagedRow.new(row[0], row[1], row[2])
        end
      end
    end

    def get_author_by_name_pattern(name_pattern: nil)
      with_client('get_author_by_name_pattern') do |client|
        query_params = [name_pattern]
        result = client.query(bind_params(client, GET_AUTHOR_BY_NAME_PATTERN_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          GetAuthorByNamePatternRow.new(row[0], row[1], row[2])
        end
      end
    end

    def get_authors_by_optional_name(limit:, name_filter: nil)
      with_client('get_authors_by_optional_name') do |client|
        query_params = [name_filter, name_filter, limit]
        result = client.query(bind_params(client, GET_AUTHORS_BY_OPTIONAL_NAME_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          GetAuthorsByOptionalNameRow.new(row[0], row[1], row[2])
        end
      end
    end

    def pause_query(seconds:)
      with_client('pause_query') do |client|
        query_params = [seconds]
        client.query(bind_params(client, PAUSE_QUERY_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        nil
      end
    end

    # Sets the bio of every author that has one and returns how many were changed.
    def update_author_bios(bio: nil)
      with_client('update_author_bios') do |client|
        query_params = [bio]
        client.query(bind_params(client, UPDATE_AUTHOR_BIOS_SQL, query_params))
        client.affected_rows
      end
    end

    def get_authors_by_ids(ids:)
      with_client('get_authors_by_ids') do |client|
        query_params = [*ids]
        sql = GET_AUTHORS_BY_IDS_SQL.gsub('/*SLICE:ids*/?', slice_placeholders(ids))
        result = client.query(bind_params(client, sql, query_params), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          GetAuthorsByIdsRow.new(row[0], row[1], row[2])
        end
      end
    end

    def get_authors_by_ids_and_names(ids:, names:)
      with_client('get_authors_by_ids_and_names') do |client|
        query_params = [*ids, *names]
        sql = GET_AUTHORS_BY_IDS_AND_NAMES_SQL.gsub('/*SLICE:ids*/?', slice_placeholders(ids))
        sql = sql.gsub('/*SLICE:names*/?', slice_placeholders(names))
        result = client.query(bind_params(client, sql, query_params), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          GetAuthorsByIdsAndNamesRow.new(row[0], row[1], row[2])
        end
      end
    end

    # Bulk insert: pass an Array of CopyAuthorsArgs.
    def copy_authors(rows)
      with_client('copy_authors') do |client|
        ::Tempfile.create(['copy_authors', '.csv']) do |file|
          rows.each do |row|
            file.write(csv_line(client, [row.name, row.bio]))
          end
          file.flush
          load_data(client, "LOAD DATA LOCAL INFILE '#{client.escape(file.path)}' INTO TABLE `authors` CHARACTER SET binary FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' ESCAPED BY '\\\\' LINES TERMINATED BY '\\n' (`name`, `bio`)") if file.pos.positive?
        end
        nil
      end
    end

    def truncate_authors
      with_client('truncate_authors') do |client|
        client.query(bind_params(client, TRUNCATE_AUTHORS_SQL, []))
        nil
      end
    end

    def create_book(name:, author_id:)
      with_client('create_book') do |client|
        query_params = [name, author_id]
        client.query(bind_params(client, CREATE_BOOK_SQL, query_params))
        client.last_id
      end
    end

    def list_all_authors_books
      with_client('list_all_authors_books') do |client|
        result = client.query(bind_params(client, LIST_ALL_AUTHORS_BOOKS_SQL, []), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          ListAllAuthorsBooksRow.new(
            Author.new(row[0], row[1], row[2]),
            Book.new(row[3], row[4], row[5], row[6])
          )
        end
      end
    end

    def get_duplicate_authors
      with_client('get_duplicate_authors') do |client|
        result = client.query(bind_params(client, GET_DUPLICATE_AUTHORS_SQL, []), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          GetDuplicateAuthorsRow.new(Author.new(row[0], row[1], row[2]), Author.new(row[3], row[4], row[5]))
        end
      end
    end

    def get_authors_by_book_name(name:)
      with_client('get_authors_by_book_name') do |client|
        query_params = [name]
        result = client.query(bind_params(client, GET_AUTHORS_BY_BOOK_NAME_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          GetAuthorsByBookNameRow.new(row[0], row[1], row[2], Book.new(row[3], row[4], row[5], row[6]))
        end
      end
    end

    def create_extended_bio(author_name:, name:, bio_type:, author_type:)
      with_client('create_extended_bio') do |client|
        query_params = [author_name, name, bio_type, author_type]
        client.query(bind_params(client, CREATE_EXTENDED_BIO_SQL, query_params))
        nil
      end
    end

    def get_first_extended_bio_by_type(bio_type:)
      with_client('get_first_extended_bio_by_type') do |client|
        query_params = [bio_type]
        result = client.query(bind_params(client, GET_FIRST_EXTENDED_BIO_BY_TYPE_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        row = result.first
        row && GetFirstExtendedBioByTypeRow.new(row[0], row[1], row[2], row[3])
      end
    end

    # Like #get_first_extended_bio_by_type, but raises NotFound when there is no row.
    def get_first_extended_bio_by_type!(...)
      get_first_extended_bio_by_type(...) || raise(NotFound, 'GetFirstExtendedBioByType returned no row')
    end

    def truncate_extended_bios
      with_client('truncate_extended_bios') do |client|
        client.query(bind_params(client, TRUNCATE_EXTENDED_BIOS_SQL, []))
        nil
      end
    end

    def create_author_result(name:, bio:)
      with_client('create_author_result') do |client|
        query_params = [name, bio]
        client.query(bind_params(client, CREATE_AUTHOR_RESULT_SQL, query_params))
        ExecResult.new(client.affected_rows, client.last_id)
      end
    end

    def create_authors_batch(rows)
      with_client('create_authors_batch') do |client|
        rows.each do |args|
          query_params = [args.name, args.bio]
          client.query(bind_params(client, CREATE_AUTHORS_BATCH_SQL, query_params))
        end
        nil
      end
    end

    def get_author_batch(rows)
      with_client('get_author_batch') do |client|
        rows.map do |args|
          query_params = [args.id]
          result = client.query(bind_params(client, GET_AUTHOR_BATCH_SQL, query_params), as: :array, cast: true, cast_booleans: false)
          row = result.first
          row && GetAuthorBatchRow.new(row[0], row[1], row[2])
        end
      end
    end

    def list_authors_by_name_batch(rows)
      with_client('list_authors_by_name_batch') do |client|
        rows.map do |args|
          query_params = [args.name]
          result = client.query(bind_params(client, LIST_AUTHORS_BY_NAME_BATCH_SQL, query_params), as: :array, cast: true, cast_booleans: false)
          result.map do |row|
            ListAuthorsByNameBatchRow.new(row[0], row[1], row[2])
          end
        end
      end
    end

    def count_regressions_by_text(term:)
      with_client('count_regressions_by_text') do |client|
        query_params = [term, term]
        result = client.query(bind_params(client, COUNT_REGRESSIONS_BY_TEXT_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        row = result.first
        row && CountRegressionsByTextRow.new(row[0])
      end
    end

    # Like #count_regressions_by_text, but raises NotFound when there is no row.
    def count_regressions_by_text!(...)
      count_regressions_by_text(...) || raise(NotFound, 'CountRegressionsByText returned no row')
    end

    def list_regressions_by_ids(id:, id_2:, id_3:)
      with_client('list_regressions_by_ids') do |client|
        query_params = [id, id_2, id_3]
        result = client.query(bind_params(client, LIST_REGRESSIONS_BY_IDS_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          ListRegressionsByIdsRow.new(row[0], row[1], row[2])
        end
      end
    end

    def copy_regressions(rows)
      with_client('copy_regressions') do |client|
        ::Tempfile.create(['copy_regressions', '.csv']) do |file|
          rows.each do |row|
            file.write(csv_line(client, [row.order, row.note]))
          end
          file.flush
          load_data(client, "LOAD DATA LOCAL INFILE '#{client.escape(file.path)}' INTO TABLE `regressions` CHARACTER SET binary FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' ESCAPED BY '\\\\' LINES TERMINATED BY '\\n' (`order`, `note`)") if file.pos.positive?
        end
        nil
      end
    end

    def copy_regression_rows(rows)
      with_client('copy_regression_rows') do |client|
        ::Tempfile.create(['copy_regression_rows', '.csv']) do |file|
          rows.each do |row|
            file.write(csv_line(client, [row.id, row.order, row.note, row.payload]))
          end
          file.flush
          load_data(client, "LOAD DATA LOCAL INFILE '#{client.escape(file.path)}' INTO TABLE `regressions` CHARACTER SET binary FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' ESCAPED BY '\\\\' LINES TERMINATED BY '\\n' (`id`, `order`, `note`, `payload`)") if file.pos.positive?
        end
        nil
      end
    end

    def set_regression_step(step:, id:)
      with_client('set_regression_step') do |client|
        query_params = [step, id]
        client.query(bind_params(client, SET_REGRESSION_STEP_SQL, query_params))
        nil
      end
    end

    def get_regression_step(id:)
      with_client('get_regression_step') do |client|
        query_params = [id]
        result = client.query(bind_params(client, GET_REGRESSION_STEP_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        row = result.first
        row && GetRegressionStepRow.new(row[0])
      end
    end

    # Like #get_regression_step, but raises NotFound when there is no row.
    def get_regression_step!(...)
      get_regression_step(...) || raise(NotFound, 'GetRegressionStep returned no row')
    end

    def list_regression_rows
      with_client('list_regression_rows') do |client|
        result = client.query(bind_params(client, LIST_REGRESSION_ROWS_SQL, []), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          ListRegressionRowsRow.new(
            row[0],
            row[1],
            row[2],
            row[3],
            row[4],
            row[5],
            row[6],
            row[7]
          )
        end
      end
    end

    def list_authors_with_optional_book
      with_client('list_authors_with_optional_book') do |client|
        result = client.query(bind_params(client, LIST_AUTHORS_WITH_OPTIONAL_BOOK_SQL, []), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          ListAuthorsWithOptionalBookRow.new(
            row[0].nil? && row[1].nil? ? nil : Author.new(row[0], row[1], row[2]),
            row[3].nil? && row[4].nil? && row[5].nil? ? nil : Book.new(row[3], row[4], row[5], row[6])
          )
        end
      end
    end

    def truncate_regressions
      with_client('truncate_regressions') do |client|
        client.query(bind_params(client, TRUNCATE_REGRESSIONS_SQL, []))
        nil
      end
    end

    def copy_regression_types(rows)
      with_client('copy_regression_types') do |client|
        ::Tempfile.create(['copy_regression_types', '.csv']) do |file|
          rows.each do |row|
            file.write(csv_line(client, [row.id, row.code, row.doc, row.flags, row.amount]))
          end
          file.flush
          load_data(client, "LOAD DATA LOCAL INFILE '#{client.escape(file.path)}' INTO TABLE `regressions` CHARACTER SET binary FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' ESCAPED BY '\\\\' LINES TERMINATED BY '\\n' (`id`, `code`, @sqlc_v2, `flags`, `amount`) SET `doc` = CONVERT(@sqlc_v2 USING utf8mb4)") if file.pos.positive?
        end
        nil
      end
    end

    def copy_regressions_ignore(rows)
      with_client('copy_regressions_ignore') do |client|
        ::Tempfile.create(['copy_regressions_ignore', '.csv']) do |file|
          rows.each do |row|
            file.write(csv_line(client, [row.id, row.code]))
          end
          file.flush
          load_data(client, "LOAD DATA LOCAL INFILE '#{client.escape(file.path)}' IGNORE INTO TABLE `regressions` CHARACTER SET binary FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' ESCAPED BY '\\\\' LINES TERMINATED BY '\\n' (`id`, `code`)", strict: false) if file.pos.positive?
        end
        nil
      end
    end

    def copy_regressions_replace(rows)
      with_client('copy_regressions_replace') do |client|
        ::Tempfile.create(['copy_regressions_replace', '.csv']) do |file|
          rows.each do |row|
            file.write(csv_line(client, [row.id, row.code]))
          end
          file.flush
          load_data(client, "LOAD DATA LOCAL INFILE '#{client.escape(file.path)}' REPLACE INTO TABLE `regressions` CHARACTER SET binary FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' ESCAPED BY '\\\\' LINES TERMINATED BY '\\n' (`id`, `code`)") if file.pos.positive?
        end
        nil
      end
    end

    def create_regressions_batch(rows)
      with_client('create_regressions_batch') do |client|
        rows.each do |args|
          query_params = [args.id, args.code, args.flags, args.amount]
          client.query(bind_params(client, CREATE_REGRESSIONS_BATCH_SQL, query_params))
        end
        nil
      end
    end

    def count_regressions_by_codes(rows)
      with_client('count_regressions_by_codes') do |client|
        rows.map do |args|
          query_params = [args.code, args.code_2]
          result = client.query(bind_params(client, COUNT_REGRESSIONS_BY_CODES_SQL, query_params), as: :array, cast: true, cast_booleans: false)
          row = result.first
          row && CountRegressionsByCodesRow.new(row[0])
        end
      end
    end

    def find_authors_by_exact_name(name:)
      with_client('find_authors_by_exact_name') do |client|
        query_params = [name]
        result = client.query(bind_params(client, FIND_AUTHORS_BY_EXACT_NAME_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          FindAuthorsByExactNameRow.new(row[0])
        end
      end
    end

    # ?
    def get_author_with_question_marks(name:)
      with_client('get_author_with_question_marks') do |client|
        query_params = [name]
        result = client.query(bind_params(client, GET_AUTHOR_WITH_QUESTION_MARKS_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          GetAuthorWithQuestionMarksRow.new(row[0])
        end
      end
    end

    def insert_name_case(id:, class_:, end_:, hash:, method:, count:, camel_case:, http_server:, initialize:)
      with_client('insert_name_case') do |client|
        query_params = [
          id,
          class_,
          end_,
          hash,
          method,
          count,
          camel_case,
          http_server,
          initialize
        ]
        client.query(bind_params(client, INSERT_NAME_CASE_SQL, query_params))
        nil
      end
    end

    def get_name_case(id:, class_:, end_:, hash:, method:, count:, http_server:, camel_case:, initialize:)
      with_client('get_name_case') do |client|
        query_params = [
          id,
          class_,
          end_,
          hash,
          method,
          count,
          http_server,
          camel_case,
          initialize
        ]
        result = client.query(bind_params(client, GET_NAME_CASE_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        row = result.first
        row && GetNameCaseRow.new(
          row[0],
          row[1],
          row[2],
          row[3],
          row[4],
          row[5],
          row[6],
          row[7],
          row[8]
        )
      end
    end

    # Like #get_name_case, but raises NotFound when there is no row.
    def get_name_case!(...)
      get_name_case(...) || raise(NotFound, 'GetNameCase returned no row')
    end

    def get_http_server(id:)
      with_client('get_http_server') do |client|
        query_params = [id]
        result = client.query(bind_params(client, GET_HTTP_SERVER_SQL, query_params), as: :array, cast: true, cast_booleans: false)
        row = result.first
        row && GetHTTPServerRow.new(
          row[0],
          row[1],
          row[2],
          row[3],
          row[4],
          row[5],
          row[6],
          row[7],
          row[8]
        )
      end
    end

    # Like #get_http_server, but raises NotFound when there is no row.
    def get_http_server!(...)
      get_http_server(...) || raise(NotFound, 'GetHTTPServer returned no row')
    end

    def truncate_name_cases
      with_client('truncate_name_cases') do |client|
        client.query(bind_params(client, TRUNCATE_NAME_CASES_SQL, []))
        nil
      end
    end

    # MySQL table names are case-sensitive on Linux: LOAD DATA must use `MixedCaseCopies`, not sqlc's lowercased name.
    def copy_mixed_case_copies(rows)
      with_client('copy_mixed_case_copies') do |client|
        ::Tempfile.create(['copy_mixed_case_copies', '.csv']) do |file|
          rows.each do |row|
            file.write(csv_line(client, [row.id, row.somevalue]))
          end
          file.flush
          load_data(client, "LOAD DATA LOCAL INFILE '#{client.escape(file.path)}' INTO TABLE `MixedCaseCopies` CHARACTER SET binary FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' ESCAPED BY '\\\\' LINES TERMINATED BY '\\n' (`Id`, `SomeValue`)") if file.pos.positive?
        end
        nil
      end
    end

    def copy_mixed_case_copies_unquoted(rows)
      with_client('copy_mixed_case_copies_unquoted') do |client|
        ::Tempfile.create(['copy_mixed_case_copies_unquoted', '.csv']) do |file|
          rows.each do |row|
            file.write(csv_line(client, [row.somevalue, row.id]))
          end
          file.flush
          load_data(client, "LOAD DATA LOCAL INFILE '#{client.escape(file.path)}' INTO TABLE `MixedCaseCopies` CHARACTER SET binary FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '\"' ESCAPED BY '\\\\' LINES TERMINATED BY '\\n' (`SomeValue`, `Id`)") if file.pos.positive?
        end
        nil
      end
    end

    def list_mixed_case_copies
      with_client('list_mixed_case_copies') do |client|
        result = client.query(bind_params(client, LIST_MIXED_CASE_COPIES_SQL, []), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          ListMixedCaseCopiesRow.new(row[0], row[1])
        end
      end
    end

    def truncate_mixed_case_copies
      with_client('truncate_mixed_case_copies') do |client|
        client.query(bind_params(client, TRUNCATE_MIXED_CASE_COPIES_SQL, []))
        nil
      end
    end

    def get_unnamed_columns
      with_client('get_unnamed_columns') do |client|
        result = client.query(bind_params(client, GET_UNNAMED_COLUMNS_SQL, []), as: :array, cast: true, cast_booleans: false)
        row = result.first
        row && GetUnnamedColumnsRow.new(row[0], row[1])
      end
    end

    # Like #get_unnamed_columns, but raises NotFound when there is no row.
    def get_unnamed_columns!(...)
      get_unnamed_columns(...) || raise(NotFound, 'GetUnnamedColumns returned no row')
    end

    def get_quoted_alias
      with_client('get_quoted_alias') do |client|
        result = client.query(bind_params(client, GET_QUOTED_ALIAS_SQL, []), as: :array, cast: true, cast_booleans: false)
        row = result.first
        row && GetQuotedAliasRow.new(row[0])
      end
    end

    # Like #get_quoted_alias, but raises NotFound when there is no row.
    def get_quoted_alias!(...)
      get_quoted_alias(...) || raise(NotFound, 'GetQuotedAlias returned no row')
    end

    def get_authors_not_in_ids(ids:)
      with_client('get_authors_not_in_ids') do |client|
        query_params = [*ids]
        sql = GET_AUTHORS_NOT_IN_IDS_SQL.gsub('/*SLICE:ids*/?', slice_placeholders(ids))
        result = client.query(bind_params(client, sql, query_params), as: :array, cast: true, cast_booleans: false)
        result.map do |row|
          GetAuthorsNotInIdsRow.new(row[0], row[1], row[2])
        end
      end
    end

    def create_exception
      with_client('create_exception') do |client|
        client.query(bind_params(client, CREATE_EXCEPTION_SQL, []))
        nil
      end
    end

    def count_exceptions
      with_client('count_exceptions') do |client|
        result = client.query(bind_params(client, COUNT_EXCEPTIONS_SQL, []), as: :array, cast: true, cast_booleans: false)
        row = result.first
        row && CountExceptionsRow.new(row[0])
      end
    end

    # Like #count_exceptions, but raises NotFound when there is no row.
    def count_exceptions!(...)
      count_exceptions(...) || raise(NotFound, 'CountExceptions returned no row')
    end

    def truncate_exceptions
      with_client('truncate_exceptions') do |client|
        client.query(bind_params(client, TRUNCATE_EXCEPTIONS_SQL, []))
        nil
      end
    end

    # rubocop:disable Naming/PredicatePrefix
    def has_authors
      with_client('has_authors') do |client|
        result = client.query(bind_params(client, HAS_AUTHORS_SQL, []), as: :array, cast: true, cast_booleans: false)
        row = result.first
        row && HasAuthorsRow.new(row[0])
      end
    end
    # rubocop:enable Naming/PredicatePrefix

    # rubocop:disable Naming/PredicatePrefix
    # Like #has_authors, but raises NotFound when there is no row.
    def has_authors!(...)
      has_authors(...) || raise(NotFound, 'HasAuthors returned no row')
    end
    # rubocop:enable Naming/PredicatePrefix

    private

    def instrument(name)
      return yield unless @logger

      started = ::Process.clock_gettime(::Process::CLOCK_MONOTONIC)
      begin
        yield
      ensure
        elapsed = (::Process.clock_gettime(::Process::CLOCK_MONOTONIC) - started) * 1000
        @logger.debug { format('%<class>s#%<name>s (%<ms>.1fms)', class: self.class.name, name: name, ms: elapsed) }
      end
    end

    def with_client(name)
      instrument(name) do
        @db.with do |client|
          client.extend(ConnectionState) unless client.is_a?(ConnectionState)
          if client.inherited?
            client.close
            @db.discard_current_connection if @db.respond_to?(:discard_current_connection)
            raise ::Mysql2::Error::ConnectionError, 'this Mysql2::Client was opened by another process (inherited through fork): ' \
                                                    'open clients in the process that uses them, or use a ConnectionPool'
          end
          begin
            yield client
          rescue ::Exception # rubocop:disable Lint/RescueException
            # a connection closed by the server (restart, KILL, wait_timeout) or by mysql2 when a running query
            # was interrupted (Async task stopped, Thread#raise) is replaced by the pool
            @db.discard_current_connection if client.closed? && @db.respond_to?(:discard_current_connection)
            raise
          ensure
            # Thread#kill skips rescue: a query it interrupted leaves the client waiting for a result nobody reads
            # (every later query raises) and its transaction open. Closing it makes the server roll back once the
            # statement ends, and the pool replaces it.
            if ::Thread.current.status == 'aborting' && (client.query_running? || client.closed?)
              client.close
              @db.discard_current_connection if @db.respond_to?(:discard_current_connection)
            end
          end
        end
      end
    end

    # A copy of this query object whose queries run on the transaction's connection.
    def bound_to(connection) = dup.tap { |tx| tx.instance_variable_set(:@db, connection) }

    def quote(client, value)
      case value
      when ::NilClass then 'NULL'
      when ::Symbol then quote(client, value.to_s)
      when ::TrueClass then 'TRUE'
      when ::FalseClass then 'FALSE'
      when ::Integer then value.to_s
      when ::Float
        raise ::ArgumentError, 'cannot bind a non-finite Float to MySQL' unless value.finite?

        value.to_s
      when ::BigDecimal
        raise ::ArgumentError, 'cannot bind a non-finite BigDecimal to MySQL' unless value.finite?

        value.to_s('F')
      when ::DateTime, ::Time
        "'#{mysql_time(client, value)}'"
      when ::Date
        "'#{value.strftime('%Y-%m-%d')}'"
      when ::String
        if value.encoding == ::Encoding::BINARY || !value.valid_encoding?
          "X'#{value.unpack1('H*')}'"
        else
          "'#{client.escape(value)}'"
        end
      else
        raise ::TypeError, "cannot bind #{value.class} to MySQL"
      end
    end

    def mysql_time(client, value)
      time = value.is_a?(::DateTime) ? value.to_time : value
      time = client.query_options[:database_timezone] == :utc ? time.getutc : time.getlocal
      time.strftime('%Y-%m-%d %H:%M:%S.%6N')
    end

    def bind_params(client, sql, params)
      output = +''
      index = 0
      parameter = 0
      while index < sql.length
        char = sql[index]
        if ["'", '"', '`'].include?(char)
          quote_char = char
          start = index
          index += 1
          while index < sql.length
            if sql[index] == '\\'
              index += 2
            elsif sql[index] == quote_char
              if sql[index + 1] == quote_char
                index += 2
              else
                index += 1
                break
              end
            else
              index += 1
            end
          end
          output << sql[start...index]
        elsif sql[index, 2] == '--' && (sql[index + 2].nil? || sql[index + 2].match?(/\s/))
          finish = sql.index("\n", index) || sql.length
          output << sql[index...finish]
          index = finish
        elsif char == '#'
          finish = sql.index("\n", index) || sql.length
          output << sql[index...finish]
          index = finish
        elsif sql[index, 2] == '/*'
          finish = sql.index('*/', index + 2)
          finish = finish ? finish + 2 : sql.length
          output << sql[index...finish]
          index = finish
        elsif char == '?'
          raise ::ArgumentError, 'more MySQL placeholders than parameters' if parameter >= params.length

          output << quote(client, params[parameter])
          parameter += 1
          index += 1
        else
          output << char
          index += 1
        end
      end
      raise ::ArgumentError, 'fewer MySQL placeholders than parameters' unless parameter == params.length

      output
    end

    # Formats one row for LOAD DATA ... FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"' ESCAPED BY '\\'.
    def csv_line(client, values)
      fields = values.map do |value|
        case value
        when nil then '\N'
        when true then '1'
        when false then '0'
        when ::Time, ::DateTime then mysql_time(client, value)
        else %("#{value.to_s.b.gsub('\\') { '\\\\' }.gsub('"', '""').gsub("\x1A") { '\Z' }}")
        end
      end
      "#{fields.join(',')}\n"
    end

    # Runs LOAD DATA in a transaction (a savepoint inside #transaction): all rows or none, and (strict) an error
    # instead of the warnings LOAD DATA LOCAL gives for duplicate keys and invalid values.
    def load_data(client, sql, strict: true)
      outermost = !client.in_transaction
      client.query(outermost ? 'BEGIN' : 'SAVEPOINT sqlc_copy')
      done = false
      begin
        client.query(sql)
        if strict && !client.warning_count.zero?
          warnings = client.query('SHOW WARNINGS', as: :array).reject { |level, *| level == 'Note' }
          raise ::Mysql2::Error, "LOAD DATA: #{warnings.map { |w| w[2] }.join('; ')}" unless warnings.empty?
        end
        done = true
      ensure
        if outermost
          client.query(done ? 'COMMIT' : 'ROLLBACK')
        elsif !client.rolled_back_by # a deadlock rolled the whole transaction back, its savepoint too
          client.query(done ? 'RELEASE SAVEPOINT sqlc_copy' : 'ROLLBACK TO SAVEPOINT sqlc_copy')
        end
      end
    end

    def slice_placeholders(values)
      values.empty? ? 'SELECT NULL WHERE FALSE' : ::Array.new(values.size, '?').join(', ')
    end
  end
end