mysqldb

type Adapter struct {
	*Queries
	// contains filtered or unexported fields
}

type AddNarInfoReferenceParams struct {
	NarInfoID int64
	Reference string
}

type AddNarInfoSignatureParams struct {
	NarInfoID int64
	Signature string
}

type Chunk struct {
	ID             int64
	Hash           string
	Size           uint32
	CompressedSize uint32
	CreatedAt      time.Time
	UpdatedAt      sql.NullTime
}

type Config struct {
	ID        int64
	Key       string
	Value     string
	CreatedAt time.Time
	UpdatedAt sql.NullTime
}

type CreateChunkParams struct {
	Hash           string
	Size           uint32
	CompressedSize uint32
}

type CreateConfigParams struct {
	Key   string
	Value string
}

type CreateNarFileParams struct {
	Hash        string
	Compression string
	Query       string
	FileSize    uint64
	TotalChunks int64
}

type CreateNarInfoParams struct {
	Hash        string
	StorePath   sql.NullString
	URL         sql.NullString
	Compression sql.NullString
	FileHash    sql.NullString
	FileSize    sql.NullInt64
	NarHash     sql.NullString
	NarSize     sql.NullInt64
	Deriver     sql.NullString
	System      sql.NullString
	Ca          sql.NullString
}

type DBTX interface {
	ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
	PrepareContext(context.Context, string) (*sql.Stmt, error)
	QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
	QueryRowContext(context.Context, string, ...interface{}) *sql.Row
}

type DeleteNarFileByHashParams struct {
	Hash        string
	Compression string
	Query       string
}

type GetAllNarFilesRow struct {
	ID                int64
	Hash              string
	Compression       string
	Query             string
	FileSize          uint64
	TotalChunks       int64
	ChunkingStartedAt sql.NullTime
	CreatedAt         time.Time
	UpdatedAt         sql.NullTime
	LastAccessedAt    sql.NullTime
	VerifiedAt        sql.NullTime
}

type GetChunkByNarFileIDAndIndexParams struct {
	NarFileID  int64
	ChunkIndex int64
}

type GetChunkByNarFileIDAndIndexRow struct {
	ID        int64
	Hash      string
	Size      uint32
	CreatedAt time.Time
	UpdatedAt sql.NullTime
}

type GetChunksByNarFileIDFromIndexParams struct {
	NarFileID  int64
	ChunkIndex int64
	Limit      int32
}

type GetChunksByNarFileIDFromIndexRow struct {
	ID        int64
	Hash      string
	Size      uint32
	CreatedAt time.Time
	UpdatedAt sql.NullTime
}

type GetNarFileByHashAndCompressionAndQueryParams struct {
	Hash        string
	Compression string
	Query       string
}

type GetNarFileByHashAndCompressionAndQueryRow struct {
	ID                int64
	Hash              string
	Compression       string
	FileSize          uint64
	Query             string
	CreatedAt         time.Time
	UpdatedAt         sql.NullTime
	LastAccessedAt    sql.NullTime
	TotalChunks       int64
	ChunkingStartedAt sql.NullTime
	VerifiedAt        sql.NullTime
}

type GetNarFileByNarInfoIDRow struct {
	ID                int64
	Hash              string
	Compression       string
	FileSize          uint64
	Query             string
	CreatedAt         time.Time
	UpdatedAt         sql.NullTime
	LastAccessedAt    sql.NullTime
	TotalChunks       int64
	ChunkingStartedAt sql.NullTime
	VerifiedAt        sql.NullTime
}

type GetNarFilesToChunkRow struct {
	ID          int64
	Hash        string
	Compression string
	Query       string
	FileSize    uint64
}

type GetNarInfoURLByNarFileHashParams struct {
	Hash        string
	Compression string
	Query       string
}

type GetOldCompressedNarFilesRow struct {
	ID          int64
	Hash        string
	Compression string
	Query       string
	FileSize    uint64
	CreatedAt   time.Time
}

type GetOrphanedChunksRow struct {
	ID        int64
	Hash      string
	Size      uint32
	CreatedAt time.Time
	UpdatedAt sql.NullTime
}

type GetOrphanedNarFilesRow struct {
	ID                int64
	Hash              string
	Compression       string
	FileSize          uint64
	Query             string
	CreatedAt         time.Time
	UpdatedAt         sql.NullTime
	LastAccessedAt    sql.NullTime
	TotalChunks       int64
	ChunkingStartedAt sql.NullTime
	VerifiedAt        sql.NullTime
}

type GetStuckNarFilesParams struct {
	CutoffTime time.Time
	Limit      int32
}

type GetStuckNarFilesRow struct {
	ID          int64
	Hash        string
	Compression string
	Query       string
	FileSize    uint64
}

type LinkNarFileToChunkParams struct {
	NarFileID  int64
	ChunkID    int64
	ChunkIndex int64
}

type LinkNarFileToChunksParams struct {
	NarFileID  int64
	ChunkID    int64
	ChunkIndex int64
}

type LinkNarInfoToNarFileParams struct {
	NarInfoID int64
	NarFileID int64
}

type LinkNarInfosByURLToNarFileParams struct {
	NarFileID int64
	URL       sql.NullString
}

type NarFile struct {
	ID                int64
	Hash              string
	Compression       string
	FileSize          uint64
	CreatedAt         time.Time
	UpdatedAt         sql.NullTime
	LastAccessedAt    sql.NullTime
	Query             string
	TotalChunks       int64
	ChunkingStartedAt sql.NullTime
	VerifiedAt        sql.NullTime
}

type NarFileChunk struct {
	NarFileID  int64
	ChunkID    int64
	ChunkIndex int64
}

type NarInfo struct {
	ID             int64
	Hash           string
	CreatedAt      time.Time
	UpdatedAt      sql.NullTime
	LastAccessedAt sql.NullTime
	StorePath      sql.NullString
	URL            sql.NullString
	Compression    sql.NullString
	FileHash       sql.NullString
	FileSize       sql.NullInt64
	NarHash        sql.NullString
	NarSize        sql.NullInt64
	Deriver        sql.NullString
	System         sql.NullString
	Ca             sql.NullString
}

type NarinfoNarFile struct {
	NarInfoID int64
	NarFileID int64
}

type NarinfoReference struct {
	NarInfoID int64
	Reference string
}

type NarinfoSignature struct {
	NarInfoID int64
	Signature string
}

type Querier interface {
	//AddNarInfoReference
	//
	//  INSERT IGNORE INTO narinfo_references (
	//      narinfo_id, reference
	//  ) VALUES (
	//      ?, ?
	//  )
	AddNarInfoReference(ctx context.Context, arg AddNarInfoReferenceParams) error
	//AddNarInfoSignature
	//
	//  INSERT IGNORE INTO narinfo_signatures (
	//      narinfo_id, signature
	//  ) VALUES (
	//      ?, ?
	//  )
	AddNarInfoSignature(ctx context.Context, arg AddNarInfoSignatureParams) error
	//ClearNarFileChunkingStarted
	//
	//  UPDATE nar_files
	//  SET chunking_started_at = NULL, updated_at = CURRENT_TIMESTAMP
	//  WHERE id = ?
	ClearNarFileChunkingStarted(ctx context.Context, id int64) error
	//CreateChunk
	//
	//  INSERT INTO chunks (
	//      hash, size, compressed_size
	//  ) VALUES (
	//      ?, ?, ?
	//  )
	//  ON DUPLICATE KEY UPDATE
	//      id = LAST_INSERT_ID(id),
	//      updated_at = CURRENT_TIMESTAMP
	CreateChunk(ctx context.Context, arg CreateChunkParams) (sql.Result, error)
	//CreateConfig
	//
	//  INSERT INTO config (
	//      `key`, value
	//  ) VALUES (
	//      ?, ?
	//  )
	CreateConfig(ctx context.Context, arg CreateConfigParams) (sql.Result, error)
	//CreateNarFile
	//
	//  INSERT INTO nar_files (
	//      hash, compression, `query`, file_size, total_chunks
	//  ) VALUES (
	//      ?, ?, ?, ?, ?
	//  )
	//  ON DUPLICATE KEY UPDATE
	//      id = LAST_INSERT_ID(id),
	//      updated_at = CURRENT_TIMESTAMP
	CreateNarFile(ctx context.Context, arg CreateNarFileParams) (sql.Result, error)
	//CreateNarInfo
	//
	//  INSERT INTO narinfos (
	//      hash, store_path, url, compression, file_hash, file_size, nar_hash, nar_size, deriver, system, ca
	//  ) VALUES (
	//      ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
	//  )
	//  ON DUPLICATE KEY UPDATE
	//      id = LAST_INSERT_ID(id),
	//      store_path = IF(url IS NULL, VALUES(store_path), store_path),
	//      compression = IF(url IS NULL, VALUES(compression), compression),
	//      file_hash = IF(url IS NULL, VALUES(file_hash), file_hash),
	//      file_size = IF(url IS NULL, VALUES(file_size), file_size),
	//      nar_hash = IF(url IS NULL, VALUES(nar_hash), nar_hash),
	//      nar_size = IF(url IS NULL, VALUES(nar_size), nar_size),
	//      deriver = IF(url IS NULL, VALUES(deriver), deriver),
	//      system = IF(url IS NULL, VALUES(system), system),
	//      ca = IF(url IS NULL, VALUES(ca), ca),
	//      url = IF(url IS NULL, VALUES(url), url),
	//      updated_at = IF(url IS NULL, CURRENT_TIMESTAMP, updated_at)
	CreateNarInfo(ctx context.Context, arg CreateNarInfoParams) (sql.Result, error)
	//DeleteChunkByID
	//
	//  DELETE FROM chunks
	//  WHERE id = ?
	DeleteChunkByID(ctx context.Context, id int64) error
	//DeleteNarFileByHash
	//
	//  DELETE FROM nar_files
	//  WHERE hash = ? AND compression = ? AND `query` = ?
	DeleteNarFileByHash(ctx context.Context, arg DeleteNarFileByHashParams) (int64, error)
	//DeleteNarFileByID
	//
	//  DELETE FROM nar_files
	//  WHERE id = ?
	DeleteNarFileByID(ctx context.Context, id int64) (int64, error)
	//DeleteNarFileChunksByNarFileID
	//
	//  DELETE FROM nar_file_chunks
	//  WHERE nar_file_id = ?
	DeleteNarFileChunksByNarFileID(ctx context.Context, narFileID int64) error
	//DeleteNarInfoByHash
	//
	//  DELETE FROM narinfos
	//  WHERE hash = ?
	DeleteNarInfoByHash(ctx context.Context, hash string) (int64, error)
	//DeleteNarInfoByID
	//
	//  DELETE FROM narinfos
	//  WHERE id = ?
	DeleteNarInfoByID(ctx context.Context, id int64) (int64, error)
	//DeleteOrphanedChunks
	//
	//  DELETE FROM chunks
	//  WHERE NOT EXISTS (
	//      SELECT 1
	//      FROM nar_file_chunks
	//      WHERE chunk_id = chunks.id
	//  )
	DeleteOrphanedChunks(ctx context.Context) (int64, error)
	//DeleteOrphanedNarFiles
	//
	//  DELETE FROM nar_files
	//  WHERE id NOT IN (
	//      SELECT DISTINCT nar_file_id
	//      FROM narinfo_nar_files
	//  )
	DeleteOrphanedNarFiles(ctx context.Context) (int64, error)
	// Returns all chunks for storage existence verification (CDC mode).
	//
	//  SELECT id, hash, size, compressed_size, created_at, updated_at
	//  FROM chunks
	GetAllChunks(ctx context.Context) ([]Chunk, error)
	// Returns all nar_files for storage existence verification.
	//
	//  SELECT id, hash, compression, `query`, file_size, total_chunks, chunking_started_at, created_at, updated_at, last_accessed_at, verified_at
	//  FROM nar_files
	GetAllNarFiles(ctx context.Context) ([]GetAllNarFilesRow, error)
	//GetChunkByHash
	//
	//  SELECT id, hash, size, compressed_size, created_at, updated_at
	//  FROM chunks
	//  WHERE hash = ?
	GetChunkByHash(ctx context.Context, hash string) (Chunk, error)
	//GetChunkByNarFileIDAndIndex
	//
	//  SELECT c.id, c.hash, c.size, c.created_at, c.updated_at
	//  FROM chunks c
	//  INNER JOIN nar_file_chunks nfc ON c.id = nfc.chunk_id
	//  WHERE nfc.nar_file_id = ? AND nfc.chunk_index = ?
	GetChunkByNarFileIDAndIndex(ctx context.Context, arg GetChunkByNarFileIDAndIndexParams) (GetChunkByNarFileIDAndIndexRow, error)
	//GetChunkCount
	//
	//  SELECT CAST(COUNT(*) AS SIGNED) AS count
	//  FROM chunks
	GetChunkCount(ctx context.Context) (int64, error)
	//GetChunksByNarFileID
	//
	//  SELECT c.id, c.hash, c.size, c.compressed_size, c.created_at, c.updated_at
	//  FROM chunks c
	//  INNER JOIN nar_file_chunks nfc ON c.id = nfc.chunk_id
	//  WHERE nfc.nar_file_id = ?
	//  ORDER BY nfc.chunk_index
	GetChunksByNarFileID(ctx context.Context, narFileID int64) ([]Chunk, error)
	//GetChunksByNarFileIDFromIndex
	//
	//  SELECT c.id, c.hash, c.size, c.created_at, c.updated_at
	//  FROM chunks c
	//  INNER JOIN nar_file_chunks nfc ON c.id = nfc.chunk_id
	//  WHERE nfc.nar_file_id = ? AND nfc.chunk_index >= ?
	//  ORDER BY nfc.chunk_index
	//  LIMIT ?
	GetChunksByNarFileIDFromIndex(ctx context.Context, arg GetChunksByNarFileIDFromIndexParams) ([]GetChunksByNarFileIDFromIndexRow, error)
	//GetConfigByKey
	//
	//  SELECT id, `key`, value, created_at, updated_at
	//  FROM config
	//  WHERE `key` = ?
	GetConfigByKey(ctx context.Context, key string) (Config, error)
	// NOTE: This query uses a correlated subquery which is not optimal for performance.
	// The ideal implementation would use a window function (SUM OVER), but sqlc v1.30.0
	// does not properly support filtering on window function results in subqueries.
	// Gets the least-used narinfos up to a certain total file size (accounting for their nar_files).
	//
	//  SELECT ni1.id, ni1.hash, ni1.created_at, ni1.updated_at, ni1.last_accessed_at, ni1.store_path, ni1.url, ni1.compression, ni1.file_hash, ni1.file_size, ni1.nar_hash, ni1.nar_size, ni1.deriver, ni1.`system`, ni1.ca
	//  FROM narinfos ni1
	//  WHERE (
	//      SELECT COALESCE(SUM(nf.file_size), 0)
	//      FROM nar_files nf
	//      WHERE nf.id IN (
	//          SELECT DISTINCT nnf.nar_file_id
	//          FROM narinfo_nar_files nnf
	//          INNER JOIN narinfos ni2 ON nnf.narinfo_id = ni2.id
	//          WHERE ni2.last_accessed_at < ni1.last_accessed_at
	//              OR (ni2.last_accessed_at = ni1.last_accessed_at AND ni2.id <= ni1.id)
	//      )
	//  ) <= ?
	GetLeastUsedNarInfos(ctx context.Context, fileSize uint64) ([]NarInfo, error)
	// Get all narinfo hashes that have a URL (migrated).
	//
	//  SELECT hash
	//  FROM narinfos
	//  WHERE url IS NOT NULL
	GetMigratedNarInfoHashes(ctx context.Context) ([]string, error)
	//GetNarFileByHashAndCompressionAndQuery
	//
	//  SELECT id, hash, compression, file_size, `query`, created_at, updated_at, last_accessed_at, total_chunks, chunking_started_at, verified_at
	//  FROM nar_files
	//  WHERE hash = ? AND compression = ? AND `query` = ?
	GetNarFileByHashAndCompressionAndQuery(ctx context.Context, arg GetNarFileByHashAndCompressionAndQueryParams) (GetNarFileByHashAndCompressionAndQueryRow, error)
	//GetNarFileByNarInfoID
	//
	//  SELECT nf.id, nf.hash, nf.compression, nf.file_size, nf.`query`, nf.created_at, nf.updated_at, nf.last_accessed_at, nf.total_chunks, nf.chunking_started_at, nf.verified_at
	//  FROM nar_files nf
	//  INNER JOIN narinfo_nar_files nnf ON nf.id = nnf.nar_file_id
	//  WHERE nnf.narinfo_id = ?
	GetNarFileByNarInfoID(ctx context.Context, narinfoID int64) (GetNarFileByNarInfoIDRow, error)
	//GetNarFileCount
	//
	//  SELECT CAST(COUNT(*) AS SIGNED) AS count
	//  FROM nar_files
	GetNarFileCount(ctx context.Context) (int64, error)
	// Get all NAR files that are not yet chunked.
	//
	//  SELECT id, hash, compression, `query`, file_size
	//  FROM nar_files
	//  WHERE total_chunks = 0
	//  ORDER BY id
	GetNarFilesToChunk(ctx context.Context) ([]GetNarFilesToChunkRow, error)
	// Get the count of NAR files that are not yet chunked.
	//
	//  SELECT COUNT(*)
	//  FROM nar_files
	//  WHERE total_chunks = 0
	GetNarFilesToChunkCount(ctx context.Context) (int64, error)
	//GetNarInfoByHash
	//
	//  SELECT id, hash, created_at, updated_at, last_accessed_at, store_path, url, compression, file_hash, file_size, nar_hash, nar_size, deriver, `system`, ca
	//  FROM narinfos
	//  WHERE hash = ?
	GetNarInfoByHash(ctx context.Context, hash string) (NarInfo, error)
	//GetNarInfoCount
	//
	//  SELECT CAST(COUNT(*) AS SIGNED) AS count
	//  FROM narinfos
	GetNarInfoCount(ctx context.Context) (int64, error)
	//GetNarInfoHashByNarURL
	//
	//  SELECT hash
	//  FROM narinfos
	//  WHERE url = ?
	//  LIMIT 1
	GetNarInfoHashByNarURL(ctx context.Context, url sql.NullString) (string, error)
	//GetNarInfoHashesByURL
	//
	//  SELECT hash
	//  FROM narinfos
	//  WHERE url = ?
	GetNarInfoHashesByURL(ctx context.Context, url sql.NullString) ([]string, error)
	//GetNarInfoReferences
	//
	//  SELECT reference
	//  FROM narinfo_references
	//  WHERE narinfo_id = ?
	GetNarInfoReferences(ctx context.Context, narinfoID int64) ([]string, error)
	//GetNarInfoSignatures
	//
	//  SELECT signature
	//  FROM narinfo_signatures
	//  WHERE narinfo_id = ?
	GetNarInfoSignatures(ctx context.Context, narinfoID int64) ([]string, error)
	//GetNarInfoURLByNarFileHash
	//
	//  SELECT ni.url
	//  FROM narinfos ni
	//  INNER JOIN narinfo_nar_files nnf ON ni.id = nnf.narinfo_id
	//  INNER JOIN nar_files nf ON nf.id = nnf.nar_file_id
	//  WHERE nf.hash = ? AND nf.compression = ? AND nf.query = ?
	//  LIMIT 1
	GetNarInfoURLByNarFileHash(ctx context.Context, arg GetNarInfoURLByNarFileHashParams) (sql.NullString, error)
	// Returns narinfos that have no linked nar_file entries.
	//
	//  SELECT ni.id, ni.hash, ni.created_at, ni.updated_at, ni.last_accessed_at, ni.store_path, ni.url, ni.compression, ni.file_hash, ni.file_size, ni.nar_hash, ni.nar_size, ni.deriver, ni.`system`, ni.ca
	//  FROM narinfos ni
	//  WHERE NOT EXISTS (
	//      SELECT 1 FROM narinfo_nar_files nnf WHERE nnf.narinfo_id = ni.id
	//  )
	GetNarInfosWithoutNarFiles(ctx context.Context) ([]NarInfo, error)
	//GetNarTotalSize
	//
	//  SELECT CAST(COALESCE(SUM(file_size), 0) AS SIGNED) AS total_size
	//  FROM nar_files
	GetNarTotalSize(ctx context.Context) (int64, error)
	// Get compressed NAR files that have been replaced by chunked versions and are ready for deletion.
	// This is used by the CDC delayed cleanup job to find old compressed files after chunking.
	//
	//  SELECT old_nf.id, old_nf.hash, old_nf.compression, old_nf.query, old_nf.file_size, old_nf.created_at
	//  FROM nar_files old_nf
	//  JOIN nar_files new_nf ON old_nf.hash = new_nf.hash
	//  WHERE old_nf.total_chunks = 0
	//    AND old_nf.compression != 'none'
	//    AND new_nf.compression = 'none'
	//    AND new_nf.total_chunks > 0
	//    AND old_nf.created_at < ?
	GetOldCompressedNarFiles(ctx context.Context, cutoffTime time.Time) ([]GetOldCompressedNarFilesRow, error)
	//GetOrphanedChunks
	//
	//  SELECT c.id, c.hash, c.size, c.created_at, c.updated_at
	//  FROM chunks c
	//  LEFT JOIN nar_file_chunks nfc ON c.id = nfc.chunk_id
	//  WHERE nfc.chunk_id IS NULL
	GetOrphanedChunks(ctx context.Context) ([]GetOrphanedChunksRow, error)
	// Find files that have no relationship to any narinfo
	//
	//  SELECT nf.id, nf.hash, nf.compression, nf.file_size, nf.`query`, nf.created_at, nf.updated_at, nf.last_accessed_at, nf.total_chunks, nf.chunking_started_at, nf.verified_at
	//  FROM nar_files nf
	//  LEFT JOIN narinfo_nar_files ninf ON nf.id = ninf.nar_file_id
	//  WHERE ninf.narinfo_id IS NULL
	GetOrphanedNarFiles(ctx context.Context) ([]GetOrphanedNarFilesRow, error)
	// Get NAR files that are stuck (not chunked, no active chunking, and older than the given age).
	// This is used by the CDC lazy recovery job to find NARs that failed to chunk due to restart.
	//
	//  SELECT id, hash, compression, query, file_size
	//  FROM nar_files
	//  WHERE total_chunks = 0
	//    AND chunking_started_at IS NULL
	//    AND created_at < ?
	//  ORDER BY id
	//  LIMIT ?
	GetStuckNarFiles(ctx context.Context, arg GetStuckNarFilesParams) ([]GetStuckNarFilesRow, error)
	// Get all narinfo hashes that have no URL (unmigrated).
	//
	//  SELECT hash
	//  FROM narinfos
	//  WHERE url IS NULL
	GetUnmigratedNarInfoHashes(ctx context.Context) ([]string, error)
	// Returns true if any nar_file has total_chunks > 0 (used for CDC auto-detection).
	//
	//  SELECT EXISTS(SELECT 1 FROM nar_files WHERE total_chunks > 0) AS "exists"
	HasAnyChunkedNarFiles(ctx context.Context) (bool, error)
	//LinkNarFileToChunk
	//
	//  INSERT IGNORE INTO nar_file_chunks (
	//      nar_file_id, chunk_id, chunk_index
	//  ) VALUES (
	//      ?, ?, ?
	//  )
	LinkNarFileToChunk(ctx context.Context, arg LinkNarFileToChunkParams) error
	// @bulk-for LinkNarFileToChunk
	//
	//  INSERT IGNORE INTO nar_file_chunks (
	//      nar_file_id, chunk_id, chunk_index
	//  ) VALUES (
	//      ?, ?, ?
	//  )
	LinkNarFileToChunks(ctx context.Context, arg LinkNarFileToChunksParams) error
	//LinkNarInfoToNarFile
	//
	//  INSERT INTO narinfo_nar_files (
	//      narinfo_id, nar_file_id
	//  ) VALUES (
	//      ?, ?
	//  )
	//  ON DUPLICATE KEY UPDATE narinfo_id = narinfo_id
	LinkNarInfoToNarFile(ctx context.Context, arg LinkNarInfoToNarFileParams) error
	//LinkNarInfosByURLToNarFile
	//
	//  INSERT IGNORE INTO narinfo_nar_files (narinfo_id, nar_file_id)
	//  SELECT id, ?
	//  FROM narinfos
	//  WHERE url = ?
	LinkNarInfosByURLToNarFile(ctx context.Context, arg LinkNarInfosByURLToNarFileParams) error
	//SetConfig
	//
	//  INSERT INTO config (
	//      `key`, value
	//  ) VALUES (
	//      ?, ?
	//  )
	//  ON DUPLICATE KEY UPDATE
	//      value = VALUES(value),
	//      updated_at = CURRENT_TIMESTAMP
	SetConfig(ctx context.Context, arg SetConfigParams) error
	//SetNarFileChunkingStarted
	//
	//  UPDATE nar_files
	//  SET chunking_started_at = CURRENT_TIMESTAMP, updated_at = CURRENT_TIMESTAMP
	//  WHERE id = ?
	SetNarFileChunkingStarted(ctx context.Context, id int64) error
	//TouchNarFile
	//
	//  UPDATE nar_files
	//  SET
	//      last_accessed_at = CURRENT_TIMESTAMP,
	//      updated_at = CURRENT_TIMESTAMP
	//  WHERE hash = ? AND compression = ? AND `query` = ?
	TouchNarFile(ctx context.Context, arg TouchNarFileParams) (int64, error)
	//TouchNarInfo
	//
	//  UPDATE narinfos
	//  SET
	//      last_accessed_at = CURRENT_TIMESTAMP,
	//      updated_at = CURRENT_TIMESTAMP
	//  WHERE hash = ?
	TouchNarInfo(ctx context.Context, hash string) (int64, error)
	//UpdateNarFileFileSize
	//
	//  UPDATE nar_files
	//  SET file_size = ?, updated_at = CURRENT_TIMESTAMP
	//  WHERE id = ?
	UpdateNarFileFileSize(ctx context.Context, arg UpdateNarFileFileSizeParams) error
	//UpdateNarFileTotalChunks
	//
	//  UPDATE nar_files
	//  SET total_chunks = ?, file_size = ?, updated_at = CURRENT_TIMESTAMP, chunking_started_at = NULL
	//  WHERE id = ?
	UpdateNarFileTotalChunks(ctx context.Context, arg UpdateNarFileTotalChunksParams) error
	//UpdateNarFileVerifiedAt
	//
	//  UPDATE nar_files
	//  SET verified_at = CURRENT_TIMESTAMP
	//  WHERE id = ?
	UpdateNarFileVerifiedAt(ctx context.Context, id int64) error
	//UpdateNarInfo
	//
	//  UPDATE narinfos
	//  SET
	//      store_path = ?,
	//      url = ?,
	//      compression = ?,
	//      file_hash = ?,
	//      file_size = ?,
	//      nar_hash = ?,
	//      nar_size = ?,
	//      deriver = ?,
	//      system = ?,
	//      ca = ?,
	//      updated_at = CURRENT_TIMESTAMP
	//  WHERE hash = ?
	UpdateNarInfo(ctx context.Context, arg UpdateNarInfoParams) (sql.Result, error)
	// Update narinfo compression and URL after CDC migration.
	//
	//  UPDATE narinfos
	//  SET compression = ?, url = ?, updated_at = CURRENT_TIMESTAMP
	//  WHERE url = ?
	UpdateNarInfoCompressionAndURL(ctx context.Context, arg UpdateNarInfoCompressionAndURLParams) (int64, error)
	// Update narinfo compression, file_size, file_hash and URL after CDC migration.
	//
	//  UPDATE narinfos
	//  SET
	//      compression = ?,
	//      url = ?,
	//      file_size = ?,
	//      file_hash = ?,
	//      updated_at = CURRENT_TIMESTAMP
	//  WHERE url = ?
	UpdateNarInfoCompressionFileSizeHashAndURL(ctx context.Context, arg UpdateNarInfoCompressionFileSizeHashAndURLParams) (int64, error)
	//UpdateNarInfoFileHash
	//
	//  UPDATE narinfos
	//  SET file_hash = ?, updated_at = CURRENT_TIMESTAMP
	//  WHERE hash = ?
	UpdateNarInfoFileHash(ctx context.Context, arg UpdateNarInfoFileHashParams) error
	//UpdateNarInfoFileSize
	//
	//  UPDATE narinfos
	//  SET file_size = ?, updated_at = CURRENT_TIMESTAMP
	//  WHERE hash = ?
	UpdateNarInfoFileSize(ctx context.Context, arg UpdateNarInfoFileSizeParams) error
}

type Queries struct {
	// contains filtered or unexported fields
}

type SetConfigParams struct {
	Key   string
	Value string
}

type TouchNarFileParams struct {
	Hash        string
	Compression string
	Query       string
}

type UpdateNarFileFileSizeParams struct {
	FileSize uint64
	ID       int64
}

type UpdateNarFileTotalChunksParams struct {
	TotalChunks int64
	FileSize    uint64
	ID          int64
}

type UpdateNarInfoCompressionAndURLParams struct {
	Compression sql.NullString
	NewUrl      sql.NullString
	OldUrl      sql.NullString
}

type UpdateNarInfoCompressionFileSizeHashAndURLParams struct {
	Compression sql.NullString
	NewUrl      sql.NullString
	FileSize    sql.NullInt64
	FileHash    sql.NullString
	OldUrl      sql.NullString
}

type UpdateNarInfoFileHashParams struct {
	FileHash sql.NullString
	Hash     string
}

type UpdateNarInfoFileSizeParams struct {
	FileSize sql.NullInt64
	Hash     string
}

type UpdateNarInfoParams struct {
	StorePath   sql.NullString
	URL         sql.NullString
	Compression sql.NullString
	FileHash    sql.NullString
	FileSize    sql.NullInt64
	NarHash     sql.NullString
	NarSize     sql.NullInt64
	Deriver     sql.NullString
	System      sql.NullString
	Ca          sql.NullString
	Hash        string
}