// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.31.1
// source: metrics.sql

package sqlcdb

import (
	"context"
	"database/sql"
	"time"
)

const aggregateNodeMetrics = `-- name: AggregateNodeMetrics :many
SELECT date_bin($1::interval, timestamp, '2000-01-01'::timestamptz) AS bucket,
       AVG(cpu_usage)::float8 AS avg_cpu,
       AVG(memory_usage_percent)::float8 AS avg_memory,
       AVG(storage_usage_percent)::float8 AS avg_storage
FROM node_metrics
WHERE node_id = $2 AND timestamp BETWEEN $3 AND $4
GROUP BY bucket
ORDER BY bucket ASC
`

type AggregateNodeMetricsParams struct {
	Column1     int64     `json:"column_1"`
	NodeID      string    `json:"node_id"`
	Timestamp   time.Time `json:"timestamp"`
	Timestamp_2 time.Time `json:"timestamp_2"`
}

type AggregateNodeMetricsRow struct {
	Bucket     interface{} `json:"bucket"`
	AvgCpu     float64     `json:"avg_cpu"`
	AvgMemory  float64     `json:"avg_memory"`
	AvgStorage float64     `json:"avg_storage"`
}

// Portable bucket bucketing (no TimescaleDB): floor epoch seconds into
// bucket-sized buckets, then back to timestamptz.
func (q *Queries) AggregateNodeMetrics(ctx context.Context, arg AggregateNodeMetricsParams) ([]AggregateNodeMetricsRow, error) {
	rows, err := q.db.QueryContext(ctx, aggregateNodeMetrics,
		arg.Column1,
		arg.NodeID,
		arg.Timestamp,
		arg.Timestamp_2,
	)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []AggregateNodeMetricsRow{}
	for rows.Next() {
		var i AggregateNodeMetricsRow
		if err := rows.Scan(
			&i.Bucket,
			&i.AvgCpu,
			&i.AvgMemory,
			&i.AvgStorage,
		); 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 listInstanceMetrics = `-- name: ListInstanceMetrics :many
SELECT instance_id, node_id, status, cpu, memory,
       network_bytes_in, network_bytes_out, network_packets_in, network_packets_out,
       network_connections_in, network_connections_out, network_errors_in, network_errors_out,
       start_time, last_seen, health_status, health_last_check, health_check_count, health_failure_count
FROM instance_metrics
WHERE service_id = $1 AND timestamp = $2
`

type ListInstanceMetricsParams struct {
	ServiceID string    `json:"service_id"`
	Timestamp time.Time `json:"timestamp"`
}

type ListInstanceMetricsRow struct {
	InstanceID            string         `json:"instance_id"`
	NodeID                sql.NullString `json:"node_id"`
	Status                sql.NullString `json:"status"`
	Cpu                   sql.NullString `json:"cpu"`
	Memory                sql.NullInt64  `json:"memory"`
	NetworkBytesIn        sql.NullInt64  `json:"network_bytes_in"`
	NetworkBytesOut       sql.NullInt64  `json:"network_bytes_out"`
	NetworkPacketsIn      sql.NullInt64  `json:"network_packets_in"`
	NetworkPacketsOut     sql.NullInt64  `json:"network_packets_out"`
	NetworkConnectionsIn  sql.NullInt32  `json:"network_connections_in"`
	NetworkConnectionsOut sql.NullInt32  `json:"network_connections_out"`
	NetworkErrorsIn       sql.NullInt64  `json:"network_errors_in"`
	NetworkErrorsOut      sql.NullInt64  `json:"network_errors_out"`
	StartTime             sql.NullTime   `json:"start_time"`
	LastSeen              sql.NullTime   `json:"last_seen"`
	HealthStatus          sql.NullString `json:"health_status"`
	HealthLastCheck       sql.NullTime   `json:"health_last_check"`
	HealthCheckCount      sql.NullInt32  `json:"health_check_count"`
	HealthFailureCount    sql.NullInt32  `json:"health_failure_count"`
}

func (q *Queries) ListInstanceMetrics(ctx context.Context, arg ListInstanceMetricsParams) ([]ListInstanceMetricsRow, error) {
	rows, err := q.db.QueryContext(ctx, listInstanceMetrics, arg.ServiceID, arg.Timestamp)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListInstanceMetricsRow{}
	for rows.Next() {
		var i ListInstanceMetricsRow
		if err := rows.Scan(
			&i.InstanceID,
			&i.NodeID,
			&i.Status,
			&i.Cpu,
			&i.Memory,
			&i.NetworkBytesIn,
			&i.NetworkBytesOut,
			&i.NetworkPacketsIn,
			&i.NetworkPacketsOut,
			&i.NetworkConnectionsIn,
			&i.NetworkConnectionsOut,
			&i.NetworkErrorsIn,
			&i.NetworkErrorsOut,
			&i.StartTime,
			&i.LastSeen,
			&i.HealthStatus,
			&i.HealthLastCheck,
			&i.HealthCheckCount,
			&i.HealthFailureCount,
		); 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 listNodeMetrics = `-- name: ListNodeMetrics :many
SELECT node_id, timestamp, cpu_usage, cpu_cores, load_avg_1, load_avg_5, load_avg_15,
       memory_total, memory_used, memory_available, memory_usage_percent,
       storage_total, storage_used, storage_available, storage_usage_percent,
       network_bytes_in, network_bytes_out, network_packets_in, network_packets_out,
       network_connections_in, network_connections_out, network_errors_in, network_errors_out,
       coalesce(extract(epoch from uptime), 0)::bigint AS uptime_seconds,
       processes, os, kernel, architecture
FROM node_metrics
WHERE node_id = $1 AND timestamp BETWEEN $2 AND $3
ORDER BY timestamp ASC
`

type ListNodeMetricsParams struct {
	NodeID      string    `json:"node_id"`
	Timestamp   time.Time `json:"timestamp"`
	Timestamp_2 time.Time `json:"timestamp_2"`
}

type ListNodeMetricsRow struct {
	NodeID                string         `json:"node_id"`
	Timestamp             time.Time      `json:"timestamp"`
	CpuUsage              sql.NullString `json:"cpu_usage"`
	CpuCores              sql.NullString `json:"cpu_cores"`
	LoadAvg1              sql.NullString `json:"load_avg_1"`
	LoadAvg5              sql.NullString `json:"load_avg_5"`
	LoadAvg15             sql.NullString `json:"load_avg_15"`
	MemoryTotal           sql.NullInt64  `json:"memory_total"`
	MemoryUsed            sql.NullInt64  `json:"memory_used"`
	MemoryAvailable       sql.NullInt64  `json:"memory_available"`
	MemoryUsagePercent    sql.NullString `json:"memory_usage_percent"`
	StorageTotal          sql.NullInt64  `json:"storage_total"`
	StorageUsed           sql.NullInt64  `json:"storage_used"`
	StorageAvailable      sql.NullInt64  `json:"storage_available"`
	StorageUsagePercent   sql.NullString `json:"storage_usage_percent"`
	NetworkBytesIn        sql.NullInt64  `json:"network_bytes_in"`
	NetworkBytesOut       sql.NullInt64  `json:"network_bytes_out"`
	NetworkPacketsIn      sql.NullInt64  `json:"network_packets_in"`
	NetworkPacketsOut     sql.NullInt64  `json:"network_packets_out"`
	NetworkConnectionsIn  sql.NullInt32  `json:"network_connections_in"`
	NetworkConnectionsOut sql.NullInt32  `json:"network_connections_out"`
	NetworkErrorsIn       sql.NullInt64  `json:"network_errors_in"`
	NetworkErrorsOut      sql.NullInt64  `json:"network_errors_out"`
	UptimeSeconds         int64          `json:"uptime_seconds"`
	Processes             sql.NullInt32  `json:"processes"`
	Os                    sql.NullString `json:"os"`
	Kernel                sql.NullString `json:"kernel"`
	Architecture          sql.NullString `json:"architecture"`
}

func (q *Queries) ListNodeMetrics(ctx context.Context, arg ListNodeMetricsParams) ([]ListNodeMetricsRow, error) {
	rows, err := q.db.QueryContext(ctx, listNodeMetrics, arg.NodeID, arg.Timestamp, arg.Timestamp_2)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListNodeMetricsRow{}
	for rows.Next() {
		var i ListNodeMetricsRow
		if err := rows.Scan(
			&i.NodeID,
			&i.Timestamp,
			&i.CpuUsage,
			&i.CpuCores,
			&i.LoadAvg1,
			&i.LoadAvg5,
			&i.LoadAvg15,
			&i.MemoryTotal,
			&i.MemoryUsed,
			&i.MemoryAvailable,
			&i.MemoryUsagePercent,
			&i.StorageTotal,
			&i.StorageUsed,
			&i.StorageAvailable,
			&i.StorageUsagePercent,
			&i.NetworkBytesIn,
			&i.NetworkBytesOut,
			&i.NetworkPacketsIn,
			&i.NetworkPacketsOut,
			&i.NetworkConnectionsIn,
			&i.NetworkConnectionsOut,
			&i.NetworkErrorsIn,
			&i.NetworkErrorsOut,
			&i.UptimeSeconds,
			&i.Processes,
			&i.Os,
			&i.Kernel,
			&i.Architecture,
		); 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 listServiceMetrics = `-- name: ListServiceMetrics :many
SELECT service_id, service_name, project_id, timestamp,
       requests_total, requests_success, requests_errors, requests_avg_latency,
       requests_p95_latency, requests_p99_latency, requests_throughput,
       errors_total, errors_rate, performance_response_time, performance_throughput,
       performance_concurrency, performance_saturation, performance_utilization,
       resource_cpu_usage, resource_memory_usage, resource_storage_usage,
       resource_network_usage, resource_score
FROM service_metrics
WHERE service_id = $1 AND timestamp BETWEEN $2 AND $3
ORDER BY timestamp ASC
`

type ListServiceMetricsParams struct {
	ServiceID   string    `json:"service_id"`
	Timestamp   time.Time `json:"timestamp"`
	Timestamp_2 time.Time `json:"timestamp_2"`
}

type ListServiceMetricsRow struct {
	ServiceID               string         `json:"service_id"`
	ServiceName             string         `json:"service_name"`
	ProjectID               string         `json:"project_id"`
	Timestamp               time.Time      `json:"timestamp"`
	RequestsTotal           sql.NullInt64  `json:"requests_total"`
	RequestsSuccess         sql.NullInt64  `json:"requests_success"`
	RequestsErrors          sql.NullInt64  `json:"requests_errors"`
	RequestsAvgLatency      sql.NullString `json:"requests_avg_latency"`
	RequestsP95Latency      sql.NullString `json:"requests_p95_latency"`
	RequestsP99Latency      sql.NullString `json:"requests_p99_latency"`
	RequestsThroughput      sql.NullString `json:"requests_throughput"`
	ErrorsTotal             sql.NullInt64  `json:"errors_total"`
	ErrorsRate              sql.NullString `json:"errors_rate"`
	PerformanceResponseTime sql.NullString `json:"performance_response_time"`
	PerformanceThroughput   sql.NullString `json:"performance_throughput"`
	PerformanceConcurrency  sql.NullInt64  `json:"performance_concurrency"`
	PerformanceSaturation   sql.NullString `json:"performance_saturation"`
	PerformanceUtilization  sql.NullString `json:"performance_utilization"`
	ResourceCpuUsage        sql.NullString `json:"resource_cpu_usage"`
	ResourceMemoryUsage     sql.NullInt64  `json:"resource_memory_usage"`
	ResourceStorageUsage    sql.NullInt64  `json:"resource_storage_usage"`
	ResourceNetworkUsage    sql.NullInt64  `json:"resource_network_usage"`
	ResourceScore           sql.NullString `json:"resource_score"`
}

func (q *Queries) ListServiceMetrics(ctx context.Context, arg ListServiceMetricsParams) ([]ListServiceMetricsRow, error) {
	rows, err := q.db.QueryContext(ctx, listServiceMetrics, arg.ServiceID, arg.Timestamp, arg.Timestamp_2)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	items := []ListServiceMetricsRow{}
	for rows.Next() {
		var i ListServiceMetricsRow
		if err := rows.Scan(
			&i.ServiceID,
			&i.ServiceName,
			&i.ProjectID,
			&i.Timestamp,
			&i.RequestsTotal,
			&i.RequestsSuccess,
			&i.RequestsErrors,
			&i.RequestsAvgLatency,
			&i.RequestsP95Latency,
			&i.RequestsP99Latency,
			&i.RequestsThroughput,
			&i.ErrorsTotal,
			&i.ErrorsRate,
			&i.PerformanceResponseTime,
			&i.PerformanceThroughput,
			&i.PerformanceConcurrency,
			&i.PerformanceSaturation,
			&i.PerformanceUtilization,
			&i.ResourceCpuUsage,
			&i.ResourceMemoryUsage,
			&i.ResourceStorageUsage,
			&i.ResourceNetworkUsage,
			&i.ResourceScore,
		); 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 upsertInstanceMetrics = `-- name: UpsertInstanceMetrics :exec
INSERT INTO instance_metrics (
    service_id, timestamp, instance_id, node_id, status, cpu, memory,
    network_bytes_in, network_bytes_out, network_packets_in, network_packets_out,
    network_connections_in, network_connections_out, network_errors_in, network_errors_out,
    start_time, last_seen, health_status, health_last_check, health_check_count, health_failure_count
) VALUES (
    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15,
    $16, $17, $18, $19, $20, $21
)
ON CONFLICT (service_id, timestamp, instance_id) DO UPDATE SET
    node_id = EXCLUDED.node_id,
    status = EXCLUDED.status,
    cpu = EXCLUDED.cpu,
    memory = EXCLUDED.memory,
    network_bytes_in = EXCLUDED.network_bytes_in,
    network_bytes_out = EXCLUDED.network_bytes_out,
    network_packets_in = EXCLUDED.network_packets_in,
    network_packets_out = EXCLUDED.network_packets_out,
    network_connections_in = EXCLUDED.network_connections_in,
    network_connections_out = EXCLUDED.network_connections_out,
    network_errors_in = EXCLUDED.network_errors_in,
    network_errors_out = EXCLUDED.network_errors_out,
    start_time = EXCLUDED.start_time,
    last_seen = EXCLUDED.last_seen,
    health_status = EXCLUDED.health_status,
    health_last_check = EXCLUDED.health_last_check,
    health_check_count = EXCLUDED.health_check_count,
    health_failure_count = EXCLUDED.health_failure_count
`

type UpsertInstanceMetricsParams struct {
	ServiceID             string         `json:"service_id"`
	Timestamp             time.Time      `json:"timestamp"`
	InstanceID            string         `json:"instance_id"`
	NodeID                sql.NullString `json:"node_id"`
	Status                sql.NullString `json:"status"`
	Cpu                   sql.NullString `json:"cpu"`
	Memory                sql.NullInt64  `json:"memory"`
	NetworkBytesIn        sql.NullInt64  `json:"network_bytes_in"`
	NetworkBytesOut       sql.NullInt64  `json:"network_bytes_out"`
	NetworkPacketsIn      sql.NullInt64  `json:"network_packets_in"`
	NetworkPacketsOut     sql.NullInt64  `json:"network_packets_out"`
	NetworkConnectionsIn  sql.NullInt32  `json:"network_connections_in"`
	NetworkConnectionsOut sql.NullInt32  `json:"network_connections_out"`
	NetworkErrorsIn       sql.NullInt64  `json:"network_errors_in"`
	NetworkErrorsOut      sql.NullInt64  `json:"network_errors_out"`
	StartTime             sql.NullTime   `json:"start_time"`
	LastSeen              sql.NullTime   `json:"last_seen"`
	HealthStatus          sql.NullString `json:"health_status"`
	HealthLastCheck       sql.NullTime   `json:"health_last_check"`
	HealthCheckCount      sql.NullInt32  `json:"health_check_count"`
	HealthFailureCount    sql.NullInt32  `json:"health_failure_count"`
}

func (q *Queries) UpsertInstanceMetrics(ctx context.Context, arg UpsertInstanceMetricsParams) error {
	_, err := q.db.ExecContext(ctx, upsertInstanceMetrics,
		arg.ServiceID,
		arg.Timestamp,
		arg.InstanceID,
		arg.NodeID,
		arg.Status,
		arg.Cpu,
		arg.Memory,
		arg.NetworkBytesIn,
		arg.NetworkBytesOut,
		arg.NetworkPacketsIn,
		arg.NetworkPacketsOut,
		arg.NetworkConnectionsIn,
		arg.NetworkConnectionsOut,
		arg.NetworkErrorsIn,
		arg.NetworkErrorsOut,
		arg.StartTime,
		arg.LastSeen,
		arg.HealthStatus,
		arg.HealthLastCheck,
		arg.HealthCheckCount,
		arg.HealthFailureCount,
	)
	return err
}

const upsertNodeMetrics = `-- name: UpsertNodeMetrics :exec
INSERT INTO node_metrics (
    node_id, timestamp, cpu_usage, cpu_cores, load_avg_1, load_avg_5, load_avg_15,
    memory_total, memory_used, memory_available, memory_usage_percent,
    storage_total, storage_used, storage_available, storage_usage_percent,
    network_bytes_in, network_bytes_out, network_packets_in, network_packets_out,
    network_connections_in, network_connections_out, network_errors_in, network_errors_out,
    uptime, processes, os, kernel, architecture
) VALUES (
    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15,
    $16, $17, $18, $19, $20, $21, $22, $23, $24, $25, $26, $27, $28
)
ON CONFLICT (node_id, timestamp) DO UPDATE SET
    cpu_usage = EXCLUDED.cpu_usage,
    cpu_cores = EXCLUDED.cpu_cores,
    load_avg_1 = EXCLUDED.load_avg_1,
    load_avg_5 = EXCLUDED.load_avg_5,
    load_avg_15 = EXCLUDED.load_avg_15,
    memory_total = EXCLUDED.memory_total,
    memory_used = EXCLUDED.memory_used,
    memory_available = EXCLUDED.memory_available,
    memory_usage_percent = EXCLUDED.memory_usage_percent,
    storage_total = EXCLUDED.storage_total,
    storage_used = EXCLUDED.storage_used,
    storage_available = EXCLUDED.storage_available,
    storage_usage_percent = EXCLUDED.storage_usage_percent,
    network_bytes_in = EXCLUDED.network_bytes_in,
    network_bytes_out = EXCLUDED.network_bytes_out,
    network_packets_in = EXCLUDED.network_packets_in,
    network_packets_out = EXCLUDED.network_packets_out,
    network_connections_in = EXCLUDED.network_connections_in,
    network_connections_out = EXCLUDED.network_connections_out,
    network_errors_in = EXCLUDED.network_errors_in,
    network_errors_out = EXCLUDED.network_errors_out,
    uptime = EXCLUDED.uptime,
    processes = EXCLUDED.processes,
    os = EXCLUDED.os,
    kernel = EXCLUDED.kernel,
    architecture = EXCLUDED.architecture
`

type UpsertNodeMetricsParams struct {
	NodeID                string         `json:"node_id"`
	Timestamp             time.Time      `json:"timestamp"`
	CpuUsage              sql.NullString `json:"cpu_usage"`
	CpuCores              sql.NullString `json:"cpu_cores"`
	LoadAvg1              sql.NullString `json:"load_avg_1"`
	LoadAvg5              sql.NullString `json:"load_avg_5"`
	LoadAvg15             sql.NullString `json:"load_avg_15"`
	MemoryTotal           sql.NullInt64  `json:"memory_total"`
	MemoryUsed            sql.NullInt64  `json:"memory_used"`
	MemoryAvailable       sql.NullInt64  `json:"memory_available"`
	MemoryUsagePercent    sql.NullString `json:"memory_usage_percent"`
	StorageTotal          sql.NullInt64  `json:"storage_total"`
	StorageUsed           sql.NullInt64  `json:"storage_used"`
	StorageAvailable      sql.NullInt64  `json:"storage_available"`
	StorageUsagePercent   sql.NullString `json:"storage_usage_percent"`
	NetworkBytesIn        sql.NullInt64  `json:"network_bytes_in"`
	NetworkBytesOut       sql.NullInt64  `json:"network_bytes_out"`
	NetworkPacketsIn      sql.NullInt64  `json:"network_packets_in"`
	NetworkPacketsOut     sql.NullInt64  `json:"network_packets_out"`
	NetworkConnectionsIn  sql.NullInt32  `json:"network_connections_in"`
	NetworkConnectionsOut sql.NullInt32  `json:"network_connections_out"`
	NetworkErrorsIn       sql.NullInt64  `json:"network_errors_in"`
	NetworkErrorsOut      sql.NullInt64  `json:"network_errors_out"`
	Uptime                sql.NullInt64  `json:"uptime"`
	Processes             sql.NullInt32  `json:"processes"`
	Os                    sql.NullString `json:"os"`
	Kernel                sql.NullString `json:"kernel"`
	Architecture          sql.NullString `json:"architecture"`
}

func (q *Queries) UpsertNodeMetrics(ctx context.Context, arg UpsertNodeMetricsParams) error {
	_, err := q.db.ExecContext(ctx, upsertNodeMetrics,
		arg.NodeID,
		arg.Timestamp,
		arg.CpuUsage,
		arg.CpuCores,
		arg.LoadAvg1,
		arg.LoadAvg5,
		arg.LoadAvg15,
		arg.MemoryTotal,
		arg.MemoryUsed,
		arg.MemoryAvailable,
		arg.MemoryUsagePercent,
		arg.StorageTotal,
		arg.StorageUsed,
		arg.StorageAvailable,
		arg.StorageUsagePercent,
		arg.NetworkBytesIn,
		arg.NetworkBytesOut,
		arg.NetworkPacketsIn,
		arg.NetworkPacketsOut,
		arg.NetworkConnectionsIn,
		arg.NetworkConnectionsOut,
		arg.NetworkErrorsIn,
		arg.NetworkErrorsOut,
		arg.Uptime,
		arg.Processes,
		arg.Os,
		arg.Kernel,
		arg.Architecture,
	)
	return err
}

const upsertServiceMetrics = `-- name: UpsertServiceMetrics :exec
INSERT INTO service_metrics (
    service_id, service_name, project_id, timestamp,
    requests_total, requests_success, requests_errors, requests_avg_latency,
    requests_p95_latency, requests_p99_latency, requests_throughput,
    errors_total, errors_rate, performance_response_time, performance_throughput,
    performance_concurrency, performance_saturation, performance_utilization,
    resource_cpu_usage, resource_memory_usage, resource_storage_usage,
    resource_network_usage, resource_score
) VALUES (
    $1, $2, $3, $4, $5, $6, $7, $8, $9, $10, $11, $12, $13, $14, $15,
    $16, $17, $18, $19, $20, $21, $22, $23
)
ON CONFLICT (service_id, timestamp) DO UPDATE SET
    requests_total = EXCLUDED.requests_total,
    requests_success = EXCLUDED.requests_success,
    requests_errors = EXCLUDED.requests_errors,
    requests_avg_latency = EXCLUDED.requests_avg_latency,
    requests_p95_latency = EXCLUDED.requests_p95_latency,
    requests_p99_latency = EXCLUDED.requests_p99_latency,
    requests_throughput = EXCLUDED.requests_throughput,
    errors_total = EXCLUDED.errors_total,
    errors_rate = EXCLUDED.errors_rate,
    performance_response_time = EXCLUDED.performance_response_time,
    performance_throughput = EXCLUDED.performance_throughput,
    performance_concurrency = EXCLUDED.performance_concurrency,
    performance_saturation = EXCLUDED.performance_saturation,
    performance_utilization = EXCLUDED.performance_utilization,
    resource_cpu_usage = EXCLUDED.resource_cpu_usage,
    resource_memory_usage = EXCLUDED.resource_memory_usage,
    resource_storage_usage = EXCLUDED.resource_storage_usage,
    resource_network_usage = EXCLUDED.resource_network_usage,
    resource_score = EXCLUDED.resource_score
`

type UpsertServiceMetricsParams struct {
	ServiceID               string         `json:"service_id"`
	ServiceName             string         `json:"service_name"`
	ProjectID               string         `json:"project_id"`
	Timestamp               time.Time      `json:"timestamp"`
	RequestsTotal           sql.NullInt64  `json:"requests_total"`
	RequestsSuccess         sql.NullInt64  `json:"requests_success"`
	RequestsErrors          sql.NullInt64  `json:"requests_errors"`
	RequestsAvgLatency      sql.NullString `json:"requests_avg_latency"`
	RequestsP95Latency      sql.NullString `json:"requests_p95_latency"`
	RequestsP99Latency      sql.NullString `json:"requests_p99_latency"`
	RequestsThroughput      sql.NullString `json:"requests_throughput"`
	ErrorsTotal             sql.NullInt64  `json:"errors_total"`
	ErrorsRate              sql.NullString `json:"errors_rate"`
	PerformanceResponseTime sql.NullString `json:"performance_response_time"`
	PerformanceThroughput   sql.NullString `json:"performance_throughput"`
	PerformanceConcurrency  sql.NullInt64  `json:"performance_concurrency"`
	PerformanceSaturation   sql.NullString `json:"performance_saturation"`
	PerformanceUtilization  sql.NullString `json:"performance_utilization"`
	ResourceCpuUsage        sql.NullString `json:"resource_cpu_usage"`
	ResourceMemoryUsage     sql.NullInt64  `json:"resource_memory_usage"`
	ResourceStorageUsage    sql.NullInt64  `json:"resource_storage_usage"`
	ResourceNetworkUsage    sql.NullInt64  `json:"resource_network_usage"`
	ResourceScore           sql.NullString `json:"resource_score"`
}

func (q *Queries) UpsertServiceMetrics(ctx context.Context, arg UpsertServiceMetricsParams) error {
	_, err := q.db.ExecContext(ctx, upsertServiceMetrics,
		arg.ServiceID,
		arg.ServiceName,
		arg.ProjectID,
		arg.Timestamp,
		arg.RequestsTotal,
		arg.RequestsSuccess,
		arg.RequestsErrors,
		arg.RequestsAvgLatency,
		arg.RequestsP95Latency,
		arg.RequestsP99Latency,
		arg.RequestsThroughput,
		arg.ErrorsTotal,
		arg.ErrorsRate,
		arg.PerformanceResponseTime,
		arg.PerformanceThroughput,
		arg.PerformanceConcurrency,
		arg.PerformanceSaturation,
		arg.PerformanceUtilization,
		arg.ResourceCpuUsage,
		arg.ResourceMemoryUsage,
		arg.ResourceStorageUsage,
		arg.ResourceNetworkUsage,
		arg.ResourceScore,
	)
	return err
}