github.com/benoitkugler/goacve@v0.0.0-20201217100549-151ce6e55dc8/server/vote/scans.go

// DON'T EDIT - automatically generated by structgen //

package vote

import (
	"database/sql"

	"github.com/lib/pq"
)

type scanner interface {
	Scan(...interface{}) error
}

// DB groups transaction like objects
type DB interface {
	Exec(query string, args ...interface{}) (sql.Result, error)
	Query(query string, args ...interface{}) (*sql.Rows, error)
	QueryRow(query string, args ...interface{}) *sql.Row
	Prepare(query string) (*sql.Stmt, error)
}

func scanOneCandidat(row scanner) (Candidat, error) {
	var s Candidat
	err := row.Scan(
		&s.Id,
		&s.IdVote,
		&s.Label,
	)
	return s, err
}

func ScanCandidat(row *sql.Row) (Candidat, error) {
	return scanOneCandidat(row)
}

func SelectAllCandidats(tx DB) (Candidats, error) {
	rows, err := tx.Query("SELECT * FROM candidats")
	if err != nil {
		return nil, err
	}
	return ScanCandidats(rows)
}

// SelectCandidat returns the entry matching id.
func SelectCandidat(tx DB, id int64) (Candidat, error) {
	row := tx.QueryRow("SELECT * FROM candidats WHERE id = $1", id)
	return ScanCandidat(row)
}

type Candidats map[int64]Candidat

func (m Candidats) Ids() Ids {
	out := make(Ids, 0, len(m))
	for i := range m {
		out = append(out, i)
	}
	return out
}

func ScanCandidats(rs *sql.Rows) (Candidats, error) {
	var (
		s   Candidat
		err error
	)
	defer func() {
		errClose := rs.Close()
		if err == nil {
			err = errClose
		}
	}()
	structs := make(Candidats, 16)
	for rs.Next() {
		s, err = scanOneCandidat(rs)
		if err != nil {
			return nil, err
		}
		structs[s.Id] = s
	}
	if err = rs.Err(); err != nil {
		return nil, err
	}
	return structs, nil
}

// Insert Candidat in the database and returns the item with id filled.
func (item Candidat) Insert(tx DB) (out Candidat, err error) {
	row := tx.QueryRow(`INSERT INTO candidats (
		id_vote,label
		) VALUES (
		$1,$2
		) RETURNING 
		id,id_vote,label;
		`, item.IdVote, item.Label)
	return ScanCandidat(row)
}

// Update Candidat in the database and returns the new version.
func (item Candidat) Update(tx DB) (out Candidat, err error) {
	row := tx.QueryRow(`UPDATE candidats SET (
		id_vote,label
		) = (
		$2,$3
		) WHERE id = $1 RETURNING 
		id,id_vote,label;
		`, item.Id, item.IdVote, item.Label)
	return ScanCandidat(row)
}

// Deletes Candidat in the database and returns the item.
// Only the field 'Id' is used.
func (item Candidat) Delete(tx DB) (Candidat, error) {
	row := tx.QueryRow("DELETE FROM candidats WHERE id = $1 RETURNING *;", item.Id)
	return ScanCandidat(row)
}

func scanOneVote(row scanner) (Vote, error) {
	var s Vote
	err := row.Scan(
		&s.Id,
		&s.Nom,
		&s.Description,
		&s.IsQCM,
		&s.IsLocked,
	)
	return s, err
}

func ScanVote(row *sql.Row) (Vote, error) {
	return scanOneVote(row)
}

func SelectAllVotes(tx DB) (Votes, error) {
	rows, err := tx.Query("SELECT * FROM votes")
	if err != nil {
		return nil, err
	}
	return ScanVotes(rows)
}

// SelectVote returns the entry matching id.
func SelectVote(tx DB, id int64) (Vote, error) {
	row := tx.QueryRow("SELECT * FROM votes WHERE id = $1", id)
	return ScanVote(row)
}

type Votes map[int64]Vote

func (m Votes) Ids() Ids {
	out := make(Ids, 0, len(m))
	for i := range m {
		out = append(out, i)
	}
	return out
}

func ScanVotes(rs *sql.Rows) (Votes, error) {
	var (
		s   Vote
		err error
	)
	defer func() {
		errClose := rs.Close()
		if err == nil {
			err = errClose
		}
	}()
	structs := make(Votes, 16)
	for rs.Next() {
		s, err = scanOneVote(rs)
		if err != nil {
			return nil, err
		}
		structs[s.Id] = s
	}
	if err = rs.Err(); err != nil {
		return nil, err
	}
	return structs, nil
}

// Insert Vote in the database and returns the item with id filled.
func (item Vote) Insert(tx DB) (out Vote, err error) {
	row := tx.QueryRow(`INSERT INTO votes (
		nom,description,is_qcm,is_locked
		) VALUES (
		$1,$2,$3,$4
		) RETURNING 
		id,nom,description,is_qcm,is_locked;
		`, item.Nom, item.Description, item.IsQCM, item.IsLocked)
	return ScanVote(row)
}

// Update Vote in the database and returns the new version.
func (item Vote) Update(tx DB) (out Vote, err error) {
	row := tx.QueryRow(`UPDATE votes SET (
		nom,description,is_qcm,is_locked
		) = (
		$2,$3,$4,$5
		) WHERE id = $1 RETURNING 
		id,nom,description,is_qcm,is_locked;
		`, item.Id, item.Nom, item.Description, item.IsQCM, item.IsLocked)
	return ScanVote(row)
}

// Deletes Vote in the database and returns the item.
// Only the field 'Id' is used.
func (item Vote) Delete(tx DB) (Vote, error) {
	row := tx.QueryRow("DELETE FROM votes WHERE id = $1 RETURNING *;", item.Id)
	return ScanVote(row)
}

func scanOneVotePersonne(row scanner) (VotePersonne, error) {
	var s VotePersonne
	err := row.Scan(
		&s.IdVote,
		&s.IdPersonne,
		&s.Time,
	)
	return s, err
}

func ScanVotePersonne(row *sql.Row) (VotePersonne, error) {
	return scanOneVotePersonne(row)
}

func SelectAllVotePersonnes(tx DB) (VotePersonnes, error) {
	rows, err := tx.Query("SELECT * FROM vote_personnes")
	if err != nil {
		return nil, err
	}
	return ScanVotePersonnes(rows)
}

type VotePersonnes []VotePersonne

func ScanVotePersonnes(rs *sql.Rows) (VotePersonnes, error) {
	var (
		s   VotePersonne
		err error
	)
	defer func() {
		errClose := rs.Close()
		if err == nil {
			err = errClose
		}
	}()
	structs := make(VotePersonnes, 0, 16)
	for rs.Next() {
		s, err = scanOneVotePersonne(rs)
		if err != nil {
			return nil, err
		}
		structs = append(structs, s)
	}
	if err = rs.Err(); err != nil {
		return nil, err
	}
	return structs, nil
}

func SelectVotePersonneByIdVote(tx DB, idVotes ...int64) (VotePersonnes, error) {
	rows, err := tx.Query("SELECT * FROM vote_personnes WHERE id_vote = ANY($1)", pq.Int64Array(idVotes))
	if err != nil {
		return nil, err
	}
	return ScanVotePersonnes(rows)
}

func SelectVotePersonneByIdPersonne(tx DB, idPersonnes ...int64) (VotePersonnes, error) {
	rows, err := tx.Query("SELECT * FROM vote_personnes WHERE id_personne = ANY($1)", pq.Int64Array(idPersonnes))
	if err != nil {
		return nil, err
	}
	return ScanVotePersonnes(rows)
}

// ByIdVote returns a map with 'IdVote' as keys.
// Collision may happen without uniqueness constraint.
func (items VotePersonnes) ByIdVote() map[int64]VotePersonne {
	out := make(map[int64]VotePersonne, len(items))
	for _, target := range items {
		out[target.IdVote] = target
	}
	return out
}

// ByIdPersonne returns a map with 'IdPersonne' as keys.
// Collision may happen without uniqueness constraint.
func (items VotePersonnes) ByIdPersonne() map[int64]VotePersonne {
	out := make(map[int64]VotePersonne, len(items))
	for _, target := range items {
		out[target.IdPersonne] = target
	}
	return out
}

// Insert the links VotePersonne in the database.
func InsertManyVotePersonnes(tx DB, items ...VotePersonne) error {
	if len(items) == 0 {
		return nil
	}

	stmt, err := tx.Prepare(pq.CopyIn("vote_personnes",
		"id_vote", "id_personne", "time",
	))
	if err != nil {
		return err
	}

	for _, item := range items {
		_, err = stmt.Exec(item.IdVote, item.IdPersonne, item.Time)
		if err != nil {
			return err
		}
	}

	if _, err = stmt.Exec(); err != nil {
		return err
	}

	if err = stmt.Close(); err != nil {
		return err
	}
	return nil
}

// Delete the link VotePersonne in the database.
// Only the 'IdVote' 'IdPersonne' fields are used.
func (item VotePersonne) Delete(tx DB) error {
	_, err := tx.Exec(`DELETE FROM vote_personnes WHERE 
	id_vote = $1 AND id_personne = $2;`, item.IdVote, item.IdPersonne)
	return err
}

func scanOneVotePersonneCandidat(row scanner) (VotePersonneCandidat, error) {
	var s VotePersonneCandidat
	err := row.Scan(
		&s.IdVote,
		&s.IdPersonne,
		&s.IdCandidat,
	)
	return s, err
}

func ScanVotePersonneCandidat(row *sql.Row) (VotePersonneCandidat, error) {
	return scanOneVotePersonneCandidat(row)
}

func SelectAllVotePersonneCandidats(tx DB) (VotePersonneCandidats, error) {
	rows, err := tx.Query("SELECT * FROM vote_personne_candidats")
	if err != nil {
		return nil, err
	}
	return ScanVotePersonneCandidats(rows)
}

type VotePersonneCandidats []VotePersonneCandidat

func ScanVotePersonneCandidats(rs *sql.Rows) (VotePersonneCandidats, error) {
	var (
		s   VotePersonneCandidat
		err error
	)
	defer func() {
		errClose := rs.Close()
		if err == nil {
			err = errClose
		}
	}()
	structs := make(VotePersonneCandidats, 0, 16)
	for rs.Next() {
		s, err = scanOneVotePersonneCandidat(rs)
		if err != nil {
			return nil, err
		}
		structs = append(structs, s)
	}
	if err = rs.Err(); err != nil {
		return nil, err
	}
	return structs, nil
}

func SelectVotePersonneCandidatByIdVote(tx DB, idVotes ...int64) (VotePersonneCandidats, error) {
	rows, err := tx.Query("SELECT * FROM vote_personne_candidats WHERE id_vote = ANY($1)", pq.Int64Array(idVotes))
	if err != nil {
		return nil, err
	}
	return ScanVotePersonneCandidats(rows)
}

func SelectVotePersonneCandidatByIdPersonne(tx DB, idPersonnes ...int64) (VotePersonneCandidats, error) {
	rows, err := tx.Query("SELECT * FROM vote_personne_candidats WHERE id_personne = ANY($1)", pq.Int64Array(idPersonnes))
	if err != nil {
		return nil, err
	}
	return ScanVotePersonneCandidats(rows)
}

func SelectVotePersonneCandidatByIdCandidat(tx DB, idCandidats ...int64) (VotePersonneCandidats, error) {
	rows, err := tx.Query("SELECT * FROM vote_personne_candidats WHERE id_candidat = ANY($1)", pq.Int64Array(idCandidats))
	if err != nil {
		return nil, err
	}
	return ScanVotePersonneCandidats(rows)
}

// ByIdVote returns a map with 'IdVote' as keys.
// Collision may happen without uniqueness constraint.
func (items VotePersonneCandidats) ByIdVote() map[int64]VotePersonneCandidat {
	out := make(map[int64]VotePersonneCandidat, len(items))
	for _, target := range items {
		out[target.IdVote] = target
	}
	return out
}

// ByIdPersonne returns a map with 'IdPersonne' as keys.
// Collision may happen without uniqueness constraint.
func (items VotePersonneCandidats) ByIdPersonne() map[int64]VotePersonneCandidat {
	out := make(map[int64]VotePersonneCandidat, len(items))
	for _, target := range items {
		out[target.IdPersonne] = target
	}
	return out
}

// ByIdCandidat returns a map with 'IdCandidat' as keys.
// Collision may happen without uniqueness constraint.
func (items VotePersonneCandidats) ByIdCandidat() map[int64]VotePersonneCandidat {
	out := make(map[int64]VotePersonneCandidat, len(items))
	for _, target := range items {
		out[target.IdCandidat] = target
	}
	return out
}

// Insert the links VotePersonneCandidat in the database.
func InsertManyVotePersonneCandidats(tx DB, items ...VotePersonneCandidat) error {
	if len(items) == 0 {
		return nil
	}

	stmt, err := tx.Prepare(pq.CopyIn("vote_personne_candidats",
		"id_vote", "id_personne", "id_candidat",
	))
	if err != nil {
		return err
	}

	for _, item := range items {
		_, err = stmt.Exec(item.IdVote, item.IdPersonne, item.IdCandidat)
		if err != nil {
			return err
		}
	}

	if _, err = stmt.Exec(); err != nil {
		return err
	}

	if err = stmt.Close(); err != nil {
		return err
	}
	return nil
}

// Delete the link VotePersonneCandidat in the database.
// Only the 'IdVote' 'IdPersonne' 'IdCandidat' fields are used.
func (item VotePersonneCandidat) Delete(tx DB) error {
	_, err := tx.Exec(`DELETE FROM vote_personne_candidats WHERE 
	id_vote = $1 AND id_personne = $2 AND id_candidat = $3;`, item.IdVote, item.IdPersonne, item.IdCandidat)
	return err
}