// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.27.0
// source: query.sql

package queries

import (
	"context"
	"database/sql"
)

const createEvent = `-- name: CreateEvent :one
INSERT INTO "Events" (
    "CloudId", "Source", "EventTime", "ChainId", "VmId", "EventKey", "Datacenter", "ComputeResource", "UserName"
) VALUES(
    ?, ?, ?, ?, ?, ?, ?, ?, ?
)
RETURNING Eid, CloudId, Source, EventTime, ChainId, VmId, EventKey, Datacenter, ComputeResource, UserName, Processed
`

type CreateEventParams struct {
	CloudId         string
	Source          string
	EventTime       sql.NullInt64
	ChainId         string
	VmId            sql.NullString
	EventKey        sql.NullString
	Datacenter      sql.NullString
	ComputeResource sql.NullString
	UserName        sql.NullString
}

func (q *Queries) CreateEvent(ctx context.Context, arg CreateEventParams) (Events, error) {
	row := q.db.QueryRowContext(ctx, createEvent,
		arg.CloudId,
		arg.Source,
		arg.EventTime,
		arg.ChainId,
		arg.VmId,
		arg.EventKey,
		arg.Datacenter,
		arg.ComputeResource,
		arg.UserName,
	)
	var i Events
	err := row.Scan(
		&i.Eid,
		&i.CloudId,
		&i.Source,
		&i.EventTime,
		&i.ChainId,
		&i.VmId,
		&i.EventKey,
		&i.Datacenter,
		&i.ComputeResource,
		&i.UserName,
		&i.Processed,
	)
	return i, err
}

const createInventory = `-- name: CreateInventory :one
INSERT INTO "Inventory" (
    "Name", "Vcenter", "VmId", "EventKey", "EventId", "CreationTime", "ResourcePool", "VmType", "Datacenter", "Cluster", "Folder", "ProvisionedDisk", "InitialVcpus", "InitialRam", "SrmPlaceholder"
) VALUES(
    ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?
)
RETURNING Iid, Name, Vcenter, VmId, EventKey, EventId, CreationTime, DeletionTime, ResourcePool, VmType, Datacenter, Cluster, Folder, ProvisionedDisk, InitialVcpus, InitialRam, SrmPlaceholder
`

type CreateInventoryParams struct {
	Name            string
	Vcenter         string
	VmId            sql.NullString
	EventKey        sql.NullString
	EventId         sql.NullString
	CreationTime    sql.NullInt64
	ResourcePool    sql.NullString
	VmType          sql.NullString
	Datacenter      sql.NullString
	Cluster         sql.NullString
	Folder          sql.NullString
	ProvisionedDisk sql.NullFloat64
	InitialVcpus    sql.NullInt64
	InitialRam      sql.NullInt64
	SrmPlaceholder  sql.NullInt64
}

func (q *Queries) CreateInventory(ctx context.Context, arg CreateInventoryParams) (Inventory, error) {
	row := q.db.QueryRowContext(ctx, createInventory,
		arg.Name,
		arg.Vcenter,
		arg.VmId,
		arg.EventKey,
		arg.EventId,
		arg.CreationTime,
		arg.ResourcePool,
		arg.VmType,
		arg.Datacenter,
		arg.Cluster,
		arg.Folder,
		arg.ProvisionedDisk,
		arg.InitialVcpus,
		arg.InitialRam,
		arg.SrmPlaceholder,
	)
	var i Inventory
	err := row.Scan(
		&i.Iid,
		&i.Name,
		&i.Vcenter,
		&i.VmId,
		&i.EventKey,
		&i.EventId,
		&i.CreationTime,
		&i.DeletionTime,
		&i.ResourcePool,
		&i.VmType,
		&i.Datacenter,
		&i.Cluster,
		&i.Folder,
		&i.ProvisionedDisk,
		&i.InitialVcpus,
		&i.InitialRam,
		&i.SrmPlaceholder,
	)
	return i, err
}

const createUpdate = `-- name: CreateUpdate :one
INSERT INTO "Updates" (
    "InventoryId", "EventKey", "EventId", "UpdateTime", "UpdateType", "NewVcpus", "NewRam", "NewResourcePool"
) VALUES(
    ?, ?, ?, ?, ?, ?, ?, ?
)
RETURNING Uid, InventoryId, UpdateTime, UpdateType, NewVcpus, NewRam, NewResourcePool, EventKey, EventId
`

type CreateUpdateParams struct {
	InventoryId     sql.NullInt64
	EventKey        sql.NullString
	EventId         sql.NullString
	UpdateTime      sql.NullInt64
	UpdateType      string
	NewVcpus        sql.NullInt64
	NewRam          sql.NullInt64
	NewResourcePool sql.NullString
}

func (q *Queries) CreateUpdate(ctx context.Context, arg CreateUpdateParams) (Updates, error) {
	row := q.db.QueryRowContext(ctx, createUpdate,
		arg.InventoryId,
		arg.EventKey,
		arg.EventId,
		arg.UpdateTime,
		arg.UpdateType,
		arg.NewVcpus,
		arg.NewRam,
		arg.NewResourcePool,
	)
	var i Updates
	err := row.Scan(
		&i.Uid,
		&i.InventoryId,
		&i.UpdateTime,
		&i.UpdateType,
		&i.NewVcpus,
		&i.NewRam,
		&i.NewResourcePool,
		&i.EventKey,
		&i.EventId,
	)
	return i, err
}

const getInventoryByName = `-- name: GetInventoryByName :many
SELECT Iid, Name, Vcenter, VmId, EventKey, EventId, CreationTime, DeletionTime, ResourcePool, VmType, Datacenter, Cluster, Folder, ProvisionedDisk, InitialVcpus, InitialRam, SrmPlaceholder FROM "Inventory"
WHERE "Name" = ?
`

func (q *Queries) GetInventoryByName(ctx context.Context, name string) ([]Inventory, error) {
	rows, err := q.db.QueryContext(ctx, getInventoryByName, name)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Inventory
	for rows.Next() {
		var i Inventory
		if err := rows.Scan(
			&i.Iid,
			&i.Name,
			&i.Vcenter,
			&i.VmId,
			&i.EventKey,
			&i.EventId,
			&i.CreationTime,
			&i.DeletionTime,
			&i.ResourcePool,
			&i.VmType,
			&i.Datacenter,
			&i.Cluster,
			&i.Folder,
			&i.ProvisionedDisk,
			&i.InitialVcpus,
			&i.InitialRam,
			&i.SrmPlaceholder,
		); 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 getInventoryEventId = `-- name: GetInventoryEventId :one
SELECT Iid, Name, Vcenter, VmId, EventKey, EventId, CreationTime, DeletionTime, ResourcePool, VmType, Datacenter, Cluster, Folder, ProvisionedDisk, InitialVcpus, InitialRam, SrmPlaceholder FROM "Inventory"
WHERE "EventId" = ? LIMIT 1
`

func (q *Queries) GetInventoryEventId(ctx context.Context, eventid sql.NullString) (Inventory, error) {
	row := q.db.QueryRowContext(ctx, getInventoryEventId, eventid)
	var i Inventory
	err := row.Scan(
		&i.Iid,
		&i.Name,
		&i.Vcenter,
		&i.VmId,
		&i.EventKey,
		&i.EventId,
		&i.CreationTime,
		&i.DeletionTime,
		&i.ResourcePool,
		&i.VmType,
		&i.Datacenter,
		&i.Cluster,
		&i.Folder,
		&i.ProvisionedDisk,
		&i.InitialVcpus,
		&i.InitialRam,
		&i.SrmPlaceholder,
	)
	return i, err
}

const getInventoryVmId = `-- name: GetInventoryVmId :one
SELECT Iid, Name, Vcenter, VmId, EventKey, EventId, CreationTime, DeletionTime, ResourcePool, VmType, Datacenter, Cluster, Folder, ProvisionedDisk, InitialVcpus, InitialRam, SrmPlaceholder FROM "Inventory"
WHERE "VmId" = ? LIMIT 1
`

func (q *Queries) GetInventoryVmId(ctx context.Context, vmid sql.NullString) (Inventory, error) {
	row := q.db.QueryRowContext(ctx, getInventoryVmId, vmid)
	var i Inventory
	err := row.Scan(
		&i.Iid,
		&i.Name,
		&i.Vcenter,
		&i.VmId,
		&i.EventKey,
		&i.EventId,
		&i.CreationTime,
		&i.DeletionTime,
		&i.ResourcePool,
		&i.VmType,
		&i.Datacenter,
		&i.Cluster,
		&i.Folder,
		&i.ProvisionedDisk,
		&i.InitialVcpus,
		&i.InitialRam,
		&i.SrmPlaceholder,
	)
	return i, err
}

const listEvents = `-- name: ListEvents :many
SELECT Eid, CloudId, Source, EventTime, ChainId, VmId, EventKey, Datacenter, ComputeResource, UserName, Processed FROM "Events"
ORDER BY "EventTime"
`

func (q *Queries) ListEvents(ctx context.Context) ([]Events, error) {
	rows, err := q.db.QueryContext(ctx, listEvents)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Events
	for rows.Next() {
		var i Events
		if err := rows.Scan(
			&i.Eid,
			&i.CloudId,
			&i.Source,
			&i.EventTime,
			&i.ChainId,
			&i.VmId,
			&i.EventKey,
			&i.Datacenter,
			&i.ComputeResource,
			&i.UserName,
			&i.Processed,
		); 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 listInventory = `-- name: ListInventory :many
SELECT Iid, Name, Vcenter, VmId, EventKey, EventId, CreationTime, DeletionTime, ResourcePool, VmType, Datacenter, Cluster, Folder, ProvisionedDisk, InitialVcpus, InitialRam, SrmPlaceholder FROM "Inventory"
ORDER BY "Name"
`

func (q *Queries) ListInventory(ctx context.Context) ([]Inventory, error) {
	rows, err := q.db.QueryContext(ctx, listInventory)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Inventory
	for rows.Next() {
		var i Inventory
		if err := rows.Scan(
			&i.Iid,
			&i.Name,
			&i.Vcenter,
			&i.VmId,
			&i.EventKey,
			&i.EventId,
			&i.CreationTime,
			&i.DeletionTime,
			&i.ResourcePool,
			&i.VmType,
			&i.Datacenter,
			&i.Cluster,
			&i.Folder,
			&i.ProvisionedDisk,
			&i.InitialVcpus,
			&i.InitialRam,
			&i.SrmPlaceholder,
		); 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 listUnprocessedEvents = `-- name: ListUnprocessedEvents :many
SELECT Eid, CloudId, Source, EventTime, ChainId, VmId, EventKey, Datacenter, ComputeResource, UserName, Processed FROM "Events"
WHERE "Processed" = 0
ORDER BY "EventTime"
`

func (q *Queries) ListUnprocessedEvents(ctx context.Context) ([]Events, error) {
	rows, err := q.db.QueryContext(ctx, listUnprocessedEvents)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []Events
	for rows.Next() {
		var i Events
		if err := rows.Scan(
			&i.Eid,
			&i.CloudId,
			&i.Source,
			&i.EventTime,
			&i.ChainId,
			&i.VmId,
			&i.EventKey,
			&i.Datacenter,
			&i.ComputeResource,
			&i.UserName,
			&i.Processed,
		); 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 updateEventsProcessed = `-- name: UpdateEventsProcessed :exec
UPDATE "Events"
SET "Processed" = 1
WHERE "Eid" = ?1
`

func (q *Queries) UpdateEventsProcessed(ctx context.Context, eid int64) error {
	_, err := q.db.ExecContext(ctx, updateEventsProcessed, eid)
	return err
}