682 lines
15 KiB
Go
682 lines
15 KiB
Go
// 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
|
|
}
|