cost.sql.go

// Code generated by sqlc. DO NOT EDIT.
// source: cost.sql

package gensql

import (
	"context"

	"github.com/jackc/pgx/v5/pgtype"
	"github.com/nais/api/internal/slug"
)

const dailyCostForApp = `-- name: DailyCostForApp :many
SELECT
    id, environment, team_slug, app, cost_type, date, daily_cost
FROM
    cost
WHERE
    date >= $1::date
    AND date <= $2::date
    AND environment = $3::text
    AND team_slug = $4::slug
    AND app = $5
ORDER BY
    date, cost_type ASC
`

type DailyCostForAppParams struct {
	FromDate    pgtype.Date
	ToDate      pgtype.Date
	Environment string
	TeamSlug    slug.Slug
	App         string
}

// DailyCostForApp will fetch the daily cost for a specific team app in a specific environment, across all cost types
// in a date range.
func (q *Queries) DailyCostForApp(ctx context.Context, arg DailyCostForAppParams) ([]*Cost, error) {
	rows, err := q.db.Query(ctx, dailyCostForApp,
		arg.FromDate,
		arg.ToDate,
		arg.Environment,
		arg.TeamSlug,
		arg.App,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*Cost{}
	for rows.Next() {
		var i Cost
		if err := rows.Scan(
			&i.ID,
			&i.Environment,
			&i.TeamSlug,
			&i.App,
			&i.CostType,
			&i.Date,
			&i.DailyCost,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const dailyCostForTeam = `-- name: DailyCostForTeam :many
SELECT
    id, environment, team_slug, app, cost_type, date, daily_cost
FROM
    cost
WHERE
    date >= $1::date
    AND date <= $2::date
    AND team_slug = $3::slug
ORDER BY
    date, environment, app, cost_type ASC
`

type DailyCostForTeamParams struct {
	FromDate pgtype.Date
	ToDate   pgtype.Date
	TeamSlug slug.Slug
}

// DailyCostForTeam will fetch the daily cost for a specific team across all apps and envs in a date range.
func (q *Queries) DailyCostForTeam(ctx context.Context, arg DailyCostForTeamParams) ([]*Cost, error) {
	rows, err := q.db.Query(ctx, dailyCostForTeam, arg.FromDate, arg.ToDate, arg.TeamSlug)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*Cost{}
	for rows.Next() {
		var i Cost
		if err := rows.Scan(
			&i.ID,
			&i.Environment,
			&i.TeamSlug,
			&i.App,
			&i.CostType,
			&i.Date,
			&i.DailyCost,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const dailyEnvCostForTeam = `-- name: DailyEnvCostForTeam :many
SELECT team_slug, app, environment, date, daily_cost
FROM cost_daily_team
WHERE
    date >= $1::date
    AND date <= $2::date
    AND team_slug = $3::slug
    AND environment = $4
ORDER BY
    date, app ASC
`

type DailyEnvCostForTeamParams struct {
	FromDate    pgtype.Date
	ToDate      pgtype.Date
	TeamSlug    slug.Slug
	Environment *string
}

// DailyEnvCostForTeam will fetch the daily cost for a specific team and environment across all apps in a date range.
func (q *Queries) DailyEnvCostForTeam(ctx context.Context, arg DailyEnvCostForTeamParams) ([]*CostDailyTeam, error) {
	rows, err := q.db.Query(ctx, dailyEnvCostForTeam,
		arg.FromDate,
		arg.ToDate,
		arg.TeamSlug,
		arg.Environment,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*CostDailyTeam{}
	for rows.Next() {
		var i CostDailyTeam
		if err := rows.Scan(
			&i.TeamSlug,
			&i.App,
			&i.Environment,
			&i.Date,
			&i.DailyCost,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const lastCostDate = `-- name: LastCostDate :one
SELECT
    MAX(date)::date AS date
FROM
    cost
`

// LastCostDate will return the last date that has a cost.
func (q *Queries) LastCostDate(ctx context.Context) (pgtype.Date, error) {
	row := q.db.QueryRow(ctx, lastCostDate)
	var date pgtype.Date
	err := row.Scan(&date)
	return date, err
}

const monthlyCostForApp = `-- name: MonthlyCostForApp :many
SELECT team_slug, app, environment, month, last_recorded_date, daily_cost
FROM cost_monthly_app
WHERE team_slug = $1::slug
AND app = $2
AND environment = $3::text
ORDER BY month DESC
LIMIT 12
`

type MonthlyCostForAppParams struct {
	TeamSlug    slug.Slug
	App         string
	Environment string
}

func (q *Queries) MonthlyCostForApp(ctx context.Context, arg MonthlyCostForAppParams) ([]*CostMonthlyApp, error) {
	rows, err := q.db.Query(ctx, monthlyCostForApp, arg.TeamSlug, arg.App, arg.Environment)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*CostMonthlyApp{}
	for rows.Next() {
		var i CostMonthlyApp
		if err := rows.Scan(
			&i.TeamSlug,
			&i.App,
			&i.Environment,
			&i.Month,
			&i.LastRecordedDate,
			&i.DailyCost,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const monthlyCostForTeam = `-- name: MonthlyCostForTeam :many
SELECT team_slug, month, last_recorded_date, daily_cost
FROM cost_monthly_team
WHERE team_slug = $1::slug
ORDER BY month DESC
LIMIT 12
`

func (q *Queries) MonthlyCostForTeam(ctx context.Context, teamSlug slug.Slug) ([]*CostMonthlyTeam, error) {
	rows, err := q.db.Query(ctx, monthlyCostForTeam, teamSlug)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []*CostMonthlyTeam{}
	for rows.Next() {
		var i CostMonthlyTeam
		if err := rows.Scan(
			&i.TeamSlug,
			&i.Month,
			&i.LastRecordedDate,
			&i.DailyCost,
		); err != nil {
			return nil, err
		}
		items = append(items, &i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}