// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.29.0
// source: actor.sql

package sqlc

import (
	"context"
	"database/sql"
)

const countActors = `-- name: CountActors :one
SELECT COUNT(*)
FROM actor
`

func (q *Queries) CountActors(ctx context.Context) (int64, error) {
	row := q.db.QueryRowContext(ctx, countActors)
	var count int64
	err := row.Scan(&count)
	return count, err
}

const deleteActor = `-- name: DeleteActor :execrows
DELETE FROM actor WHERE actor_id = ?
`

func (q *Queries) DeleteActor(ctx context.Context, actorID int64) (int64, error) {
	result, err := q.db.ExecContext(ctx, deleteActor, actorID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}

const getActor = `-- name: GetActor :one
SELECT actor_id, first_name, last_name, last_update
FROM actor
WHERE actor_id = ?
`

func (q *Queries) GetActor(ctx context.Context, actorID int64) (Actor, error) {
	row := q.db.QueryRowContext(ctx, getActor, actorID)
	var i Actor
	err := row.Scan(
		&i.ActorID,
		&i.FirstName,
		&i.LastName,
		&i.LastUpdate,
	)
	return i, err
}

const insertActor = `-- name: InsertActor :exec
INSERT INTO actor (actor_id, first_name, last_name, last_update)
VALUES (?, ?, ?, CURRENT_TIMESTAMP)
`

type InsertActorParams struct {
	ActorID   int64  `json:"actor_id"`
	FirstName string `json:"first_name"`
	LastName  string `json:"last_name"`
}

func (q *Queries) InsertActor(ctx context.Context, arg InsertActorParams) error {
	_, err := q.db.ExecContext(ctx, insertActor, arg.ActorID, arg.FirstName, arg.LastName)
	return err
}

const listActors = `-- name: ListActors :many
SELECT actor_id, first_name, last_name, last_update
FROM actor
ORDER BY actor_id ASC
LIMIT ? OFFSET ?
`

type ListActorsParams struct {
	Limit  int64 `json:"limit"`
	Offset int64 `json:"offset"`
}

func (q *Queries) ListActors(ctx context.Context, arg ListActorsParams) ([]Actor, error) {
	rows, err := q.db.QueryContext(ctx, listActors, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Actor
	for rows.Next() {
		var i Actor
		if err := rows.Scan(
			&i.ActorID,
			&i.FirstName,
			&i.LastName,
			&i.LastUpdate,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listFilmsByActor = `-- name: ListFilmsByActor :many
SELECT f.film_id,
       f.title,
       f.description,
       f.release_year,
       f.language_id,
       f.original_language_id,
       f.rental_duration,
       f.rental_rate,
       f.length,
       f.replacement_cost,
       f.rating,
       f.special_features,
       f.last_update
FROM film f
         JOIN film_actor fa ON fa.film_id = f.film_id
WHERE fa.actor_id = ?
ORDER BY f.title ASC
`

func (q *Queries) ListFilmsByActor(ctx context.Context, actorID int64) ([]Film, error) {
	rows, err := q.db.QueryContext(ctx, listFilmsByActor, actorID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Film
	for rows.Next() {
		var i Film
		if err := rows.Scan(
			&i.FilmID,
			&i.Title,
			&i.Description,
			&i.ReleaseYear,
			&i.LanguageID,
			&i.OriginalLanguageID,
			&i.RentalDuration,
			&i.RentalRate,
			&i.Length,
			&i.ReplacementCost,
			&i.Rating,
			&i.SpecialFeatures,
			&i.LastUpdate,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const nextActorID = `-- name: NextActorID :one
SELECT COALESCE(MAX(actor_id), 0) + 1 FROM actor
`

func (q *Queries) NextActorID(ctx context.Context) (int64, error) {
	row := q.db.QueryRowContext(ctx, nextActorID)
	var column_1 int64
	err := row.Scan(&column_1)
	return column_1, err
}

const patchActor = `-- name: PatchActor :execrows
UPDATE actor
SET first_name = COALESCE(?1, first_name),
    last_name  = COALESCE(?2,  last_name)
WHERE actor_id = ?3
`

type PatchActorParams struct {
	FirstName sql.NullString `json:"first_name"`
	LastName  sql.NullString `json:"last_name"`
	ActorID   int64          `json:"actor_id"`
}

func (q *Queries) PatchActor(ctx context.Context, arg PatchActorParams) (int64, error) {
	result, err := q.db.ExecContext(ctx, patchActor, arg.FirstName, arg.LastName, arg.ActorID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}

const updateActorPut = `-- name: UpdateActorPut :execrows
UPDATE actor
SET first_name = ?,
    last_name  = ?
WHERE actor_id = ?
`

type UpdateActorPutParams struct {
	FirstName string `json:"first_name"`
	LastName  string `json:"last_name"`
	ActorID   int64  `json:"actor_id"`
}

func (q *Queries) UpdateActorPut(ctx context.Context, arg UpdateActorPutParams) (int64, error) {
	result, err := q.db.ExecContext(ctx, updateActorPut, arg.FirstName, arg.LastName, arg.ActorID)
	if err != nil {
		return 0, err
	}
	return result.RowsAffected()
}