// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.30.0
// source: queries.sql

package db

import (
	"context"
	"time"
)

const createDeviceTag = `-- name: CreateDeviceTag :one
insert
into device_tag (device_name, tag)
values (?, ?) returning id, device_name, tag
`

type CreateDeviceTagParams struct {
	DeviceName string
	Tag        string
}

func (q *Queries) CreateDeviceTag(ctx context.Context, arg CreateDeviceTagParams) (DeviceTag, error) {
	row := q.db.QueryRowContext(ctx, createDeviceTag, arg.DeviceName, arg.Tag)
	var i DeviceTag
	err := row.Scan(&i.ID, &i.DeviceName, &i.Tag)
	return i, err
}

const createHumidityLog = `-- name: CreateHumidityLog :one
insert
into humidity_log (time, sensor , temperature, humidity, dew_point)
values (?, ?, ?, ?, ?) returning id, time, sensor, temperature, humidity, dew_point
`

type CreateHumidityLogParams struct {
	Time        time.Time
	Sensor      string
	Temperature float64
	Humidity    float64
	DewPoint    float64
}

func (q *Queries) CreateHumidityLog(ctx context.Context, arg CreateHumidityLogParams) (HumidityLog, error) {
	row := q.db.QueryRowContext(ctx, createHumidityLog,
		arg.Time,
		arg.Sensor,
		arg.Temperature,
		arg.Humidity,
		arg.DewPoint,
	)
	var i HumidityLog
	err := row.Scan(
		&i.ID,
		&i.Time,
		&i.Sensor,
		&i.Temperature,
		&i.Humidity,
		&i.DewPoint,
	)
	return i, err
}

const createPowerLog = `-- name: CreatePowerLog :one
insert
into power_log (time, sensor, total_start_time, total, yesterday, today, period, power, apparent_power, reactive_power, factor, voltage, current, sensor_temperature)
values (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?) returning id, time, sensor, total_start_time, total, yesterday, today, period, power, apparent_power, reactive_power, factor, voltage, "current", sensor_temperature
`

type CreatePowerLogParams struct {
	Time              time.Time
	Sensor            string
	TotalStartTime    time.Time
	Total             float64
	Yesterday         float64
	Today             float64
	Period            float64
	Power             float64
	ApparentPower     float64
	ReactivePower     float64
	Factor            float64
	Voltage           float64
	Current           float64
	SensorTemperature float64
}

func (q *Queries) CreatePowerLog(ctx context.Context, arg CreatePowerLogParams) (PowerLog, error) {
	row := q.db.QueryRowContext(ctx, createPowerLog,
		arg.Time,
		arg.Sensor,
		arg.TotalStartTime,
		arg.Total,
		arg.Yesterday,
		arg.Today,
		arg.Period,
		arg.Power,
		arg.ApparentPower,
		arg.ReactivePower,
		arg.Factor,
		arg.Voltage,
		arg.Current,
		arg.SensorTemperature,
	)
	var i PowerLog
	err := row.Scan(
		&i.ID,
		&i.Time,
		&i.Sensor,
		&i.TotalStartTime,
		&i.Total,
		&i.Yesterday,
		&i.Today,
		&i.Period,
		&i.Power,
		&i.ApparentPower,
		&i.ReactivePower,
		&i.Factor,
		&i.Voltage,
		&i.Current,
		&i.SensorTemperature,
	)
	return i, err
}

const createSwitchStateLog = `-- name: CreateSwitchStateLog :one
insert
into switch_state_log (time, sensor , switch_state)
values (?, ?, ?) returning id, time, sensor, switch_state
`

type CreateSwitchStateLogParams struct {
	Time        time.Time
	Sensor      string
	SwitchState string
}

func (q *Queries) CreateSwitchStateLog(ctx context.Context, arg CreateSwitchStateLogParams) (SwitchStateLog, error) {
	row := q.db.QueryRowContext(ctx, createSwitchStateLog, arg.Time, arg.Sensor, arg.SwitchState)
	var i SwitchStateLog
	err := row.Scan(
		&i.ID,
		&i.Time,
		&i.Sensor,
		&i.SwitchState,
	)
	return i, err
}

const deleteDeviceTag = `-- name: DeleteDeviceTag :exec
delete
from device_tag
where id = ?
`

func (q *Queries) DeleteDeviceTag(ctx context.Context, id int64) error {
	_, err := q.db.ExecContext(ctx, deleteDeviceTag, id)
	return err
}

const deleteHumidityLog = `-- name: DeleteHumidityLog :exec
delete
from humidity_log
where id = ?
`

func (q *Queries) DeleteHumidityLog(ctx context.Context, id int64) error {
	_, err := q.db.ExecContext(ctx, deleteHumidityLog, id)
	return err
}

const deletePowerLog = `-- name: DeletePowerLog :exec
delete
from power_log
where id = ?
`

func (q *Queries) DeletePowerLog(ctx context.Context, id int64) error {
	_, err := q.db.ExecContext(ctx, deletePowerLog, id)
	return err
}

const deleteSwitchStateLog = `-- name: DeleteSwitchStateLog :exec
delete
from switch_state_log
where id = ?
`

func (q *Queries) DeleteSwitchStateLog(ctx context.Context, id int64) error {
	_, err := q.db.ExecContext(ctx, deleteSwitchStateLog, id)
	return err
}

const getDeviceTag = `-- name: GetDeviceTag :one
select id, device_name, tag
from device_tag
where id = ? limit 1
`

func (q *Queries) GetDeviceTag(ctx context.Context, id int64) (DeviceTag, error) {
	row := q.db.QueryRowContext(ctx, getDeviceTag, id)
	var i DeviceTag
	err := row.Scan(&i.ID, &i.DeviceName, &i.Tag)
	return i, err
}

const getHumidityLog = `-- name: GetHumidityLog :one
select id, time, sensor, temperature, humidity, dew_point
from humidity_log
where id = ? limit 1
`

func (q *Queries) GetHumidityLog(ctx context.Context, id int64) (HumidityLog, error) {
	row := q.db.QueryRowContext(ctx, getHumidityLog, id)
	var i HumidityLog
	err := row.Scan(
		&i.ID,
		&i.Time,
		&i.Sensor,
		&i.Temperature,
		&i.Humidity,
		&i.DewPoint,
	)
	return i, err
}

const getPowerLog = `-- name: GetPowerLog :one
select id, time, sensor, total_start_time, total, yesterday, today, period, power, apparent_power, reactive_power, factor, voltage, "current", sensor_temperature
from power_log
where id = ? limit 1
`

func (q *Queries) GetPowerLog(ctx context.Context, id int64) (PowerLog, error) {
	row := q.db.QueryRowContext(ctx, getPowerLog, id)
	var i PowerLog
	err := row.Scan(
		&i.ID,
		&i.Time,
		&i.Sensor,
		&i.TotalStartTime,
		&i.Total,
		&i.Yesterday,
		&i.Today,
		&i.Period,
		&i.Power,
		&i.ApparentPower,
		&i.ReactivePower,
		&i.Factor,
		&i.Voltage,
		&i.Current,
		&i.SensorTemperature,
	)
	return i, err
}

const getSwitchStateLog = `-- name: GetSwitchStateLog :one
select id, time, sensor, switch_state
from switch_state_log
where id = ? limit 1
`

func (q *Queries) GetSwitchStateLog(ctx context.Context, id int64) (SwitchStateLog, error) {
	row := q.db.QueryRowContext(ctx, getSwitchStateLog, id)
	var i SwitchStateLog
	err := row.Scan(
		&i.ID,
		&i.Time,
		&i.Sensor,
		&i.SwitchState,
	)
	return i, err
}

const humidityLogForDeviceToDate = `-- name: HumidityLogForDeviceToDate :many
select humidity_log.id, time, sensor, temperature, humidity, dew_point, device_tag.id, device_name, tag
from humidity_log
join device_tag on device_name = humidity_log.sensor
where device_tag.tag = ?
    and (time between ? and ?)
order by time desc
`

type HumidityLogForDeviceToDateParams struct {
	Tag      string
	FromTime time.Time
	ToTime   time.Time
}

type HumidityLogForDeviceToDateRow struct {
	ID          int64
	Time        time.Time
	Sensor      string
	Temperature float64
	Humidity    float64
	DewPoint    float64
	ID_2        int64
	DeviceName  string
	Tag         string
}

func (q *Queries) HumidityLogForDeviceToDate(ctx context.Context, arg HumidityLogForDeviceToDateParams) ([]HumidityLogForDeviceToDateRow, error) {
	rows, err := q.db.QueryContext(ctx, humidityLogForDeviceToDate, arg.Tag, arg.FromTime, arg.ToTime)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []HumidityLogForDeviceToDateRow
	for rows.Next() {
		var i HumidityLogForDeviceToDateRow
		if err := rows.Scan(
			&i.ID,
			&i.Time,
			&i.Sensor,
			&i.Temperature,
			&i.Humidity,
			&i.DewPoint,
			&i.ID_2,
			&i.DeviceName,
			&i.Tag,
		); 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 listDeviceTag = `-- name: ListDeviceTag :many
select id, device_name, tag
from device_tag
`

func (q *Queries) ListDeviceTag(ctx context.Context) ([]DeviceTag, error) {
	rows, err := q.db.QueryContext(ctx, listDeviceTag)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []DeviceTag
	for rows.Next() {
		var i DeviceTag
		if err := rows.Scan(&i.ID, &i.DeviceName, &i.Tag); 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 listDevices = `-- name: ListDevices :many
select tag from device_tag group by tag
`

func (q *Queries) ListDevices(ctx context.Context) ([]string, error) {
	rows, err := q.db.QueryContext(ctx, listDevices)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []string
	for rows.Next() {
		var tag string
		if err := rows.Scan(&tag); err != nil {
			return nil, err
		}
		items = append(items, tag)
	}
	if err := rows.Close(); err != nil {
		return nil, err
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const listHumidityLog = `-- name: ListHumidityLog :many
select id, time, sensor, temperature, humidity, dew_point
from humidity_log
order by time desc limit ? offset ?
`

type ListHumidityLogParams struct {
	Limit  int64
	Offset int64
}

func (q *Queries) ListHumidityLog(ctx context.Context, arg ListHumidityLogParams) ([]HumidityLog, error) {
	rows, err := q.db.QueryContext(ctx, listHumidityLog, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []HumidityLog
	for rows.Next() {
		var i HumidityLog
		if err := rows.Scan(
			&i.ID,
			&i.Time,
			&i.Sensor,
			&i.Temperature,
			&i.Humidity,
			&i.DewPoint,
		); 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 listPowerLog = `-- name: ListPowerLog :many
select id, time, sensor, total_start_time, total, yesterday, today, period, power, apparent_power, reactive_power, factor, voltage, "current", sensor_temperature
from power_log
order by time desc limit ? offset ?
`

type ListPowerLogParams struct {
	Limit  int64
	Offset int64
}

func (q *Queries) ListPowerLog(ctx context.Context, arg ListPowerLogParams) ([]PowerLog, error) {
	rows, err := q.db.QueryContext(ctx, listPowerLog, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []PowerLog
	for rows.Next() {
		var i PowerLog
		if err := rows.Scan(
			&i.ID,
			&i.Time,
			&i.Sensor,
			&i.TotalStartTime,
			&i.Total,
			&i.Yesterday,
			&i.Today,
			&i.Period,
			&i.Power,
			&i.ApparentPower,
			&i.ReactivePower,
			&i.Factor,
			&i.Voltage,
			&i.Current,
			&i.SensorTemperature,
		); 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 listSwitchStateLog = `-- name: ListSwitchStateLog :many
select id, time, sensor, switch_state
from switch_state_log
order by time desc limit ? offset ?
`

type ListSwitchStateLogParams struct {
	Limit  int64
	Offset int64
}

func (q *Queries) ListSwitchStateLog(ctx context.Context, arg ListSwitchStateLogParams) ([]SwitchStateLog, error) {
	rows, err := q.db.QueryContext(ctx, listSwitchStateLog, arg.Limit, arg.Offset)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []SwitchStateLog
	for rows.Next() {
		var i SwitchStateLog
		if err := rows.Scan(
			&i.ID,
			&i.Time,
			&i.Sensor,
			&i.SwitchState,
		); 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 powerLogForDeviceToDate = `-- name: PowerLogForDeviceToDate :many
select power_log.id, time, sensor, total_start_time, total, yesterday, today, period, power, apparent_power, reactive_power, factor, voltage, "current", sensor_temperature, device_tag.id, device_name, tag
from power_log
         join device_tag on device_name = power_log.sensor
where device_tag.tag = ?
  and (time between ? and ?)
order by time desc
`

type PowerLogForDeviceToDateParams struct {
	Tag      string
	FromTime time.Time
	ToTime   time.Time
}

type PowerLogForDeviceToDateRow struct {
	ID                int64
	Time              time.Time
	Sensor            string
	TotalStartTime    time.Time
	Total             float64
	Yesterday         float64
	Today             float64
	Period            float64
	Power             float64
	ApparentPower     float64
	ReactivePower     float64
	Factor            float64
	Voltage           float64
	Current           float64
	SensorTemperature float64
	ID_2              int64
	DeviceName        string
	Tag               string
}

func (q *Queries) PowerLogForDeviceToDate(ctx context.Context, arg PowerLogForDeviceToDateParams) ([]PowerLogForDeviceToDateRow, error) {
	rows, err := q.db.QueryContext(ctx, powerLogForDeviceToDate, arg.Tag, arg.FromTime, arg.ToTime)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []PowerLogForDeviceToDateRow
	for rows.Next() {
		var i PowerLogForDeviceToDateRow
		if err := rows.Scan(
			&i.ID,
			&i.Time,
			&i.Sensor,
			&i.TotalStartTime,
			&i.Total,
			&i.Yesterday,
			&i.Today,
			&i.Period,
			&i.Power,
			&i.ApparentPower,
			&i.ReactivePower,
			&i.Factor,
			&i.Voltage,
			&i.Current,
			&i.SensorTemperature,
			&i.ID_2,
			&i.DeviceName,
			&i.Tag,
		); 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 switchStateLogForDeviceToDate = `-- name: SwitchStateLogForDeviceToDate :many
select switch_state_log.id, time, sensor, switch_state, device_tag.id, device_name, tag
from switch_state_log
         join device_tag on device_name = switch_state_log.sensor
where device_tag.tag = ?
  and (time between ? and ?)
order by time desc
`

type SwitchStateLogForDeviceToDateParams struct {
	Tag      string
	FromTime time.Time
	ToTime   time.Time
}

type SwitchStateLogForDeviceToDateRow struct {
	ID          int64
	Time        time.Time
	Sensor      string
	SwitchState string
	ID_2        int64
	DeviceName  string
	Tag         string
}

func (q *Queries) SwitchStateLogForDeviceToDate(ctx context.Context, arg SwitchStateLogForDeviceToDateParams) ([]SwitchStateLogForDeviceToDateRow, error) {
	rows, err := q.db.QueryContext(ctx, switchStateLogForDeviceToDate, arg.Tag, arg.FromTime, arg.ToTime)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []SwitchStateLogForDeviceToDateRow
	for rows.Next() {
		var i SwitchStateLogForDeviceToDateRow
		if err := rows.Scan(
			&i.ID,
			&i.Time,
			&i.Sensor,
			&i.SwitchState,
			&i.ID_2,
			&i.DeviceName,
			&i.Tag,
		); 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 truncateDeviceTag = `-- name: TruncateDeviceTag :exec
delete from device_tag
`

func (q *Queries) TruncateDeviceTag(ctx context.Context) error {
	_, err := q.db.ExecContext(ctx, truncateDeviceTag)
	return err
}

const updateDeviceTag = `-- name: UpdateDeviceTag :one
UPDATE device_tag
set device_name = ?,
    tag = ?
WHERE id = ?
RETURNING id, device_name, tag
`

type UpdateDeviceTagParams struct {
	DeviceName string
	Tag        string
	ID         int64
}

func (q *Queries) UpdateDeviceTag(ctx context.Context, arg UpdateDeviceTagParams) (DeviceTag, error) {
	row := q.db.QueryRowContext(ctx, updateDeviceTag, arg.DeviceName, arg.Tag, arg.ID)
	var i DeviceTag
	err := row.Scan(&i.ID, &i.DeviceName, &i.Tag)
	return i, err
}