diff --git a/db/migrations/00008_skus.sql b/db/migrations/00008_skus.sql deleted file mode 100644 index d6c55a01..00000000 --- a/db/migrations/00008_skus.sql +++ /dev/null @@ -1,76 +0,0 @@ --- +goose Up --- +goose StatementBegin -CREATE TABLE public.server_sku ( - id UUID NOT NULL PRIMARY KEY DEFAULT gen_random_uuid(), - name STRING NOT NULL, - version STRING NOT NULL, - vendor STRING NOT NULL, - chassis STRING NOT NULL, - bmc_model STRING NOT NULL, - motherboard_model STRING NOT NULL, - cpu_vendor STRING NOT NULL, - cpu_model STRING NOT NULL, - cpu_cores INTEGER NOT NULL, - cpu_hertz BIGINT NOT NULL, - cpu_count INTEGER NOT NULL, - created_at TIMESTAMPTZ NULL, - updated_at TIMESTAMPTZ NULL, - UNIQUE (name, version) -); - -CREATE TABLE public.server_sku_disk ( - id UUID NOT NULL PRIMARY KEY DEFAULT gen_random_uuid(), - sku_id UUID NOT NULL REFERENCES public.server_sku(id) ON DELETE CASCADE, - vendor STRING NOT NULL, - model STRING NOT NULL, - bytes BIGINT NOT NULL, - protocol STRING NOT NULL, -- SATA vs NVMe vs PCIE - count INTEGER NOT NULL, - created_at TIMESTAMPTZ NULL, - updated_at TIMESTAMPTZ NULL -); - -CREATE TABLE public.server_sku_memory ( - id UUID NOT NULL PRIMARY KEY DEFAULT gen_random_uuid(), - sku_id UUID NOT NULL REFERENCES public.server_sku(id) ON DELETE CASCADE, - vendor STRING NOT NULL, - model STRING NOT NULL, - bytes BIGINT NOT NULL, - count INTEGER NOT NULL, - created_at TIMESTAMPTZ NULL, - updated_at TIMESTAMPTZ NULL -); - -CREATE TABLE public.server_sku_nic ( - id UUID NOT NULL PRIMARY KEY DEFAULT gen_random_uuid(), - sku_id UUID NOT NULL REFERENCES public.server_sku(id) ON DELETE CASCADE, - vendor STRING NOT NULL, - model STRING NOT NULL, - port_bandwidth BIGINT NOT NULL, - port_count INTEGER NOT NULL, - count INTEGER NOT NULL, - created_at TIMESTAMPTZ NULL, - updated_at TIMESTAMPTZ NULL -); - -CREATE TABLE public.server_sku_aux_device ( - id UUID NOT NULL PRIMARY KEY DEFAULT gen_random_uuid(), - sku_id UUID NOT NULL REFERENCES public.server_sku(id) ON DELETE CASCADE, - vendor STRING NOT NULL, - model STRING NOT NULL, - device_type STRING NOT NULL, -- GPU vs. other? - details JSON NOT NULL, - created_at TIMESTAMPTZ NULL, - updated_at TIMESTAMPTZ NULL -); - --- +goose StatementEnd - --- +goose Down --- +goose StatementBegin -DROP TABLE public.server_sku; -DROP TABLE public.server_sku_disk; -DROP TABLE public.server_sku_memory; -DROP TABLE public.server_sku_nic; -DROP TABLE public.server_sku_aux_device; --- +goose StatementEnd \ No newline at end of file diff --git a/internal/dbtools/fixtures.go b/internal/dbtools/fixtures.go index 4d6155aa..7ba93a55 100644 --- a/internal/dbtools/fixtures.go +++ b/internal/dbtools/fixtures.go @@ -101,12 +101,6 @@ var ( FixtureEventHistoryServer *models.Server FixtureEventHistoryRelatedID uuid.UUID FixtureEventHistories []*models.EventHistory - - FixtureServerSku *models.ServerSku - FixtureServerSkuAuxDevices []*models.ServerSkuAuxDevice - FixtureServerSkuDisks []*models.ServerSkuDisk - FixtureServerSkuMemory []*models.ServerSkuMemory - FixtureServerSkuNics []*models.ServerSkuNic ) func addFixtures(t *testing.T) error { @@ -189,10 +183,6 @@ func addFixtures(t *testing.T) error { return err } - if err := setupServerSku(ctx, testDB); err != nil { - return err - } - // excluding Chuckles here since that server is deleted FixtureServers = models.ServerSlice{FixtureNemo, FixtureDory, FixtureMarlin} FixtureDeletedServers = models.ServerSlice{FixtureChuckles} @@ -896,104 +886,3 @@ func setupConfigSet(ctx context.Context, db *sqlx.DB) error { return nil } - -//nolint:gomnd -func setupServerSku(ctx context.Context, db *sqlx.DB) error { - auxDevices := []*models.ServerSkuAuxDevice{ - { - Vendor: "Nvidia", - Model: "RTX 9090 TI", - DeviceType: "Dedicated GPU", - Details: []byte(`{}`), - }, - { - Vendor: "Quantis", - Model: "PCIe-240M", - DeviceType: "Other", - Details: []byte(`{"slot": 1,"chip": "IDQ20MC1","entropy-bandwidth": 240000000}`), - }, - } - - disks := []*models.ServerSkuDisk{ - { - Bytes: 100, - Protocol: "SATA", - Count: 2, - }, - { - Bytes: 10000, - Protocol: "NVMe", - Count: 1, - }, - { - Bytes: 2000000, - Protocol: "PCIE", - Count: 6, - }, - } - - memory := []*models.ServerSkuMemory{ - { - Bytes: 50, - Count: 2, - }, - { - Bytes: 500, - Count: 2, - }, - } - - nics := []*models.ServerSkuNic{ - { - PortBandwidth: 1000001, - PortCount: 4, - }, - } - - sku := &models.ServerSku{ - Name: "Cool Sku", - Version: "1.0", - Vendor: "CoolShop", - Chassis: "4U", - BMCModel: "1", - MotherboardModel: "Momboard 3000", - CPUVendor: "AMD", - CPUModel: "EPYC 9754S", - CPUCores: 128, - CPUHertz: 2250000000, - CPUCount: 2, - } - - err := sku.Insert(ctx, db, boil.Infer()) - if err != nil { - return err - } - - err = sku.AddSkuServerSkuAuxDevices(ctx, db, true, auxDevices...) - if err != nil { - return err - } - - err = sku.AddSkuServerSkuDisks(ctx, db, true, disks...) - if err != nil { - return err - } - - err = sku.AddSkuServerSkuMemories(ctx, db, true, memory...) - if err != nil { - return err - } - - err = sku.AddSkuServerSkuNics(ctx, db, true, nics...) - if err != nil { - return err - } - - FixtureServerSkuAuxDevices = auxDevices - FixtureServerSkuDisks = disks - FixtureServerSkuMemory = memory - FixtureServerSkuNics = nics - FixtureServerSku = sku - - return nil -} diff --git a/internal/dbtools/testtools.go b/internal/dbtools/testtools.go index 3c4b6dd1..4e9736fe 100644 --- a/internal/dbtools/testtools.go +++ b/internal/dbtools/testtools.go @@ -127,12 +127,6 @@ func cleanDB(t *testing.T) { deleteFixture(ctx, t, models.BiosConfigComponents()) deleteFixture(ctx, t, models.BiosConfigSets()) - deleteFixture(ctx, t, models.ServerSkuNics()) - deleteFixture(ctx, t, models.ServerSkuMemories()) - deleteFixture(ctx, t, models.ServerSkuDisks()) - deleteFixture(ctx, t, models.ServerSkuAuxDevices()) - deleteFixture(ctx, t, models.ServerSkus()) - testDB.Exec("SET sql_safe_updates = true;") } diff --git a/internal/models/boil_suites_test.go b/internal/models/boil_suites_test.go index ce870b2c..14f2537e 100644 --- a/internal/models/boil_suites_test.go +++ b/internal/models/boil_suites_test.go @@ -28,11 +28,6 @@ func TestParent(t *testing.T) { t.Run("ServerComponents", testServerComponents) t.Run("ServerCredentialTypes", testServerCredentialTypes) t.Run("ServerCredentials", testServerCredentials) - t.Run("ServerSkus", testServerSkus) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevices) - t.Run("ServerSkuDisks", testServerSkuDisks) - t.Run("ServerSkuMemories", testServerSkuMemories) - t.Run("ServerSkuNics", testServerSkuNics) t.Run("Servers", testServers) t.Run("VersionedAttributes", testVersionedAttributes) } @@ -66,11 +61,6 @@ func TestDelete(t *testing.T) { t.Run("ServerComponents", testServerComponentsDelete) t.Run("ServerCredentialTypes", testServerCredentialTypesDelete) t.Run("ServerCredentials", testServerCredentialsDelete) - t.Run("ServerSkus", testServerSkusDelete) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesDelete) - t.Run("ServerSkuDisks", testServerSkuDisksDelete) - t.Run("ServerSkuMemories", testServerSkuMemoriesDelete) - t.Run("ServerSkuNics", testServerSkuNicsDelete) t.Run("Servers", testServersDelete) t.Run("VersionedAttributes", testVersionedAttributesDelete) } @@ -92,11 +82,6 @@ func TestQueryDeleteAll(t *testing.T) { t.Run("ServerComponents", testServerComponentsQueryDeleteAll) t.Run("ServerCredentialTypes", testServerCredentialTypesQueryDeleteAll) t.Run("ServerCredentials", testServerCredentialsQueryDeleteAll) - t.Run("ServerSkus", testServerSkusQueryDeleteAll) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesQueryDeleteAll) - t.Run("ServerSkuDisks", testServerSkuDisksQueryDeleteAll) - t.Run("ServerSkuMemories", testServerSkuMemoriesQueryDeleteAll) - t.Run("ServerSkuNics", testServerSkuNicsQueryDeleteAll) t.Run("Servers", testServersQueryDeleteAll) t.Run("VersionedAttributes", testVersionedAttributesQueryDeleteAll) } @@ -118,11 +103,6 @@ func TestSliceDeleteAll(t *testing.T) { t.Run("ServerComponents", testServerComponentsSliceDeleteAll) t.Run("ServerCredentialTypes", testServerCredentialTypesSliceDeleteAll) t.Run("ServerCredentials", testServerCredentialsSliceDeleteAll) - t.Run("ServerSkus", testServerSkusSliceDeleteAll) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesSliceDeleteAll) - t.Run("ServerSkuDisks", testServerSkuDisksSliceDeleteAll) - t.Run("ServerSkuMemories", testServerSkuMemoriesSliceDeleteAll) - t.Run("ServerSkuNics", testServerSkuNicsSliceDeleteAll) t.Run("Servers", testServersSliceDeleteAll) t.Run("VersionedAttributes", testVersionedAttributesSliceDeleteAll) } @@ -144,11 +124,6 @@ func TestExists(t *testing.T) { t.Run("ServerComponents", testServerComponentsExists) t.Run("ServerCredentialTypes", testServerCredentialTypesExists) t.Run("ServerCredentials", testServerCredentialsExists) - t.Run("ServerSkus", testServerSkusExists) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesExists) - t.Run("ServerSkuDisks", testServerSkuDisksExists) - t.Run("ServerSkuMemories", testServerSkuMemoriesExists) - t.Run("ServerSkuNics", testServerSkuNicsExists) t.Run("Servers", testServersExists) t.Run("VersionedAttributes", testVersionedAttributesExists) } @@ -170,11 +145,6 @@ func TestFind(t *testing.T) { t.Run("ServerComponents", testServerComponentsFind) t.Run("ServerCredentialTypes", testServerCredentialTypesFind) t.Run("ServerCredentials", testServerCredentialsFind) - t.Run("ServerSkus", testServerSkusFind) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesFind) - t.Run("ServerSkuDisks", testServerSkuDisksFind) - t.Run("ServerSkuMemories", testServerSkuMemoriesFind) - t.Run("ServerSkuNics", testServerSkuNicsFind) t.Run("Servers", testServersFind) t.Run("VersionedAttributes", testVersionedAttributesFind) } @@ -196,11 +166,6 @@ func TestBind(t *testing.T) { t.Run("ServerComponents", testServerComponentsBind) t.Run("ServerCredentialTypes", testServerCredentialTypesBind) t.Run("ServerCredentials", testServerCredentialsBind) - t.Run("ServerSkus", testServerSkusBind) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesBind) - t.Run("ServerSkuDisks", testServerSkuDisksBind) - t.Run("ServerSkuMemories", testServerSkuMemoriesBind) - t.Run("ServerSkuNics", testServerSkuNicsBind) t.Run("Servers", testServersBind) t.Run("VersionedAttributes", testVersionedAttributesBind) } @@ -222,11 +187,6 @@ func TestOne(t *testing.T) { t.Run("ServerComponents", testServerComponentsOne) t.Run("ServerCredentialTypes", testServerCredentialTypesOne) t.Run("ServerCredentials", testServerCredentialsOne) - t.Run("ServerSkus", testServerSkusOne) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesOne) - t.Run("ServerSkuDisks", testServerSkuDisksOne) - t.Run("ServerSkuMemories", testServerSkuMemoriesOne) - t.Run("ServerSkuNics", testServerSkuNicsOne) t.Run("Servers", testServersOne) t.Run("VersionedAttributes", testVersionedAttributesOne) } @@ -248,11 +208,6 @@ func TestAll(t *testing.T) { t.Run("ServerComponents", testServerComponentsAll) t.Run("ServerCredentialTypes", testServerCredentialTypesAll) t.Run("ServerCredentials", testServerCredentialsAll) - t.Run("ServerSkus", testServerSkusAll) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesAll) - t.Run("ServerSkuDisks", testServerSkuDisksAll) - t.Run("ServerSkuMemories", testServerSkuMemoriesAll) - t.Run("ServerSkuNics", testServerSkuNicsAll) t.Run("Servers", testServersAll) t.Run("VersionedAttributes", testVersionedAttributesAll) } @@ -274,11 +229,6 @@ func TestCount(t *testing.T) { t.Run("ServerComponents", testServerComponentsCount) t.Run("ServerCredentialTypes", testServerCredentialTypesCount) t.Run("ServerCredentials", testServerCredentialsCount) - t.Run("ServerSkus", testServerSkusCount) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesCount) - t.Run("ServerSkuDisks", testServerSkuDisksCount) - t.Run("ServerSkuMemories", testServerSkuMemoriesCount) - t.Run("ServerSkuNics", testServerSkuNicsCount) t.Run("Servers", testServersCount) t.Run("VersionedAttributes", testVersionedAttributesCount) } @@ -300,11 +250,6 @@ func TestHooks(t *testing.T) { t.Run("ServerComponents", testServerComponentsHooks) t.Run("ServerCredentialTypes", testServerCredentialTypesHooks) t.Run("ServerCredentials", testServerCredentialsHooks) - t.Run("ServerSkus", testServerSkusHooks) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesHooks) - t.Run("ServerSkuDisks", testServerSkuDisksHooks) - t.Run("ServerSkuMemories", testServerSkuMemoriesHooks) - t.Run("ServerSkuNics", testServerSkuNicsHooks) t.Run("Servers", testServersHooks) t.Run("VersionedAttributes", testVersionedAttributesHooks) } @@ -342,16 +287,6 @@ func TestInsert(t *testing.T) { t.Run("ServerCredentialTypes", testServerCredentialTypesInsertWhitelist) t.Run("ServerCredentials", testServerCredentialsInsert) t.Run("ServerCredentials", testServerCredentialsInsertWhitelist) - t.Run("ServerSkus", testServerSkusInsert) - t.Run("ServerSkus", testServerSkusInsertWhitelist) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesInsert) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesInsertWhitelist) - t.Run("ServerSkuDisks", testServerSkuDisksInsert) - t.Run("ServerSkuDisks", testServerSkuDisksInsertWhitelist) - t.Run("ServerSkuMemories", testServerSkuMemoriesInsert) - t.Run("ServerSkuMemories", testServerSkuMemoriesInsertWhitelist) - t.Run("ServerSkuNics", testServerSkuNicsInsert) - t.Run("ServerSkuNics", testServerSkuNicsInsertWhitelist) t.Run("Servers", testServersInsert) t.Run("Servers", testServersInsertWhitelist) t.Run("VersionedAttributes", testVersionedAttributesInsert) @@ -375,10 +310,6 @@ func TestToOne(t *testing.T) { t.Run("ServerComponentToServerComponentTypeUsingServerComponentType", testServerComponentToOneServerComponentTypeUsingServerComponentType) t.Run("ServerCredentialToServerCredentialTypeUsingServerCredentialType", testServerCredentialToOneServerCredentialTypeUsingServerCredentialType) t.Run("ServerCredentialToServerUsingServer", testServerCredentialToOneServerUsingServer) - t.Run("ServerSkuAuxDeviceToServerSkuUsingSku", testServerSkuAuxDeviceToOneServerSkuUsingSku) - t.Run("ServerSkuDiskToServerSkuUsingSku", testServerSkuDiskToOneServerSkuUsingSku) - t.Run("ServerSkuMemoryToServerSkuUsingSku", testServerSkuMemoryToOneServerSkuUsingSku) - t.Run("ServerSkuNicToServerSkuUsingSku", testServerSkuNicToOneServerSkuUsingSku) t.Run("VersionedAttributeToServerUsingServer", testVersionedAttributeToOneServerUsingServer) t.Run("VersionedAttributeToServerComponentUsingServerComponent", testVersionedAttributeToOneServerComponentUsingServerComponent) } @@ -401,10 +332,6 @@ func TestToMany(t *testing.T) { t.Run("ServerComponentToAttributes", testServerComponentToManyAttributes) t.Run("ServerComponentToVersionedAttributes", testServerComponentToManyVersionedAttributes) t.Run("ServerCredentialTypeToServerCredentials", testServerCredentialTypeToManyServerCredentials) - t.Run("ServerSkuToSkuServerSkuAuxDevices", testServerSkuToManySkuServerSkuAuxDevices) - t.Run("ServerSkuToSkuServerSkuDisks", testServerSkuToManySkuServerSkuDisks) - t.Run("ServerSkuToSkuServerSkuMemories", testServerSkuToManySkuServerSkuMemories) - t.Run("ServerSkuToSkuServerSkuNics", testServerSkuToManySkuServerSkuNics) t.Run("ServerToAttributes", testServerToManyAttributes) t.Run("ServerToTargetServerEventHistories", testServerToManyTargetServerEventHistories) t.Run("ServerToServerComponents", testServerToManyServerComponents) @@ -429,10 +356,6 @@ func TestToOneSet(t *testing.T) { t.Run("ServerComponentToServerComponentTypeUsingServerComponents", testServerComponentToOneSetOpServerComponentTypeUsingServerComponentType) t.Run("ServerCredentialToServerCredentialTypeUsingServerCredentials", testServerCredentialToOneSetOpServerCredentialTypeUsingServerCredentialType) t.Run("ServerCredentialToServerUsingServerCredentials", testServerCredentialToOneSetOpServerUsingServer) - t.Run("ServerSkuAuxDeviceToServerSkuUsingSkuServerSkuAuxDevices", testServerSkuAuxDeviceToOneSetOpServerSkuUsingSku) - t.Run("ServerSkuDiskToServerSkuUsingSkuServerSkuDisks", testServerSkuDiskToOneSetOpServerSkuUsingSku) - t.Run("ServerSkuMemoryToServerSkuUsingSkuServerSkuMemories", testServerSkuMemoryToOneSetOpServerSkuUsingSku) - t.Run("ServerSkuNicToServerSkuUsingSkuServerSkuNics", testServerSkuNicToOneSetOpServerSkuUsingSku) t.Run("VersionedAttributeToServerUsingVersionedAttributes", testVersionedAttributeToOneSetOpServerUsingServer) t.Run("VersionedAttributeToServerComponentUsingVersionedAttributes", testVersionedAttributeToOneSetOpServerComponentUsingServerComponent) } @@ -469,10 +392,6 @@ func TestToManyAdd(t *testing.T) { t.Run("ServerComponentToAttributes", testServerComponentToManyAddOpAttributes) t.Run("ServerComponentToVersionedAttributes", testServerComponentToManyAddOpVersionedAttributes) t.Run("ServerCredentialTypeToServerCredentials", testServerCredentialTypeToManyAddOpServerCredentials) - t.Run("ServerSkuToSkuServerSkuAuxDevices", testServerSkuToManyAddOpSkuServerSkuAuxDevices) - t.Run("ServerSkuToSkuServerSkuDisks", testServerSkuToManyAddOpSkuServerSkuDisks) - t.Run("ServerSkuToSkuServerSkuMemories", testServerSkuToManyAddOpSkuServerSkuMemories) - t.Run("ServerSkuToSkuServerSkuNics", testServerSkuToManyAddOpSkuServerSkuNics) t.Run("ServerToAttributes", testServerToManyAddOpAttributes) t.Run("ServerToTargetServerEventHistories", testServerToManyAddOpTargetServerEventHistories) t.Run("ServerToServerComponents", testServerToManyAddOpServerComponents) @@ -517,11 +436,6 @@ func TestReload(t *testing.T) { t.Run("ServerComponents", testServerComponentsReload) t.Run("ServerCredentialTypes", testServerCredentialTypesReload) t.Run("ServerCredentials", testServerCredentialsReload) - t.Run("ServerSkus", testServerSkusReload) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesReload) - t.Run("ServerSkuDisks", testServerSkuDisksReload) - t.Run("ServerSkuMemories", testServerSkuMemoriesReload) - t.Run("ServerSkuNics", testServerSkuNicsReload) t.Run("Servers", testServersReload) t.Run("VersionedAttributes", testVersionedAttributesReload) } @@ -543,11 +457,6 @@ func TestReloadAll(t *testing.T) { t.Run("ServerComponents", testServerComponentsReloadAll) t.Run("ServerCredentialTypes", testServerCredentialTypesReloadAll) t.Run("ServerCredentials", testServerCredentialsReloadAll) - t.Run("ServerSkus", testServerSkusReloadAll) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesReloadAll) - t.Run("ServerSkuDisks", testServerSkuDisksReloadAll) - t.Run("ServerSkuMemories", testServerSkuMemoriesReloadAll) - t.Run("ServerSkuNics", testServerSkuNicsReloadAll) t.Run("Servers", testServersReloadAll) t.Run("VersionedAttributes", testVersionedAttributesReloadAll) } @@ -569,11 +478,6 @@ func TestSelect(t *testing.T) { t.Run("ServerComponents", testServerComponentsSelect) t.Run("ServerCredentialTypes", testServerCredentialTypesSelect) t.Run("ServerCredentials", testServerCredentialsSelect) - t.Run("ServerSkus", testServerSkusSelect) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesSelect) - t.Run("ServerSkuDisks", testServerSkuDisksSelect) - t.Run("ServerSkuMemories", testServerSkuMemoriesSelect) - t.Run("ServerSkuNics", testServerSkuNicsSelect) t.Run("Servers", testServersSelect) t.Run("VersionedAttributes", testVersionedAttributesSelect) } @@ -595,11 +499,6 @@ func TestUpdate(t *testing.T) { t.Run("ServerComponents", testServerComponentsUpdate) t.Run("ServerCredentialTypes", testServerCredentialTypesUpdate) t.Run("ServerCredentials", testServerCredentialsUpdate) - t.Run("ServerSkus", testServerSkusUpdate) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesUpdate) - t.Run("ServerSkuDisks", testServerSkuDisksUpdate) - t.Run("ServerSkuMemories", testServerSkuMemoriesUpdate) - t.Run("ServerSkuNics", testServerSkuNicsUpdate) t.Run("Servers", testServersUpdate) t.Run("VersionedAttributes", testVersionedAttributesUpdate) } @@ -621,11 +520,6 @@ func TestSliceUpdateAll(t *testing.T) { t.Run("ServerComponents", testServerComponentsSliceUpdateAll) t.Run("ServerCredentialTypes", testServerCredentialTypesSliceUpdateAll) t.Run("ServerCredentials", testServerCredentialsSliceUpdateAll) - t.Run("ServerSkus", testServerSkusSliceUpdateAll) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesSliceUpdateAll) - t.Run("ServerSkuDisks", testServerSkuDisksSliceUpdateAll) - t.Run("ServerSkuMemories", testServerSkuMemoriesSliceUpdateAll) - t.Run("ServerSkuNics", testServerSkuNicsSliceUpdateAll) t.Run("Servers", testServersSliceUpdateAll) t.Run("VersionedAttributes", testVersionedAttributesSliceUpdateAll) } diff --git a/internal/models/boil_table_names.go b/internal/models/boil_table_names.go index 81dafb8c..ec7ae292 100644 --- a/internal/models/boil_table_names.go +++ b/internal/models/boil_table_names.go @@ -20,11 +20,6 @@ var TableNames = struct { ServerComponents string ServerCredentialTypes string ServerCredentials string - ServerSku string - ServerSkuAuxDevice string - ServerSkuDisk string - ServerSkuMemory string - ServerSkuNic string Servers string VersionedAttributes string }{ @@ -44,11 +39,6 @@ var TableNames = struct { ServerComponents: "server_components", ServerCredentialTypes: "server_credential_types", ServerCredentials: "server_credentials", - ServerSku: "server_sku", - ServerSkuAuxDevice: "server_sku_aux_device", - ServerSkuDisk: "server_sku_disk", - ServerSkuMemory: "server_sku_memory", - ServerSkuNic: "server_sku_nic", Servers: "servers", VersionedAttributes: "versioned_attributes", } diff --git a/internal/models/crdb_main_test.go b/internal/models/crdb_main_test.go index efe37c31..aa5a73c0 100644 --- a/internal/models/crdb_main_test.go +++ b/internal/models/crdb_main_test.go @@ -74,14 +74,14 @@ func (c *crdbTester) setup() error { createCmd.Stdin = newShowCreateTableFilter(newFKeyDestroyer(rgxCDBFkey, r)) if err = dumpCmd.Start(); err != nil { - return errors.Wrap(err, "failed to start cockroach show-create command") + return errors.Wrap(err, "failed to start 'cockroach dump' command") } if err = createCmd.Start(); err != nil { - return errors.Wrap(err, "failed to start 'cockroach sql' command for db create") + return errors.Wrap(err, "failed to start 'cockroach sql' command") } if err = dumpCmd.Wait(); err != nil { - return errors.Wrap(err, "failed to wait for cockroach show-create command") + return errors.Wrap(err, "failed to wait for dump 'cockroach sql' command") } // After dumpCmd is done, close the write end of the pipe @@ -90,7 +90,7 @@ func (c *crdbTester) setup() error { } if err = createCmd.Wait(); err != nil { - return errors.Wrap(err, "failed to wait for 'cockroach sql' command for db create") + return errors.Wrap(err, "failed to wait for create 'cockroach sql' command") } return nil diff --git a/internal/models/crdb_suites_test.go b/internal/models/crdb_suites_test.go index 328ca383..c2c55107 100644 --- a/internal/models/crdb_suites_test.go +++ b/internal/models/crdb_suites_test.go @@ -22,11 +22,6 @@ func TestUpsert(t *testing.T) { t.Run("ServerComponents", testServerComponentsUpsert) t.Run("ServerCredentialTypes", testServerCredentialTypesUpsert) t.Run("ServerCredentials", testServerCredentialsUpsert) - t.Run("ServerSkus", testServerSkusUpsert) - t.Run("ServerSkuAuxDevices", testServerSkuAuxDevicesUpsert) - t.Run("ServerSkuDisks", testServerSkuDisksUpsert) - t.Run("ServerSkuMemories", testServerSkuMemoriesUpsert) - t.Run("ServerSkuNics", testServerSkuNicsUpsert) t.Run("Servers", testServersUpsert) t.Run("VersionedAttributes", testVersionedAttributesUpsert) } diff --git a/internal/models/server_sku.go b/internal/models/server_sku.go deleted file mode 100644 index 6a1da044..00000000 --- a/internal/models/server_sku.go +++ /dev/null @@ -1,1791 +0,0 @@ -// Code generated by SQLBoiler 4.15.0 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT. -// This file is meant to be re-generated in place and/or deleted at any time. - -package models - -import ( - "context" - "database/sql" - "fmt" - "reflect" - "strconv" - "strings" - "sync" - "time" - - "github.com/friendsofgo/errors" - "github.com/volatiletech/null/v8" - "github.com/volatiletech/sqlboiler/v4/boil" - "github.com/volatiletech/sqlboiler/v4/queries" - "github.com/volatiletech/sqlboiler/v4/queries/qm" - "github.com/volatiletech/sqlboiler/v4/queries/qmhelper" - "github.com/volatiletech/strmangle" -) - -// ServerSku is an object representing the database table. -type ServerSku struct { - ID string `boil:"id" json:"id" toml:"id" yaml:"id"` - Name string `boil:"name" json:"name" toml:"name" yaml:"name"` - Version string `boil:"version" json:"version" toml:"version" yaml:"version"` - Vendor string `boil:"vendor" json:"vendor" toml:"vendor" yaml:"vendor"` - Chassis string `boil:"chassis" json:"chassis" toml:"chassis" yaml:"chassis"` - BMCModel string `boil:"bmc_model" json:"bmc_model" toml:"bmc_model" yaml:"bmc_model"` - MotherboardModel string `boil:"motherboard_model" json:"motherboard_model" toml:"motherboard_model" yaml:"motherboard_model"` - CPUVendor string `boil:"cpu_vendor" json:"cpu_vendor" toml:"cpu_vendor" yaml:"cpu_vendor"` - CPUModel string `boil:"cpu_model" json:"cpu_model" toml:"cpu_model" yaml:"cpu_model"` - CPUCores int64 `boil:"cpu_cores" json:"cpu_cores" toml:"cpu_cores" yaml:"cpu_cores"` - CPUHertz int64 `boil:"cpu_hertz" json:"cpu_hertz" toml:"cpu_hertz" yaml:"cpu_hertz"` - CPUCount int64 `boil:"cpu_count" json:"cpu_count" toml:"cpu_count" yaml:"cpu_count"` - CreatedAt null.Time `boil:"created_at" json:"created_at,omitempty" toml:"created_at" yaml:"created_at,omitempty"` - UpdatedAt null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"` - - R *serverSkuR `boil:"-" json:"-" toml:"-" yaml:"-"` - L serverSkuL `boil:"-" json:"-" toml:"-" yaml:"-"` -} - -var ServerSkuColumns = struct { - ID string - Name string - Version string - Vendor string - Chassis string - BMCModel string - MotherboardModel string - CPUVendor string - CPUModel string - CPUCores string - CPUHertz string - CPUCount string - CreatedAt string - UpdatedAt string -}{ - ID: "id", - Name: "name", - Version: "version", - Vendor: "vendor", - Chassis: "chassis", - BMCModel: "bmc_model", - MotherboardModel: "motherboard_model", - CPUVendor: "cpu_vendor", - CPUModel: "cpu_model", - CPUCores: "cpu_cores", - CPUHertz: "cpu_hertz", - CPUCount: "cpu_count", - CreatedAt: "created_at", - UpdatedAt: "updated_at", -} - -var ServerSkuTableColumns = struct { - ID string - Name string - Version string - Vendor string - Chassis string - BMCModel string - MotherboardModel string - CPUVendor string - CPUModel string - CPUCores string - CPUHertz string - CPUCount string - CreatedAt string - UpdatedAt string -}{ - ID: "server_sku.id", - Name: "server_sku.name", - Version: "server_sku.version", - Vendor: "server_sku.vendor", - Chassis: "server_sku.chassis", - BMCModel: "server_sku.bmc_model", - MotherboardModel: "server_sku.motherboard_model", - CPUVendor: "server_sku.cpu_vendor", - CPUModel: "server_sku.cpu_model", - CPUCores: "server_sku.cpu_cores", - CPUHertz: "server_sku.cpu_hertz", - CPUCount: "server_sku.cpu_count", - CreatedAt: "server_sku.created_at", - UpdatedAt: "server_sku.updated_at", -} - -// Generated where - -type whereHelperint64 struct{ field string } - -func (w whereHelperint64) EQ(x int64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.EQ, x) } -func (w whereHelperint64) NEQ(x int64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.NEQ, x) } -func (w whereHelperint64) LT(x int64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.LT, x) } -func (w whereHelperint64) LTE(x int64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.LTE, x) } -func (w whereHelperint64) GT(x int64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.GT, x) } -func (w whereHelperint64) GTE(x int64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.GTE, x) } -func (w whereHelperint64) IN(slice []int64) qm.QueryMod { - values := make([]interface{}, 0, len(slice)) - for _, value := range slice { - values = append(values, value) - } - return qm.WhereIn(fmt.Sprintf("%s IN ?", w.field), values...) -} -func (w whereHelperint64) NIN(slice []int64) qm.QueryMod { - values := make([]interface{}, 0, len(slice)) - for _, value := range slice { - values = append(values, value) - } - return qm.WhereNotIn(fmt.Sprintf("%s NOT IN ?", w.field), values...) -} - -var ServerSkuWhere = struct { - ID whereHelperstring - Name whereHelperstring - Version whereHelperstring - Vendor whereHelperstring - Chassis whereHelperstring - BMCModel whereHelperstring - MotherboardModel whereHelperstring - CPUVendor whereHelperstring - CPUModel whereHelperstring - CPUCores whereHelperint64 - CPUHertz whereHelperint64 - CPUCount whereHelperint64 - CreatedAt whereHelpernull_Time - UpdatedAt whereHelpernull_Time -}{ - ID: whereHelperstring{field: "\"server_sku\".\"id\""}, - Name: whereHelperstring{field: "\"server_sku\".\"name\""}, - Version: whereHelperstring{field: "\"server_sku\".\"version\""}, - Vendor: whereHelperstring{field: "\"server_sku\".\"vendor\""}, - Chassis: whereHelperstring{field: "\"server_sku\".\"chassis\""}, - BMCModel: whereHelperstring{field: "\"server_sku\".\"bmc_model\""}, - MotherboardModel: whereHelperstring{field: "\"server_sku\".\"motherboard_model\""}, - CPUVendor: whereHelperstring{field: "\"server_sku\".\"cpu_vendor\""}, - CPUModel: whereHelperstring{field: "\"server_sku\".\"cpu_model\""}, - CPUCores: whereHelperint64{field: "\"server_sku\".\"cpu_cores\""}, - CPUHertz: whereHelperint64{field: "\"server_sku\".\"cpu_hertz\""}, - CPUCount: whereHelperint64{field: "\"server_sku\".\"cpu_count\""}, - CreatedAt: whereHelpernull_Time{field: "\"server_sku\".\"created_at\""}, - UpdatedAt: whereHelpernull_Time{field: "\"server_sku\".\"updated_at\""}, -} - -// ServerSkuRels is where relationship names are stored. -var ServerSkuRels = struct { - SkuServerSkuAuxDevices string - SkuServerSkuDisks string - SkuServerSkuMemories string - SkuServerSkuNics string -}{ - SkuServerSkuAuxDevices: "SkuServerSkuAuxDevices", - SkuServerSkuDisks: "SkuServerSkuDisks", - SkuServerSkuMemories: "SkuServerSkuMemories", - SkuServerSkuNics: "SkuServerSkuNics", -} - -// serverSkuR is where relationships are stored. -type serverSkuR struct { - SkuServerSkuAuxDevices ServerSkuAuxDeviceSlice `boil:"SkuServerSkuAuxDevices" json:"SkuServerSkuAuxDevices" toml:"SkuServerSkuAuxDevices" yaml:"SkuServerSkuAuxDevices"` - SkuServerSkuDisks ServerSkuDiskSlice `boil:"SkuServerSkuDisks" json:"SkuServerSkuDisks" toml:"SkuServerSkuDisks" yaml:"SkuServerSkuDisks"` - SkuServerSkuMemories ServerSkuMemorySlice `boil:"SkuServerSkuMemories" json:"SkuServerSkuMemories" toml:"SkuServerSkuMemories" yaml:"SkuServerSkuMemories"` - SkuServerSkuNics ServerSkuNicSlice `boil:"SkuServerSkuNics" json:"SkuServerSkuNics" toml:"SkuServerSkuNics" yaml:"SkuServerSkuNics"` -} - -// NewStruct creates a new relationship struct -func (*serverSkuR) NewStruct() *serverSkuR { - return &serverSkuR{} -} - -func (r *serverSkuR) GetSkuServerSkuAuxDevices() ServerSkuAuxDeviceSlice { - if r == nil { - return nil - } - return r.SkuServerSkuAuxDevices -} - -func (r *serverSkuR) GetSkuServerSkuDisks() ServerSkuDiskSlice { - if r == nil { - return nil - } - return r.SkuServerSkuDisks -} - -func (r *serverSkuR) GetSkuServerSkuMemories() ServerSkuMemorySlice { - if r == nil { - return nil - } - return r.SkuServerSkuMemories -} - -func (r *serverSkuR) GetSkuServerSkuNics() ServerSkuNicSlice { - if r == nil { - return nil - } - return r.SkuServerSkuNics -} - -// serverSkuL is where Load methods for each relationship are stored. -type serverSkuL struct{} - -var ( - serverSkuAllColumns = []string{"id", "name", "version", "vendor", "chassis", "bmc_model", "motherboard_model", "cpu_vendor", "cpu_model", "cpu_cores", "cpu_hertz", "cpu_count", "created_at", "updated_at"} - serverSkuColumnsWithoutDefault = []string{"name", "version", "vendor", "chassis", "bmc_model", "motherboard_model", "cpu_vendor", "cpu_model", "cpu_cores", "cpu_hertz", "cpu_count"} - serverSkuColumnsWithDefault = []string{"id", "created_at", "updated_at"} - serverSkuPrimaryKeyColumns = []string{"id"} - serverSkuGeneratedColumns = []string{} -) - -type ( - // ServerSkuSlice is an alias for a slice of pointers to ServerSku. - // This should almost always be used instead of []ServerSku. - ServerSkuSlice []*ServerSku - // ServerSkuHook is the signature for custom ServerSku hook methods - ServerSkuHook func(context.Context, boil.ContextExecutor, *ServerSku) error - - serverSkuQuery struct { - *queries.Query - } -) - -// Cache for insert, update and upsert -var ( - serverSkuType = reflect.TypeOf(&ServerSku{}) - serverSkuMapping = queries.MakeStructMapping(serverSkuType) - serverSkuPrimaryKeyMapping, _ = queries.BindMapping(serverSkuType, serverSkuMapping, serverSkuPrimaryKeyColumns) - serverSkuInsertCacheMut sync.RWMutex - serverSkuInsertCache = make(map[string]insertCache) - serverSkuUpdateCacheMut sync.RWMutex - serverSkuUpdateCache = make(map[string]updateCache) - serverSkuUpsertCacheMut sync.RWMutex - serverSkuUpsertCache = make(map[string]insertCache) -) - -var ( - // Force time package dependency for automated UpdatedAt/CreatedAt. - _ = time.Second - // Force qmhelper dependency for where clause generation (which doesn't - // always happen) - _ = qmhelper.Where -) - -var serverSkuAfterSelectHooks []ServerSkuHook - -var serverSkuBeforeInsertHooks []ServerSkuHook -var serverSkuAfterInsertHooks []ServerSkuHook - -var serverSkuBeforeUpdateHooks []ServerSkuHook -var serverSkuAfterUpdateHooks []ServerSkuHook - -var serverSkuBeforeDeleteHooks []ServerSkuHook -var serverSkuAfterDeleteHooks []ServerSkuHook - -var serverSkuBeforeUpsertHooks []ServerSkuHook -var serverSkuAfterUpsertHooks []ServerSkuHook - -// doAfterSelectHooks executes all "after Select" hooks. -func (o *ServerSku) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuAfterSelectHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeInsertHooks executes all "before insert" hooks. -func (o *ServerSku) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuBeforeInsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterInsertHooks executes all "after Insert" hooks. -func (o *ServerSku) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuAfterInsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeUpdateHooks executes all "before Update" hooks. -func (o *ServerSku) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuBeforeUpdateHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterUpdateHooks executes all "after Update" hooks. -func (o *ServerSku) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuAfterUpdateHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeDeleteHooks executes all "before Delete" hooks. -func (o *ServerSku) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuBeforeDeleteHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterDeleteHooks executes all "after Delete" hooks. -func (o *ServerSku) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuAfterDeleteHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeUpsertHooks executes all "before Upsert" hooks. -func (o *ServerSku) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuBeforeUpsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterUpsertHooks executes all "after Upsert" hooks. -func (o *ServerSku) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuAfterUpsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// AddServerSkuHook registers your hook function for all future operations. -func AddServerSkuHook(hookPoint boil.HookPoint, serverSkuHook ServerSkuHook) { - switch hookPoint { - case boil.AfterSelectHook: - serverSkuAfterSelectHooks = append(serverSkuAfterSelectHooks, serverSkuHook) - case boil.BeforeInsertHook: - serverSkuBeforeInsertHooks = append(serverSkuBeforeInsertHooks, serverSkuHook) - case boil.AfterInsertHook: - serverSkuAfterInsertHooks = append(serverSkuAfterInsertHooks, serverSkuHook) - case boil.BeforeUpdateHook: - serverSkuBeforeUpdateHooks = append(serverSkuBeforeUpdateHooks, serverSkuHook) - case boil.AfterUpdateHook: - serverSkuAfterUpdateHooks = append(serverSkuAfterUpdateHooks, serverSkuHook) - case boil.BeforeDeleteHook: - serverSkuBeforeDeleteHooks = append(serverSkuBeforeDeleteHooks, serverSkuHook) - case boil.AfterDeleteHook: - serverSkuAfterDeleteHooks = append(serverSkuAfterDeleteHooks, serverSkuHook) - case boil.BeforeUpsertHook: - serverSkuBeforeUpsertHooks = append(serverSkuBeforeUpsertHooks, serverSkuHook) - case boil.AfterUpsertHook: - serverSkuAfterUpsertHooks = append(serverSkuAfterUpsertHooks, serverSkuHook) - } -} - -// One returns a single serverSku record from the query. -func (q serverSkuQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServerSku, error) { - o := &ServerSku{} - - queries.SetLimit(q.Query, 1) - - err := q.Bind(ctx, exec, o) - if err != nil { - if errors.Is(err, sql.ErrNoRows) { - return nil, sql.ErrNoRows - } - return nil, errors.Wrap(err, "models: failed to execute a one query for server_sku") - } - - if err := o.doAfterSelectHooks(ctx, exec); err != nil { - return o, err - } - - return o, nil -} - -// All returns all ServerSku records from the query. -func (q serverSkuQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServerSkuSlice, error) { - var o []*ServerSku - - err := q.Bind(ctx, exec, &o) - if err != nil { - return nil, errors.Wrap(err, "models: failed to assign all query results to ServerSku slice") - } - - if len(serverSkuAfterSelectHooks) != 0 { - for _, obj := range o { - if err := obj.doAfterSelectHooks(ctx, exec); err != nil { - return o, err - } - } - } - - return o, nil -} - -// Count returns the count of all ServerSku records in the query. -func (q serverSkuQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - var count int64 - - queries.SetSelect(q.Query, nil) - queries.SetCount(q.Query) - - err := q.Query.QueryRowContext(ctx, exec).Scan(&count) - if err != nil { - return 0, errors.Wrap(err, "models: failed to count server_sku rows") - } - - return count, nil -} - -// Exists checks if the row exists in the table. -func (q serverSkuQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { - var count int64 - - queries.SetSelect(q.Query, nil) - queries.SetCount(q.Query) - queries.SetLimit(q.Query, 1) - - err := q.Query.QueryRowContext(ctx, exec).Scan(&count) - if err != nil { - return false, errors.Wrap(err, "models: failed to check if server_sku exists") - } - - return count > 0, nil -} - -// SkuServerSkuAuxDevices retrieves all the server_sku_aux_device's ServerSkuAuxDevices with an executor via sku_id column. -func (o *ServerSku) SkuServerSkuAuxDevices(mods ...qm.QueryMod) serverSkuAuxDeviceQuery { - var queryMods []qm.QueryMod - if len(mods) != 0 { - queryMods = append(queryMods, mods...) - } - - queryMods = append(queryMods, - qm.Where("\"server_sku_aux_device\".\"sku_id\"=?", o.ID), - ) - - return ServerSkuAuxDevices(queryMods...) -} - -// SkuServerSkuDisks retrieves all the server_sku_disk's ServerSkuDisks with an executor via sku_id column. -func (o *ServerSku) SkuServerSkuDisks(mods ...qm.QueryMod) serverSkuDiskQuery { - var queryMods []qm.QueryMod - if len(mods) != 0 { - queryMods = append(queryMods, mods...) - } - - queryMods = append(queryMods, - qm.Where("\"server_sku_disk\".\"sku_id\"=?", o.ID), - ) - - return ServerSkuDisks(queryMods...) -} - -// SkuServerSkuMemories retrieves all the server_sku_memory's ServerSkuMemories with an executor via sku_id column. -func (o *ServerSku) SkuServerSkuMemories(mods ...qm.QueryMod) serverSkuMemoryQuery { - var queryMods []qm.QueryMod - if len(mods) != 0 { - queryMods = append(queryMods, mods...) - } - - queryMods = append(queryMods, - qm.Where("\"server_sku_memory\".\"sku_id\"=?", o.ID), - ) - - return ServerSkuMemories(queryMods...) -} - -// SkuServerSkuNics retrieves all the server_sku_nic's ServerSkuNics with an executor via sku_id column. -func (o *ServerSku) SkuServerSkuNics(mods ...qm.QueryMod) serverSkuNicQuery { - var queryMods []qm.QueryMod - if len(mods) != 0 { - queryMods = append(queryMods, mods...) - } - - queryMods = append(queryMods, - qm.Where("\"server_sku_nic\".\"sku_id\"=?", o.ID), - ) - - return ServerSkuNics(queryMods...) -} - -// LoadSkuServerSkuAuxDevices allows an eager lookup of values, cached into the -// loaded structs of the objects. This is for a 1-M or N-M relationship. -func (serverSkuL) LoadSkuServerSkuAuxDevices(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServerSku interface{}, mods queries.Applicator) error { - var slice []*ServerSku - var object *ServerSku - - if singular { - var ok bool - object, ok = maybeServerSku.(*ServerSku) - if !ok { - object = new(ServerSku) - ok = queries.SetFromEmbeddedStruct(&object, &maybeServerSku) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", object, maybeServerSku)) - } - } - } else { - s, ok := maybeServerSku.(*[]*ServerSku) - if ok { - slice = *s - } else { - ok = queries.SetFromEmbeddedStruct(&slice, maybeServerSku) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", slice, maybeServerSku)) - } - } - } - - args := make([]interface{}, 0, 1) - if singular { - if object.R == nil { - object.R = &serverSkuR{} - } - args = append(args, object.ID) - } else { - Outer: - for _, obj := range slice { - if obj.R == nil { - obj.R = &serverSkuR{} - } - - for _, a := range args { - if a == obj.ID { - continue Outer - } - } - - args = append(args, obj.ID) - } - } - - if len(args) == 0 { - return nil - } - - query := NewQuery( - qm.From(`server_sku_aux_device`), - qm.WhereIn(`server_sku_aux_device.sku_id in ?`, args...), - ) - if mods != nil { - mods.Apply(query) - } - - results, err := query.QueryContext(ctx, e) - if err != nil { - return errors.Wrap(err, "failed to eager load server_sku_aux_device") - } - - var resultSlice []*ServerSkuAuxDevice - if err = queries.Bind(results, &resultSlice); err != nil { - return errors.Wrap(err, "failed to bind eager loaded slice server_sku_aux_device") - } - - if err = results.Close(); err != nil { - return errors.Wrap(err, "failed to close results in eager load on server_sku_aux_device") - } - if err = results.Err(); err != nil { - return errors.Wrap(err, "error occurred during iteration of eager loaded relations for server_sku_aux_device") - } - - if len(serverSkuAuxDeviceAfterSelectHooks) != 0 { - for _, obj := range resultSlice { - if err := obj.doAfterSelectHooks(ctx, e); err != nil { - return err - } - } - } - if singular { - object.R.SkuServerSkuAuxDevices = resultSlice - for _, foreign := range resultSlice { - if foreign.R == nil { - foreign.R = &serverSkuAuxDeviceR{} - } - foreign.R.Sku = object - } - return nil - } - - for _, foreign := range resultSlice { - for _, local := range slice { - if local.ID == foreign.SkuID { - local.R.SkuServerSkuAuxDevices = append(local.R.SkuServerSkuAuxDevices, foreign) - if foreign.R == nil { - foreign.R = &serverSkuAuxDeviceR{} - } - foreign.R.Sku = local - break - } - } - } - - return nil -} - -// LoadSkuServerSkuDisks allows an eager lookup of values, cached into the -// loaded structs of the objects. This is for a 1-M or N-M relationship. -func (serverSkuL) LoadSkuServerSkuDisks(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServerSku interface{}, mods queries.Applicator) error { - var slice []*ServerSku - var object *ServerSku - - if singular { - var ok bool - object, ok = maybeServerSku.(*ServerSku) - if !ok { - object = new(ServerSku) - ok = queries.SetFromEmbeddedStruct(&object, &maybeServerSku) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", object, maybeServerSku)) - } - } - } else { - s, ok := maybeServerSku.(*[]*ServerSku) - if ok { - slice = *s - } else { - ok = queries.SetFromEmbeddedStruct(&slice, maybeServerSku) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", slice, maybeServerSku)) - } - } - } - - args := make([]interface{}, 0, 1) - if singular { - if object.R == nil { - object.R = &serverSkuR{} - } - args = append(args, object.ID) - } else { - Outer: - for _, obj := range slice { - if obj.R == nil { - obj.R = &serverSkuR{} - } - - for _, a := range args { - if a == obj.ID { - continue Outer - } - } - - args = append(args, obj.ID) - } - } - - if len(args) == 0 { - return nil - } - - query := NewQuery( - qm.From(`server_sku_disk`), - qm.WhereIn(`server_sku_disk.sku_id in ?`, args...), - ) - if mods != nil { - mods.Apply(query) - } - - results, err := query.QueryContext(ctx, e) - if err != nil { - return errors.Wrap(err, "failed to eager load server_sku_disk") - } - - var resultSlice []*ServerSkuDisk - if err = queries.Bind(results, &resultSlice); err != nil { - return errors.Wrap(err, "failed to bind eager loaded slice server_sku_disk") - } - - if err = results.Close(); err != nil { - return errors.Wrap(err, "failed to close results in eager load on server_sku_disk") - } - if err = results.Err(); err != nil { - return errors.Wrap(err, "error occurred during iteration of eager loaded relations for server_sku_disk") - } - - if len(serverSkuDiskAfterSelectHooks) != 0 { - for _, obj := range resultSlice { - if err := obj.doAfterSelectHooks(ctx, e); err != nil { - return err - } - } - } - if singular { - object.R.SkuServerSkuDisks = resultSlice - for _, foreign := range resultSlice { - if foreign.R == nil { - foreign.R = &serverSkuDiskR{} - } - foreign.R.Sku = object - } - return nil - } - - for _, foreign := range resultSlice { - for _, local := range slice { - if local.ID == foreign.SkuID { - local.R.SkuServerSkuDisks = append(local.R.SkuServerSkuDisks, foreign) - if foreign.R == nil { - foreign.R = &serverSkuDiskR{} - } - foreign.R.Sku = local - break - } - } - } - - return nil -} - -// LoadSkuServerSkuMemories allows an eager lookup of values, cached into the -// loaded structs of the objects. This is for a 1-M or N-M relationship. -func (serverSkuL) LoadSkuServerSkuMemories(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServerSku interface{}, mods queries.Applicator) error { - var slice []*ServerSku - var object *ServerSku - - if singular { - var ok bool - object, ok = maybeServerSku.(*ServerSku) - if !ok { - object = new(ServerSku) - ok = queries.SetFromEmbeddedStruct(&object, &maybeServerSku) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", object, maybeServerSku)) - } - } - } else { - s, ok := maybeServerSku.(*[]*ServerSku) - if ok { - slice = *s - } else { - ok = queries.SetFromEmbeddedStruct(&slice, maybeServerSku) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", slice, maybeServerSku)) - } - } - } - - args := make([]interface{}, 0, 1) - if singular { - if object.R == nil { - object.R = &serverSkuR{} - } - args = append(args, object.ID) - } else { - Outer: - for _, obj := range slice { - if obj.R == nil { - obj.R = &serverSkuR{} - } - - for _, a := range args { - if a == obj.ID { - continue Outer - } - } - - args = append(args, obj.ID) - } - } - - if len(args) == 0 { - return nil - } - - query := NewQuery( - qm.From(`server_sku_memory`), - qm.WhereIn(`server_sku_memory.sku_id in ?`, args...), - ) - if mods != nil { - mods.Apply(query) - } - - results, err := query.QueryContext(ctx, e) - if err != nil { - return errors.Wrap(err, "failed to eager load server_sku_memory") - } - - var resultSlice []*ServerSkuMemory - if err = queries.Bind(results, &resultSlice); err != nil { - return errors.Wrap(err, "failed to bind eager loaded slice server_sku_memory") - } - - if err = results.Close(); err != nil { - return errors.Wrap(err, "failed to close results in eager load on server_sku_memory") - } - if err = results.Err(); err != nil { - return errors.Wrap(err, "error occurred during iteration of eager loaded relations for server_sku_memory") - } - - if len(serverSkuMemoryAfterSelectHooks) != 0 { - for _, obj := range resultSlice { - if err := obj.doAfterSelectHooks(ctx, e); err != nil { - return err - } - } - } - if singular { - object.R.SkuServerSkuMemories = resultSlice - for _, foreign := range resultSlice { - if foreign.R == nil { - foreign.R = &serverSkuMemoryR{} - } - foreign.R.Sku = object - } - return nil - } - - for _, foreign := range resultSlice { - for _, local := range slice { - if local.ID == foreign.SkuID { - local.R.SkuServerSkuMemories = append(local.R.SkuServerSkuMemories, foreign) - if foreign.R == nil { - foreign.R = &serverSkuMemoryR{} - } - foreign.R.Sku = local - break - } - } - } - - return nil -} - -// LoadSkuServerSkuNics allows an eager lookup of values, cached into the -// loaded structs of the objects. This is for a 1-M or N-M relationship. -func (serverSkuL) LoadSkuServerSkuNics(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServerSku interface{}, mods queries.Applicator) error { - var slice []*ServerSku - var object *ServerSku - - if singular { - var ok bool - object, ok = maybeServerSku.(*ServerSku) - if !ok { - object = new(ServerSku) - ok = queries.SetFromEmbeddedStruct(&object, &maybeServerSku) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", object, maybeServerSku)) - } - } - } else { - s, ok := maybeServerSku.(*[]*ServerSku) - if ok { - slice = *s - } else { - ok = queries.SetFromEmbeddedStruct(&slice, maybeServerSku) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", slice, maybeServerSku)) - } - } - } - - args := make([]interface{}, 0, 1) - if singular { - if object.R == nil { - object.R = &serverSkuR{} - } - args = append(args, object.ID) - } else { - Outer: - for _, obj := range slice { - if obj.R == nil { - obj.R = &serverSkuR{} - } - - for _, a := range args { - if a == obj.ID { - continue Outer - } - } - - args = append(args, obj.ID) - } - } - - if len(args) == 0 { - return nil - } - - query := NewQuery( - qm.From(`server_sku_nic`), - qm.WhereIn(`server_sku_nic.sku_id in ?`, args...), - ) - if mods != nil { - mods.Apply(query) - } - - results, err := query.QueryContext(ctx, e) - if err != nil { - return errors.Wrap(err, "failed to eager load server_sku_nic") - } - - var resultSlice []*ServerSkuNic - if err = queries.Bind(results, &resultSlice); err != nil { - return errors.Wrap(err, "failed to bind eager loaded slice server_sku_nic") - } - - if err = results.Close(); err != nil { - return errors.Wrap(err, "failed to close results in eager load on server_sku_nic") - } - if err = results.Err(); err != nil { - return errors.Wrap(err, "error occurred during iteration of eager loaded relations for server_sku_nic") - } - - if len(serverSkuNicAfterSelectHooks) != 0 { - for _, obj := range resultSlice { - if err := obj.doAfterSelectHooks(ctx, e); err != nil { - return err - } - } - } - if singular { - object.R.SkuServerSkuNics = resultSlice - for _, foreign := range resultSlice { - if foreign.R == nil { - foreign.R = &serverSkuNicR{} - } - foreign.R.Sku = object - } - return nil - } - - for _, foreign := range resultSlice { - for _, local := range slice { - if local.ID == foreign.SkuID { - local.R.SkuServerSkuNics = append(local.R.SkuServerSkuNics, foreign) - if foreign.R == nil { - foreign.R = &serverSkuNicR{} - } - foreign.R.Sku = local - break - } - } - } - - return nil -} - -// AddSkuServerSkuAuxDevices adds the given related objects to the existing relationships -// of the server_sku, optionally inserting them as new records. -// Appends related to o.R.SkuServerSkuAuxDevices. -// Sets related.R.Sku appropriately. -func (o *ServerSku) AddSkuServerSkuAuxDevices(ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServerSkuAuxDevice) error { - var err error - for _, rel := range related { - if insert { - rel.SkuID = o.ID - if err = rel.Insert(ctx, exec, boil.Infer()); err != nil { - return errors.Wrap(err, "failed to insert into foreign table") - } - } else { - updateQuery := fmt.Sprintf( - "UPDATE \"server_sku_aux_device\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, []string{"sku_id"}), - strmangle.WhereClause("\"", "\"", 2, serverSkuAuxDevicePrimaryKeyColumns), - ) - values := []interface{}{o.ID, rel.ID} - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, updateQuery) - fmt.Fprintln(writer, values) - } - if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { - return errors.Wrap(err, "failed to update foreign table") - } - - rel.SkuID = o.ID - } - } - - if o.R == nil { - o.R = &serverSkuR{ - SkuServerSkuAuxDevices: related, - } - } else { - o.R.SkuServerSkuAuxDevices = append(o.R.SkuServerSkuAuxDevices, related...) - } - - for _, rel := range related { - if rel.R == nil { - rel.R = &serverSkuAuxDeviceR{ - Sku: o, - } - } else { - rel.R.Sku = o - } - } - return nil -} - -// AddSkuServerSkuDisks adds the given related objects to the existing relationships -// of the server_sku, optionally inserting them as new records. -// Appends related to o.R.SkuServerSkuDisks. -// Sets related.R.Sku appropriately. -func (o *ServerSku) AddSkuServerSkuDisks(ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServerSkuDisk) error { - var err error - for _, rel := range related { - if insert { - rel.SkuID = o.ID - if err = rel.Insert(ctx, exec, boil.Infer()); err != nil { - return errors.Wrap(err, "failed to insert into foreign table") - } - } else { - updateQuery := fmt.Sprintf( - "UPDATE \"server_sku_disk\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, []string{"sku_id"}), - strmangle.WhereClause("\"", "\"", 2, serverSkuDiskPrimaryKeyColumns), - ) - values := []interface{}{o.ID, rel.ID} - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, updateQuery) - fmt.Fprintln(writer, values) - } - if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { - return errors.Wrap(err, "failed to update foreign table") - } - - rel.SkuID = o.ID - } - } - - if o.R == nil { - o.R = &serverSkuR{ - SkuServerSkuDisks: related, - } - } else { - o.R.SkuServerSkuDisks = append(o.R.SkuServerSkuDisks, related...) - } - - for _, rel := range related { - if rel.R == nil { - rel.R = &serverSkuDiskR{ - Sku: o, - } - } else { - rel.R.Sku = o - } - } - return nil -} - -// AddSkuServerSkuMemories adds the given related objects to the existing relationships -// of the server_sku, optionally inserting them as new records. -// Appends related to o.R.SkuServerSkuMemories. -// Sets related.R.Sku appropriately. -func (o *ServerSku) AddSkuServerSkuMemories(ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServerSkuMemory) error { - var err error - for _, rel := range related { - if insert { - rel.SkuID = o.ID - if err = rel.Insert(ctx, exec, boil.Infer()); err != nil { - return errors.Wrap(err, "failed to insert into foreign table") - } - } else { - updateQuery := fmt.Sprintf( - "UPDATE \"server_sku_memory\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, []string{"sku_id"}), - strmangle.WhereClause("\"", "\"", 2, serverSkuMemoryPrimaryKeyColumns), - ) - values := []interface{}{o.ID, rel.ID} - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, updateQuery) - fmt.Fprintln(writer, values) - } - if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { - return errors.Wrap(err, "failed to update foreign table") - } - - rel.SkuID = o.ID - } - } - - if o.R == nil { - o.R = &serverSkuR{ - SkuServerSkuMemories: related, - } - } else { - o.R.SkuServerSkuMemories = append(o.R.SkuServerSkuMemories, related...) - } - - for _, rel := range related { - if rel.R == nil { - rel.R = &serverSkuMemoryR{ - Sku: o, - } - } else { - rel.R.Sku = o - } - } - return nil -} - -// AddSkuServerSkuNics adds the given related objects to the existing relationships -// of the server_sku, optionally inserting them as new records. -// Appends related to o.R.SkuServerSkuNics. -// Sets related.R.Sku appropriately. -func (o *ServerSku) AddSkuServerSkuNics(ctx context.Context, exec boil.ContextExecutor, insert bool, related ...*ServerSkuNic) error { - var err error - for _, rel := range related { - if insert { - rel.SkuID = o.ID - if err = rel.Insert(ctx, exec, boil.Infer()); err != nil { - return errors.Wrap(err, "failed to insert into foreign table") - } - } else { - updateQuery := fmt.Sprintf( - "UPDATE \"server_sku_nic\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, []string{"sku_id"}), - strmangle.WhereClause("\"", "\"", 2, serverSkuNicPrimaryKeyColumns), - ) - values := []interface{}{o.ID, rel.ID} - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, updateQuery) - fmt.Fprintln(writer, values) - } - if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { - return errors.Wrap(err, "failed to update foreign table") - } - - rel.SkuID = o.ID - } - } - - if o.R == nil { - o.R = &serverSkuR{ - SkuServerSkuNics: related, - } - } else { - o.R.SkuServerSkuNics = append(o.R.SkuServerSkuNics, related...) - } - - for _, rel := range related { - if rel.R == nil { - rel.R = &serverSkuNicR{ - Sku: o, - } - } else { - rel.R.Sku = o - } - } - return nil -} - -// ServerSkus retrieves all the records using an executor. -func ServerSkus(mods ...qm.QueryMod) serverSkuQuery { - mods = append(mods, qm.From("\"server_sku\"")) - q := NewQuery(mods...) - if len(queries.GetSelect(q)) == 0 { - queries.SetSelect(q, []string{"\"server_sku\".*"}) - } - - return serverSkuQuery{q} -} - -// FindServerSku retrieves a single record by ID with an executor. -// If selectCols is empty Find will return all columns. -func FindServerSku(ctx context.Context, exec boil.ContextExecutor, iD string, selectCols ...string) (*ServerSku, error) { - serverSkuObj := &ServerSku{} - - sel := "*" - if len(selectCols) > 0 { - sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",") - } - query := fmt.Sprintf( - "select %s from \"server_sku\" where \"id\"=$1", sel, - ) - - q := queries.Raw(query, iD) - - err := q.Bind(ctx, exec, serverSkuObj) - if err != nil { - if errors.Is(err, sql.ErrNoRows) { - return nil, sql.ErrNoRows - } - return nil, errors.Wrap(err, "models: unable to select from server_sku") - } - - if err = serverSkuObj.doAfterSelectHooks(ctx, exec); err != nil { - return serverSkuObj, err - } - - return serverSkuObj, nil -} - -// Insert a single record using an executor. -// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts. -func (o *ServerSku) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error { - if o == nil { - return errors.New("models: no server_sku provided for insertion") - } - - var err error - if !boil.TimestampsAreSkipped(ctx) { - currTime := time.Now().In(boil.GetLocation()) - - if queries.MustTime(o.CreatedAt).IsZero() { - queries.SetScanner(&o.CreatedAt, currTime) - } - if queries.MustTime(o.UpdatedAt).IsZero() { - queries.SetScanner(&o.UpdatedAt, currTime) - } - } - - if err := o.doBeforeInsertHooks(ctx, exec); err != nil { - return err - } - - nzDefaults := queries.NonZeroDefaultSet(serverSkuColumnsWithDefault, o) - - key := makeCacheKey(columns, nzDefaults) - serverSkuInsertCacheMut.RLock() - cache, cached := serverSkuInsertCache[key] - serverSkuInsertCacheMut.RUnlock() - - if !cached { - wl, returnColumns := columns.InsertColumnSet( - serverSkuAllColumns, - serverSkuColumnsWithDefault, - serverSkuColumnsWithoutDefault, - nzDefaults, - ) - - cache.valueMapping, err = queries.BindMapping(serverSkuType, serverSkuMapping, wl) - if err != nil { - return err - } - cache.retMapping, err = queries.BindMapping(serverSkuType, serverSkuMapping, returnColumns) - if err != nil { - return err - } - if len(wl) != 0 { - cache.query = fmt.Sprintf("INSERT INTO \"server_sku\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1)) - } else { - cache.query = "INSERT INTO \"server_sku\" %sDEFAULT VALUES%s" - } - - var queryOutput, queryReturning string - - if len(cache.retMapping) != 0 { - queryReturning = fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\"")) - } - - cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning) - } - - value := reflect.Indirect(reflect.ValueOf(o)) - vals := queries.ValuesFromMapping(value, cache.valueMapping) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, cache.query) - fmt.Fprintln(writer, vals) - } - - if len(cache.retMapping) != 0 { - err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...) - } else { - _, err = exec.ExecContext(ctx, cache.query, vals...) - } - - if err != nil { - return errors.Wrap(err, "models: unable to insert into server_sku") - } - - if !cached { - serverSkuInsertCacheMut.Lock() - serverSkuInsertCache[key] = cache - serverSkuInsertCacheMut.Unlock() - } - - return o.doAfterInsertHooks(ctx, exec) -} - -// Update uses an executor to update the ServerSku. -// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. -// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records. -func (o *ServerSku) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) { - if !boil.TimestampsAreSkipped(ctx) { - currTime := time.Now().In(boil.GetLocation()) - - queries.SetScanner(&o.UpdatedAt, currTime) - } - - var err error - if err = o.doBeforeUpdateHooks(ctx, exec); err != nil { - return 0, err - } - key := makeCacheKey(columns, nil) - serverSkuUpdateCacheMut.RLock() - cache, cached := serverSkuUpdateCache[key] - serverSkuUpdateCacheMut.RUnlock() - - if !cached { - wl := columns.UpdateColumnSet( - serverSkuAllColumns, - serverSkuPrimaryKeyColumns, - ) - - if !columns.IsWhitelist() { - wl = strmangle.SetComplement(wl, []string{"created_at"}) - } - if len(wl) == 0 { - return 0, errors.New("models: unable to update server_sku, could not build whitelist") - } - - cache.query = fmt.Sprintf("UPDATE \"server_sku\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, wl), - strmangle.WhereClause("\"", "\"", len(wl)+1, serverSkuPrimaryKeyColumns), - ) - cache.valueMapping, err = queries.BindMapping(serverSkuType, serverSkuMapping, append(wl, serverSkuPrimaryKeyColumns...)) - if err != nil { - return 0, err - } - } - - values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, cache.query) - fmt.Fprintln(writer, values) - } - var result sql.Result - result, err = exec.ExecContext(ctx, cache.query, values...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to update server_sku row") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by update for server_sku") - } - - if !cached { - serverSkuUpdateCacheMut.Lock() - serverSkuUpdateCache[key] = cache - serverSkuUpdateCacheMut.Unlock() - } - - return rowsAff, o.doAfterUpdateHooks(ctx, exec) -} - -// UpdateAll updates all rows with the specified column values. -func (q serverSkuQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { - queries.SetUpdate(q.Query, cols) - - result, err := q.Query.ExecContext(ctx, exec) - if err != nil { - return 0, errors.Wrap(err, "models: unable to update all for server_sku") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: unable to retrieve rows affected for server_sku") - } - - return rowsAff, nil -} - -// UpdateAll updates all rows with the specified column values, using an executor. -func (o ServerSkuSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { - ln := int64(len(o)) - if ln == 0 { - return 0, nil - } - - if len(cols) == 0 { - return 0, errors.New("models: update all requires at least one column argument") - } - - colNames := make([]string, len(cols)) - args := make([]interface{}, len(cols)) - - i := 0 - for name, value := range cols { - colNames[i] = name - args[i] = value - i++ - } - - // Append all of the primary key values for each column - for _, obj := range o { - pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), serverSkuPrimaryKeyMapping) - args = append(args, pkeyArgs...) - } - - sql := fmt.Sprintf("UPDATE \"server_sku\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, colNames), - strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), len(colNames)+1, serverSkuPrimaryKeyColumns, len(o))) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, args...) - } - result, err := exec.ExecContext(ctx, sql, args...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to update all in serverSku slice") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: unable to retrieve rows affected all in update all serverSku") - } - return rowsAff, nil -} - -// Delete deletes a single ServerSku record with an executor. -// Delete will match against the primary key column to find the record to delete. -func (o *ServerSku) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - if o == nil { - return 0, errors.New("models: no ServerSku provided for delete") - } - - if err := o.doBeforeDeleteHooks(ctx, exec); err != nil { - return 0, err - } - - args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), serverSkuPrimaryKeyMapping) - sql := "DELETE FROM \"server_sku\" WHERE \"id\"=$1" - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, args...) - } - result, err := exec.ExecContext(ctx, sql, args...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to delete from server_sku") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by delete for server_sku") - } - - if err := o.doAfterDeleteHooks(ctx, exec); err != nil { - return 0, err - } - - return rowsAff, nil -} - -// DeleteAll deletes all matching rows. -func (q serverSkuQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - if q.Query == nil { - return 0, errors.New("models: no serverSkuQuery provided for delete all") - } - - queries.SetDelete(q.Query) - - result, err := q.Query.ExecContext(ctx, exec) - if err != nil { - return 0, errors.Wrap(err, "models: unable to delete all from server_sku") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for server_sku") - } - - return rowsAff, nil -} - -// DeleteAll deletes all rows in the slice, using an executor. -func (o ServerSkuSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - if len(o) == 0 { - return 0, nil - } - - if len(serverSkuBeforeDeleteHooks) != 0 { - for _, obj := range o { - if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil { - return 0, err - } - } - } - - var args []interface{} - for _, obj := range o { - pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), serverSkuPrimaryKeyMapping) - args = append(args, pkeyArgs...) - } - - sql := "DELETE FROM \"server_sku\" WHERE " + - strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, serverSkuPrimaryKeyColumns, len(o)) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, args) - } - result, err := exec.ExecContext(ctx, sql, args...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to delete all from serverSku slice") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for server_sku") - } - - if len(serverSkuAfterDeleteHooks) != 0 { - for _, obj := range o { - if err := obj.doAfterDeleteHooks(ctx, exec); err != nil { - return 0, err - } - } - } - - return rowsAff, nil -} - -// Reload refetches the object from the database -// using the primary keys with an executor. -func (o *ServerSku) Reload(ctx context.Context, exec boil.ContextExecutor) error { - ret, err := FindServerSku(ctx, exec, o.ID) - if err != nil { - return err - } - - *o = *ret - return nil -} - -// ReloadAll refetches every row with matching primary key column values -// and overwrites the original object slice with the newly updated slice. -func (o *ServerSkuSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error { - if o == nil || len(*o) == 0 { - return nil - } - - slice := ServerSkuSlice{} - var args []interface{} - for _, obj := range *o { - pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), serverSkuPrimaryKeyMapping) - args = append(args, pkeyArgs...) - } - - sql := "SELECT \"server_sku\".* FROM \"server_sku\" WHERE " + - strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, serverSkuPrimaryKeyColumns, len(*o)) - - q := queries.Raw(sql, args...) - - err := q.Bind(ctx, exec, &slice) - if err != nil { - return errors.Wrap(err, "models: unable to reload all in ServerSkuSlice") - } - - *o = slice - - return nil -} - -// ServerSkuExists checks if the ServerSku row exists. -func ServerSkuExists(ctx context.Context, exec boil.ContextExecutor, iD string) (bool, error) { - var exists bool - sql := "select exists(select 1 from \"server_sku\" where \"id\"=$1 limit 1)" - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, iD) - } - row := exec.QueryRowContext(ctx, sql, iD) - - err := row.Scan(&exists) - if err != nil { - return false, errors.Wrap(err, "models: unable to check if server_sku exists") - } - - return exists, nil -} - -// Exists checks if the ServerSku row exists. -func (o *ServerSku) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { - return ServerSkuExists(ctx, exec, o.ID) -} - -// Upsert attempts an insert using an executor, and does an update or ignore on conflict. -// See boil.Columns documentation for how to properly use updateColumns and insertColumns. -func (o *ServerSku) Upsert(ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error { - if o == nil { - return errors.New("models: no server_sku provided for upsert") - } - if !boil.TimestampsAreSkipped(ctx) { - currTime := time.Now().In(boil.GetLocation()) - - if queries.MustTime(o.CreatedAt).IsZero() { - queries.SetScanner(&o.CreatedAt, currTime) - } - queries.SetScanner(&o.UpdatedAt, currTime) - } - - if err := o.doBeforeUpsertHooks(ctx, exec); err != nil { - return err - } - - nzDefaults := queries.NonZeroDefaultSet(serverSkuColumnsWithDefault, o) - - // Build cache key in-line uglily - mysql vs psql problems - buf := strmangle.GetBuffer() - if updateOnConflict { - buf.WriteByte('t') - } else { - buf.WriteByte('f') - } - buf.WriteByte('.') - for _, c := range conflictColumns { - buf.WriteString(c) - } - buf.WriteByte('.') - buf.WriteString(strconv.Itoa(updateColumns.Kind)) - for _, c := range updateColumns.Cols { - buf.WriteString(c) - } - buf.WriteByte('.') - buf.WriteString(strconv.Itoa(insertColumns.Kind)) - for _, c := range insertColumns.Cols { - buf.WriteString(c) - } - buf.WriteByte('.') - for _, c := range nzDefaults { - buf.WriteString(c) - } - key := buf.String() - strmangle.PutBuffer(buf) - - serverSkuUpsertCacheMut.RLock() - cache, cached := serverSkuUpsertCache[key] - serverSkuUpsertCacheMut.RUnlock() - - var err error - - if !cached { - insert, ret := insertColumns.InsertColumnSet( - serverSkuAllColumns, - serverSkuColumnsWithDefault, - serverSkuColumnsWithoutDefault, - nzDefaults, - ) - update := updateColumns.UpdateColumnSet( - serverSkuAllColumns, - serverSkuPrimaryKeyColumns, - ) - - if updateOnConflict && len(update) == 0 { - return errors.New("models: unable to upsert server_sku, could not build update column list") - } - - conflict := conflictColumns - if len(conflict) == 0 { - conflict = make([]string, len(serverSkuPrimaryKeyColumns)) - copy(conflict, serverSkuPrimaryKeyColumns) - } - cache.query = buildUpsertQueryCockroachDB(dialect, "\"server_sku\"", updateOnConflict, ret, update, conflict, insert) - - cache.valueMapping, err = queries.BindMapping(serverSkuType, serverSkuMapping, insert) - if err != nil { - return err - } - if len(ret) != 0 { - cache.retMapping, err = queries.BindMapping(serverSkuType, serverSkuMapping, ret) - if err != nil { - return err - } - } - } - - value := reflect.Indirect(reflect.ValueOf(o)) - vals := queries.ValuesFromMapping(value, cache.valueMapping) - var returns []interface{} - if len(cache.retMapping) != 0 { - returns = queries.PtrsFromMapping(value, cache.retMapping) - } - - if boil.DebugMode { - _, _ = fmt.Fprintln(boil.DebugWriter, cache.query) - _, _ = fmt.Fprintln(boil.DebugWriter, vals) - } - - if len(cache.retMapping) != 0 { - err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(returns...) - if err == sql.ErrNoRows { - err = nil // CockcorachDB doesn't return anything when there's no update - } - } else { - _, err = exec.ExecContext(ctx, cache.query, vals...) - } - if err != nil { - return errors.Wrap(err, "models: unable to upsert server_sku") - } - - if !cached { - serverSkuUpsertCacheMut.Lock() - serverSkuUpsertCache[key] = cache - serverSkuUpsertCacheMut.Unlock() - } - - return o.doAfterUpsertHooks(ctx, exec) -} diff --git a/internal/models/server_sku_aux_device.go b/internal/models/server_sku_aux_device.go deleted file mode 100644 index 60708583..00000000 --- a/internal/models/server_sku_aux_device.go +++ /dev/null @@ -1,1151 +0,0 @@ -// Code generated by SQLBoiler 4.15.0 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT. -// This file is meant to be re-generated in place and/or deleted at any time. - -package models - -import ( - "context" - "database/sql" - "fmt" - "reflect" - "strconv" - "strings" - "sync" - "time" - - "github.com/friendsofgo/errors" - "github.com/volatiletech/null/v8" - "github.com/volatiletech/sqlboiler/v4/boil" - "github.com/volatiletech/sqlboiler/v4/queries" - "github.com/volatiletech/sqlboiler/v4/queries/qm" - "github.com/volatiletech/sqlboiler/v4/queries/qmhelper" - "github.com/volatiletech/sqlboiler/v4/types" - "github.com/volatiletech/strmangle" -) - -// ServerSkuAuxDevice is an object representing the database table. -type ServerSkuAuxDevice struct { - ID string `boil:"id" json:"id" toml:"id" yaml:"id"` - SkuID string `boil:"sku_id" json:"sku_id" toml:"sku_id" yaml:"sku_id"` - Vendor string `boil:"vendor" json:"vendor" toml:"vendor" yaml:"vendor"` - Model string `boil:"model" json:"model" toml:"model" yaml:"model"` - DeviceType string `boil:"device_type" json:"device_type" toml:"device_type" yaml:"device_type"` - Details types.JSON `boil:"details" json:"details" toml:"details" yaml:"details"` - CreatedAt null.Time `boil:"created_at" json:"created_at,omitempty" toml:"created_at" yaml:"created_at,omitempty"` - UpdatedAt null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"` - - R *serverSkuAuxDeviceR `boil:"-" json:"-" toml:"-" yaml:"-"` - L serverSkuAuxDeviceL `boil:"-" json:"-" toml:"-" yaml:"-"` -} - -var ServerSkuAuxDeviceColumns = struct { - ID string - SkuID string - Vendor string - Model string - DeviceType string - Details string - CreatedAt string - UpdatedAt string -}{ - ID: "id", - SkuID: "sku_id", - Vendor: "vendor", - Model: "model", - DeviceType: "device_type", - Details: "details", - CreatedAt: "created_at", - UpdatedAt: "updated_at", -} - -var ServerSkuAuxDeviceTableColumns = struct { - ID string - SkuID string - Vendor string - Model string - DeviceType string - Details string - CreatedAt string - UpdatedAt string -}{ - ID: "server_sku_aux_device.id", - SkuID: "server_sku_aux_device.sku_id", - Vendor: "server_sku_aux_device.vendor", - Model: "server_sku_aux_device.model", - DeviceType: "server_sku_aux_device.device_type", - Details: "server_sku_aux_device.details", - CreatedAt: "server_sku_aux_device.created_at", - UpdatedAt: "server_sku_aux_device.updated_at", -} - -// Generated where - -var ServerSkuAuxDeviceWhere = struct { - ID whereHelperstring - SkuID whereHelperstring - Vendor whereHelperstring - Model whereHelperstring - DeviceType whereHelperstring - Details whereHelpertypes_JSON - CreatedAt whereHelpernull_Time - UpdatedAt whereHelpernull_Time -}{ - ID: whereHelperstring{field: "\"server_sku_aux_device\".\"id\""}, - SkuID: whereHelperstring{field: "\"server_sku_aux_device\".\"sku_id\""}, - Vendor: whereHelperstring{field: "\"server_sku_aux_device\".\"vendor\""}, - Model: whereHelperstring{field: "\"server_sku_aux_device\".\"model\""}, - DeviceType: whereHelperstring{field: "\"server_sku_aux_device\".\"device_type\""}, - Details: whereHelpertypes_JSON{field: "\"server_sku_aux_device\".\"details\""}, - CreatedAt: whereHelpernull_Time{field: "\"server_sku_aux_device\".\"created_at\""}, - UpdatedAt: whereHelpernull_Time{field: "\"server_sku_aux_device\".\"updated_at\""}, -} - -// ServerSkuAuxDeviceRels is where relationship names are stored. -var ServerSkuAuxDeviceRels = struct { - Sku string -}{ - Sku: "Sku", -} - -// serverSkuAuxDeviceR is where relationships are stored. -type serverSkuAuxDeviceR struct { - Sku *ServerSku `boil:"Sku" json:"Sku" toml:"Sku" yaml:"Sku"` -} - -// NewStruct creates a new relationship struct -func (*serverSkuAuxDeviceR) NewStruct() *serverSkuAuxDeviceR { - return &serverSkuAuxDeviceR{} -} - -func (r *serverSkuAuxDeviceR) GetSku() *ServerSku { - if r == nil { - return nil - } - return r.Sku -} - -// serverSkuAuxDeviceL is where Load methods for each relationship are stored. -type serverSkuAuxDeviceL struct{} - -var ( - serverSkuAuxDeviceAllColumns = []string{"id", "sku_id", "vendor", "model", "device_type", "details", "created_at", "updated_at"} - serverSkuAuxDeviceColumnsWithoutDefault = []string{"sku_id", "vendor", "model", "device_type", "details"} - serverSkuAuxDeviceColumnsWithDefault = []string{"id", "created_at", "updated_at"} - serverSkuAuxDevicePrimaryKeyColumns = []string{"id"} - serverSkuAuxDeviceGeneratedColumns = []string{} -) - -type ( - // ServerSkuAuxDeviceSlice is an alias for a slice of pointers to ServerSkuAuxDevice. - // This should almost always be used instead of []ServerSkuAuxDevice. - ServerSkuAuxDeviceSlice []*ServerSkuAuxDevice - // ServerSkuAuxDeviceHook is the signature for custom ServerSkuAuxDevice hook methods - ServerSkuAuxDeviceHook func(context.Context, boil.ContextExecutor, *ServerSkuAuxDevice) error - - serverSkuAuxDeviceQuery struct { - *queries.Query - } -) - -// Cache for insert, update and upsert -var ( - serverSkuAuxDeviceType = reflect.TypeOf(&ServerSkuAuxDevice{}) - serverSkuAuxDeviceMapping = queries.MakeStructMapping(serverSkuAuxDeviceType) - serverSkuAuxDevicePrimaryKeyMapping, _ = queries.BindMapping(serverSkuAuxDeviceType, serverSkuAuxDeviceMapping, serverSkuAuxDevicePrimaryKeyColumns) - serverSkuAuxDeviceInsertCacheMut sync.RWMutex - serverSkuAuxDeviceInsertCache = make(map[string]insertCache) - serverSkuAuxDeviceUpdateCacheMut sync.RWMutex - serverSkuAuxDeviceUpdateCache = make(map[string]updateCache) - serverSkuAuxDeviceUpsertCacheMut sync.RWMutex - serverSkuAuxDeviceUpsertCache = make(map[string]insertCache) -) - -var ( - // Force time package dependency for automated UpdatedAt/CreatedAt. - _ = time.Second - // Force qmhelper dependency for where clause generation (which doesn't - // always happen) - _ = qmhelper.Where -) - -var serverSkuAuxDeviceAfterSelectHooks []ServerSkuAuxDeviceHook - -var serverSkuAuxDeviceBeforeInsertHooks []ServerSkuAuxDeviceHook -var serverSkuAuxDeviceAfterInsertHooks []ServerSkuAuxDeviceHook - -var serverSkuAuxDeviceBeforeUpdateHooks []ServerSkuAuxDeviceHook -var serverSkuAuxDeviceAfterUpdateHooks []ServerSkuAuxDeviceHook - -var serverSkuAuxDeviceBeforeDeleteHooks []ServerSkuAuxDeviceHook -var serverSkuAuxDeviceAfterDeleteHooks []ServerSkuAuxDeviceHook - -var serverSkuAuxDeviceBeforeUpsertHooks []ServerSkuAuxDeviceHook -var serverSkuAuxDeviceAfterUpsertHooks []ServerSkuAuxDeviceHook - -// doAfterSelectHooks executes all "after Select" hooks. -func (o *ServerSkuAuxDevice) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuAuxDeviceAfterSelectHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeInsertHooks executes all "before insert" hooks. -func (o *ServerSkuAuxDevice) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuAuxDeviceBeforeInsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterInsertHooks executes all "after Insert" hooks. -func (o *ServerSkuAuxDevice) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuAuxDeviceAfterInsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeUpdateHooks executes all "before Update" hooks. -func (o *ServerSkuAuxDevice) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuAuxDeviceBeforeUpdateHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterUpdateHooks executes all "after Update" hooks. -func (o *ServerSkuAuxDevice) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuAuxDeviceAfterUpdateHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeDeleteHooks executes all "before Delete" hooks. -func (o *ServerSkuAuxDevice) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuAuxDeviceBeforeDeleteHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterDeleteHooks executes all "after Delete" hooks. -func (o *ServerSkuAuxDevice) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuAuxDeviceAfterDeleteHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeUpsertHooks executes all "before Upsert" hooks. -func (o *ServerSkuAuxDevice) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuAuxDeviceBeforeUpsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterUpsertHooks executes all "after Upsert" hooks. -func (o *ServerSkuAuxDevice) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuAuxDeviceAfterUpsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// AddServerSkuAuxDeviceHook registers your hook function for all future operations. -func AddServerSkuAuxDeviceHook(hookPoint boil.HookPoint, serverSkuAuxDeviceHook ServerSkuAuxDeviceHook) { - switch hookPoint { - case boil.AfterSelectHook: - serverSkuAuxDeviceAfterSelectHooks = append(serverSkuAuxDeviceAfterSelectHooks, serverSkuAuxDeviceHook) - case boil.BeforeInsertHook: - serverSkuAuxDeviceBeforeInsertHooks = append(serverSkuAuxDeviceBeforeInsertHooks, serverSkuAuxDeviceHook) - case boil.AfterInsertHook: - serverSkuAuxDeviceAfterInsertHooks = append(serverSkuAuxDeviceAfterInsertHooks, serverSkuAuxDeviceHook) - case boil.BeforeUpdateHook: - serverSkuAuxDeviceBeforeUpdateHooks = append(serverSkuAuxDeviceBeforeUpdateHooks, serverSkuAuxDeviceHook) - case boil.AfterUpdateHook: - serverSkuAuxDeviceAfterUpdateHooks = append(serverSkuAuxDeviceAfterUpdateHooks, serverSkuAuxDeviceHook) - case boil.BeforeDeleteHook: - serverSkuAuxDeviceBeforeDeleteHooks = append(serverSkuAuxDeviceBeforeDeleteHooks, serverSkuAuxDeviceHook) - case boil.AfterDeleteHook: - serverSkuAuxDeviceAfterDeleteHooks = append(serverSkuAuxDeviceAfterDeleteHooks, serverSkuAuxDeviceHook) - case boil.BeforeUpsertHook: - serverSkuAuxDeviceBeforeUpsertHooks = append(serverSkuAuxDeviceBeforeUpsertHooks, serverSkuAuxDeviceHook) - case boil.AfterUpsertHook: - serverSkuAuxDeviceAfterUpsertHooks = append(serverSkuAuxDeviceAfterUpsertHooks, serverSkuAuxDeviceHook) - } -} - -// One returns a single serverSkuAuxDevice record from the query. -func (q serverSkuAuxDeviceQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServerSkuAuxDevice, error) { - o := &ServerSkuAuxDevice{} - - queries.SetLimit(q.Query, 1) - - err := q.Bind(ctx, exec, o) - if err != nil { - if errors.Is(err, sql.ErrNoRows) { - return nil, sql.ErrNoRows - } - return nil, errors.Wrap(err, "models: failed to execute a one query for server_sku_aux_device") - } - - if err := o.doAfterSelectHooks(ctx, exec); err != nil { - return o, err - } - - return o, nil -} - -// All returns all ServerSkuAuxDevice records from the query. -func (q serverSkuAuxDeviceQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServerSkuAuxDeviceSlice, error) { - var o []*ServerSkuAuxDevice - - err := q.Bind(ctx, exec, &o) - if err != nil { - return nil, errors.Wrap(err, "models: failed to assign all query results to ServerSkuAuxDevice slice") - } - - if len(serverSkuAuxDeviceAfterSelectHooks) != 0 { - for _, obj := range o { - if err := obj.doAfterSelectHooks(ctx, exec); err != nil { - return o, err - } - } - } - - return o, nil -} - -// Count returns the count of all ServerSkuAuxDevice records in the query. -func (q serverSkuAuxDeviceQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - var count int64 - - queries.SetSelect(q.Query, nil) - queries.SetCount(q.Query) - - err := q.Query.QueryRowContext(ctx, exec).Scan(&count) - if err != nil { - return 0, errors.Wrap(err, "models: failed to count server_sku_aux_device rows") - } - - return count, nil -} - -// Exists checks if the row exists in the table. -func (q serverSkuAuxDeviceQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { - var count int64 - - queries.SetSelect(q.Query, nil) - queries.SetCount(q.Query) - queries.SetLimit(q.Query, 1) - - err := q.Query.QueryRowContext(ctx, exec).Scan(&count) - if err != nil { - return false, errors.Wrap(err, "models: failed to check if server_sku_aux_device exists") - } - - return count > 0, nil -} - -// Sku pointed to by the foreign key. -func (o *ServerSkuAuxDevice) Sku(mods ...qm.QueryMod) serverSkuQuery { - queryMods := []qm.QueryMod{ - qm.Where("\"id\" = ?", o.SkuID), - } - - queryMods = append(queryMods, mods...) - - return ServerSkus(queryMods...) -} - -// LoadSku allows an eager lookup of values, cached into the -// loaded structs of the objects. This is for an N-1 relationship. -func (serverSkuAuxDeviceL) LoadSku(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServerSkuAuxDevice interface{}, mods queries.Applicator) error { - var slice []*ServerSkuAuxDevice - var object *ServerSkuAuxDevice - - if singular { - var ok bool - object, ok = maybeServerSkuAuxDevice.(*ServerSkuAuxDevice) - if !ok { - object = new(ServerSkuAuxDevice) - ok = queries.SetFromEmbeddedStruct(&object, &maybeServerSkuAuxDevice) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", object, maybeServerSkuAuxDevice)) - } - } - } else { - s, ok := maybeServerSkuAuxDevice.(*[]*ServerSkuAuxDevice) - if ok { - slice = *s - } else { - ok = queries.SetFromEmbeddedStruct(&slice, maybeServerSkuAuxDevice) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", slice, maybeServerSkuAuxDevice)) - } - } - } - - args := make([]interface{}, 0, 1) - if singular { - if object.R == nil { - object.R = &serverSkuAuxDeviceR{} - } - args = append(args, object.SkuID) - - } else { - Outer: - for _, obj := range slice { - if obj.R == nil { - obj.R = &serverSkuAuxDeviceR{} - } - - for _, a := range args { - if a == obj.SkuID { - continue Outer - } - } - - args = append(args, obj.SkuID) - - } - } - - if len(args) == 0 { - return nil - } - - query := NewQuery( - qm.From(`server_sku`), - qm.WhereIn(`server_sku.id in ?`, args...), - ) - if mods != nil { - mods.Apply(query) - } - - results, err := query.QueryContext(ctx, e) - if err != nil { - return errors.Wrap(err, "failed to eager load ServerSku") - } - - var resultSlice []*ServerSku - if err = queries.Bind(results, &resultSlice); err != nil { - return errors.Wrap(err, "failed to bind eager loaded slice ServerSku") - } - - if err = results.Close(); err != nil { - return errors.Wrap(err, "failed to close results of eager load for server_sku") - } - if err = results.Err(); err != nil { - return errors.Wrap(err, "error occurred during iteration of eager loaded relations for server_sku") - } - - if len(serverSkuAfterSelectHooks) != 0 { - for _, obj := range resultSlice { - if err := obj.doAfterSelectHooks(ctx, e); err != nil { - return err - } - } - } - - if len(resultSlice) == 0 { - return nil - } - - if singular { - foreign := resultSlice[0] - object.R.Sku = foreign - if foreign.R == nil { - foreign.R = &serverSkuR{} - } - foreign.R.SkuServerSkuAuxDevices = append(foreign.R.SkuServerSkuAuxDevices, object) - return nil - } - - for _, local := range slice { - for _, foreign := range resultSlice { - if local.SkuID == foreign.ID { - local.R.Sku = foreign - if foreign.R == nil { - foreign.R = &serverSkuR{} - } - foreign.R.SkuServerSkuAuxDevices = append(foreign.R.SkuServerSkuAuxDevices, local) - break - } - } - } - - return nil -} - -// SetSku of the serverSkuAuxDevice to the related item. -// Sets o.R.Sku to related. -// Adds o to related.R.SkuServerSkuAuxDevices. -func (o *ServerSkuAuxDevice) SetSku(ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServerSku) error { - var err error - if insert { - if err = related.Insert(ctx, exec, boil.Infer()); err != nil { - return errors.Wrap(err, "failed to insert into foreign table") - } - } - - updateQuery := fmt.Sprintf( - "UPDATE \"server_sku_aux_device\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, []string{"sku_id"}), - strmangle.WhereClause("\"", "\"", 2, serverSkuAuxDevicePrimaryKeyColumns), - ) - values := []interface{}{related.ID, o.ID} - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, updateQuery) - fmt.Fprintln(writer, values) - } - if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { - return errors.Wrap(err, "failed to update local table") - } - - o.SkuID = related.ID - if o.R == nil { - o.R = &serverSkuAuxDeviceR{ - Sku: related, - } - } else { - o.R.Sku = related - } - - if related.R == nil { - related.R = &serverSkuR{ - SkuServerSkuAuxDevices: ServerSkuAuxDeviceSlice{o}, - } - } else { - related.R.SkuServerSkuAuxDevices = append(related.R.SkuServerSkuAuxDevices, o) - } - - return nil -} - -// ServerSkuAuxDevices retrieves all the records using an executor. -func ServerSkuAuxDevices(mods ...qm.QueryMod) serverSkuAuxDeviceQuery { - mods = append(mods, qm.From("\"server_sku_aux_device\"")) - q := NewQuery(mods...) - if len(queries.GetSelect(q)) == 0 { - queries.SetSelect(q, []string{"\"server_sku_aux_device\".*"}) - } - - return serverSkuAuxDeviceQuery{q} -} - -// FindServerSkuAuxDevice retrieves a single record by ID with an executor. -// If selectCols is empty Find will return all columns. -func FindServerSkuAuxDevice(ctx context.Context, exec boil.ContextExecutor, iD string, selectCols ...string) (*ServerSkuAuxDevice, error) { - serverSkuAuxDeviceObj := &ServerSkuAuxDevice{} - - sel := "*" - if len(selectCols) > 0 { - sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",") - } - query := fmt.Sprintf( - "select %s from \"server_sku_aux_device\" where \"id\"=$1", sel, - ) - - q := queries.Raw(query, iD) - - err := q.Bind(ctx, exec, serverSkuAuxDeviceObj) - if err != nil { - if errors.Is(err, sql.ErrNoRows) { - return nil, sql.ErrNoRows - } - return nil, errors.Wrap(err, "models: unable to select from server_sku_aux_device") - } - - if err = serverSkuAuxDeviceObj.doAfterSelectHooks(ctx, exec); err != nil { - return serverSkuAuxDeviceObj, err - } - - return serverSkuAuxDeviceObj, nil -} - -// Insert a single record using an executor. -// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts. -func (o *ServerSkuAuxDevice) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error { - if o == nil { - return errors.New("models: no server_sku_aux_device provided for insertion") - } - - var err error - if !boil.TimestampsAreSkipped(ctx) { - currTime := time.Now().In(boil.GetLocation()) - - if queries.MustTime(o.CreatedAt).IsZero() { - queries.SetScanner(&o.CreatedAt, currTime) - } - if queries.MustTime(o.UpdatedAt).IsZero() { - queries.SetScanner(&o.UpdatedAt, currTime) - } - } - - if err := o.doBeforeInsertHooks(ctx, exec); err != nil { - return err - } - - nzDefaults := queries.NonZeroDefaultSet(serverSkuAuxDeviceColumnsWithDefault, o) - - key := makeCacheKey(columns, nzDefaults) - serverSkuAuxDeviceInsertCacheMut.RLock() - cache, cached := serverSkuAuxDeviceInsertCache[key] - serverSkuAuxDeviceInsertCacheMut.RUnlock() - - if !cached { - wl, returnColumns := columns.InsertColumnSet( - serverSkuAuxDeviceAllColumns, - serverSkuAuxDeviceColumnsWithDefault, - serverSkuAuxDeviceColumnsWithoutDefault, - nzDefaults, - ) - - cache.valueMapping, err = queries.BindMapping(serverSkuAuxDeviceType, serverSkuAuxDeviceMapping, wl) - if err != nil { - return err - } - cache.retMapping, err = queries.BindMapping(serverSkuAuxDeviceType, serverSkuAuxDeviceMapping, returnColumns) - if err != nil { - return err - } - if len(wl) != 0 { - cache.query = fmt.Sprintf("INSERT INTO \"server_sku_aux_device\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1)) - } else { - cache.query = "INSERT INTO \"server_sku_aux_device\" %sDEFAULT VALUES%s" - } - - var queryOutput, queryReturning string - - if len(cache.retMapping) != 0 { - queryReturning = fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\"")) - } - - cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning) - } - - value := reflect.Indirect(reflect.ValueOf(o)) - vals := queries.ValuesFromMapping(value, cache.valueMapping) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, cache.query) - fmt.Fprintln(writer, vals) - } - - if len(cache.retMapping) != 0 { - err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...) - } else { - _, err = exec.ExecContext(ctx, cache.query, vals...) - } - - if err != nil { - return errors.Wrap(err, "models: unable to insert into server_sku_aux_device") - } - - if !cached { - serverSkuAuxDeviceInsertCacheMut.Lock() - serverSkuAuxDeviceInsertCache[key] = cache - serverSkuAuxDeviceInsertCacheMut.Unlock() - } - - return o.doAfterInsertHooks(ctx, exec) -} - -// Update uses an executor to update the ServerSkuAuxDevice. -// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. -// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records. -func (o *ServerSkuAuxDevice) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) { - if !boil.TimestampsAreSkipped(ctx) { - currTime := time.Now().In(boil.GetLocation()) - - queries.SetScanner(&o.UpdatedAt, currTime) - } - - var err error - if err = o.doBeforeUpdateHooks(ctx, exec); err != nil { - return 0, err - } - key := makeCacheKey(columns, nil) - serverSkuAuxDeviceUpdateCacheMut.RLock() - cache, cached := serverSkuAuxDeviceUpdateCache[key] - serverSkuAuxDeviceUpdateCacheMut.RUnlock() - - if !cached { - wl := columns.UpdateColumnSet( - serverSkuAuxDeviceAllColumns, - serverSkuAuxDevicePrimaryKeyColumns, - ) - - if !columns.IsWhitelist() { - wl = strmangle.SetComplement(wl, []string{"created_at"}) - } - if len(wl) == 0 { - return 0, errors.New("models: unable to update server_sku_aux_device, could not build whitelist") - } - - cache.query = fmt.Sprintf("UPDATE \"server_sku_aux_device\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, wl), - strmangle.WhereClause("\"", "\"", len(wl)+1, serverSkuAuxDevicePrimaryKeyColumns), - ) - cache.valueMapping, err = queries.BindMapping(serverSkuAuxDeviceType, serverSkuAuxDeviceMapping, append(wl, serverSkuAuxDevicePrimaryKeyColumns...)) - if err != nil { - return 0, err - } - } - - values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, cache.query) - fmt.Fprintln(writer, values) - } - var result sql.Result - result, err = exec.ExecContext(ctx, cache.query, values...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to update server_sku_aux_device row") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by update for server_sku_aux_device") - } - - if !cached { - serverSkuAuxDeviceUpdateCacheMut.Lock() - serverSkuAuxDeviceUpdateCache[key] = cache - serverSkuAuxDeviceUpdateCacheMut.Unlock() - } - - return rowsAff, o.doAfterUpdateHooks(ctx, exec) -} - -// UpdateAll updates all rows with the specified column values. -func (q serverSkuAuxDeviceQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { - queries.SetUpdate(q.Query, cols) - - result, err := q.Query.ExecContext(ctx, exec) - if err != nil { - return 0, errors.Wrap(err, "models: unable to update all for server_sku_aux_device") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: unable to retrieve rows affected for server_sku_aux_device") - } - - return rowsAff, nil -} - -// UpdateAll updates all rows with the specified column values, using an executor. -func (o ServerSkuAuxDeviceSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { - ln := int64(len(o)) - if ln == 0 { - return 0, nil - } - - if len(cols) == 0 { - return 0, errors.New("models: update all requires at least one column argument") - } - - colNames := make([]string, len(cols)) - args := make([]interface{}, len(cols)) - - i := 0 - for name, value := range cols { - colNames[i] = name - args[i] = value - i++ - } - - // Append all of the primary key values for each column - for _, obj := range o { - pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), serverSkuAuxDevicePrimaryKeyMapping) - args = append(args, pkeyArgs...) - } - - sql := fmt.Sprintf("UPDATE \"server_sku_aux_device\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, colNames), - strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), len(colNames)+1, serverSkuAuxDevicePrimaryKeyColumns, len(o))) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, args...) - } - result, err := exec.ExecContext(ctx, sql, args...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to update all in serverSkuAuxDevice slice") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: unable to retrieve rows affected all in update all serverSkuAuxDevice") - } - return rowsAff, nil -} - -// Delete deletes a single ServerSkuAuxDevice record with an executor. -// Delete will match against the primary key column to find the record to delete. -func (o *ServerSkuAuxDevice) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - if o == nil { - return 0, errors.New("models: no ServerSkuAuxDevice provided for delete") - } - - if err := o.doBeforeDeleteHooks(ctx, exec); err != nil { - return 0, err - } - - args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), serverSkuAuxDevicePrimaryKeyMapping) - sql := "DELETE FROM \"server_sku_aux_device\" WHERE \"id\"=$1" - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, args...) - } - result, err := exec.ExecContext(ctx, sql, args...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to delete from server_sku_aux_device") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by delete for server_sku_aux_device") - } - - if err := o.doAfterDeleteHooks(ctx, exec); err != nil { - return 0, err - } - - return rowsAff, nil -} - -// DeleteAll deletes all matching rows. -func (q serverSkuAuxDeviceQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - if q.Query == nil { - return 0, errors.New("models: no serverSkuAuxDeviceQuery provided for delete all") - } - - queries.SetDelete(q.Query) - - result, err := q.Query.ExecContext(ctx, exec) - if err != nil { - return 0, errors.Wrap(err, "models: unable to delete all from server_sku_aux_device") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for server_sku_aux_device") - } - - return rowsAff, nil -} - -// DeleteAll deletes all rows in the slice, using an executor. -func (o ServerSkuAuxDeviceSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - if len(o) == 0 { - return 0, nil - } - - if len(serverSkuAuxDeviceBeforeDeleteHooks) != 0 { - for _, obj := range o { - if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil { - return 0, err - } - } - } - - var args []interface{} - for _, obj := range o { - pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), serverSkuAuxDevicePrimaryKeyMapping) - args = append(args, pkeyArgs...) - } - - sql := "DELETE FROM \"server_sku_aux_device\" WHERE " + - strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, serverSkuAuxDevicePrimaryKeyColumns, len(o)) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, args) - } - result, err := exec.ExecContext(ctx, sql, args...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to delete all from serverSkuAuxDevice slice") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for server_sku_aux_device") - } - - if len(serverSkuAuxDeviceAfterDeleteHooks) != 0 { - for _, obj := range o { - if err := obj.doAfterDeleteHooks(ctx, exec); err != nil { - return 0, err - } - } - } - - return rowsAff, nil -} - -// Reload refetches the object from the database -// using the primary keys with an executor. -func (o *ServerSkuAuxDevice) Reload(ctx context.Context, exec boil.ContextExecutor) error { - ret, err := FindServerSkuAuxDevice(ctx, exec, o.ID) - if err != nil { - return err - } - - *o = *ret - return nil -} - -// ReloadAll refetches every row with matching primary key column values -// and overwrites the original object slice with the newly updated slice. -func (o *ServerSkuAuxDeviceSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error { - if o == nil || len(*o) == 0 { - return nil - } - - slice := ServerSkuAuxDeviceSlice{} - var args []interface{} - for _, obj := range *o { - pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), serverSkuAuxDevicePrimaryKeyMapping) - args = append(args, pkeyArgs...) - } - - sql := "SELECT \"server_sku_aux_device\".* FROM \"server_sku_aux_device\" WHERE " + - strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, serverSkuAuxDevicePrimaryKeyColumns, len(*o)) - - q := queries.Raw(sql, args...) - - err := q.Bind(ctx, exec, &slice) - if err != nil { - return errors.Wrap(err, "models: unable to reload all in ServerSkuAuxDeviceSlice") - } - - *o = slice - - return nil -} - -// ServerSkuAuxDeviceExists checks if the ServerSkuAuxDevice row exists. -func ServerSkuAuxDeviceExists(ctx context.Context, exec boil.ContextExecutor, iD string) (bool, error) { - var exists bool - sql := "select exists(select 1 from \"server_sku_aux_device\" where \"id\"=$1 limit 1)" - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, iD) - } - row := exec.QueryRowContext(ctx, sql, iD) - - err := row.Scan(&exists) - if err != nil { - return false, errors.Wrap(err, "models: unable to check if server_sku_aux_device exists") - } - - return exists, nil -} - -// Exists checks if the ServerSkuAuxDevice row exists. -func (o *ServerSkuAuxDevice) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { - return ServerSkuAuxDeviceExists(ctx, exec, o.ID) -} - -// Upsert attempts an insert using an executor, and does an update or ignore on conflict. -// See boil.Columns documentation for how to properly use updateColumns and insertColumns. -func (o *ServerSkuAuxDevice) Upsert(ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error { - if o == nil { - return errors.New("models: no server_sku_aux_device provided for upsert") - } - if !boil.TimestampsAreSkipped(ctx) { - currTime := time.Now().In(boil.GetLocation()) - - if queries.MustTime(o.CreatedAt).IsZero() { - queries.SetScanner(&o.CreatedAt, currTime) - } - queries.SetScanner(&o.UpdatedAt, currTime) - } - - if err := o.doBeforeUpsertHooks(ctx, exec); err != nil { - return err - } - - nzDefaults := queries.NonZeroDefaultSet(serverSkuAuxDeviceColumnsWithDefault, o) - - // Build cache key in-line uglily - mysql vs psql problems - buf := strmangle.GetBuffer() - if updateOnConflict { - buf.WriteByte('t') - } else { - buf.WriteByte('f') - } - buf.WriteByte('.') - for _, c := range conflictColumns { - buf.WriteString(c) - } - buf.WriteByte('.') - buf.WriteString(strconv.Itoa(updateColumns.Kind)) - for _, c := range updateColumns.Cols { - buf.WriteString(c) - } - buf.WriteByte('.') - buf.WriteString(strconv.Itoa(insertColumns.Kind)) - for _, c := range insertColumns.Cols { - buf.WriteString(c) - } - buf.WriteByte('.') - for _, c := range nzDefaults { - buf.WriteString(c) - } - key := buf.String() - strmangle.PutBuffer(buf) - - serverSkuAuxDeviceUpsertCacheMut.RLock() - cache, cached := serverSkuAuxDeviceUpsertCache[key] - serverSkuAuxDeviceUpsertCacheMut.RUnlock() - - var err error - - if !cached { - insert, ret := insertColumns.InsertColumnSet( - serverSkuAuxDeviceAllColumns, - serverSkuAuxDeviceColumnsWithDefault, - serverSkuAuxDeviceColumnsWithoutDefault, - nzDefaults, - ) - update := updateColumns.UpdateColumnSet( - serverSkuAuxDeviceAllColumns, - serverSkuAuxDevicePrimaryKeyColumns, - ) - - if updateOnConflict && len(update) == 0 { - return errors.New("models: unable to upsert server_sku_aux_device, could not build update column list") - } - - conflict := conflictColumns - if len(conflict) == 0 { - conflict = make([]string, len(serverSkuAuxDevicePrimaryKeyColumns)) - copy(conflict, serverSkuAuxDevicePrimaryKeyColumns) - } - cache.query = buildUpsertQueryCockroachDB(dialect, "\"server_sku_aux_device\"", updateOnConflict, ret, update, conflict, insert) - - cache.valueMapping, err = queries.BindMapping(serverSkuAuxDeviceType, serverSkuAuxDeviceMapping, insert) - if err != nil { - return err - } - if len(ret) != 0 { - cache.retMapping, err = queries.BindMapping(serverSkuAuxDeviceType, serverSkuAuxDeviceMapping, ret) - if err != nil { - return err - } - } - } - - value := reflect.Indirect(reflect.ValueOf(o)) - vals := queries.ValuesFromMapping(value, cache.valueMapping) - var returns []interface{} - if len(cache.retMapping) != 0 { - returns = queries.PtrsFromMapping(value, cache.retMapping) - } - - if boil.DebugMode { - _, _ = fmt.Fprintln(boil.DebugWriter, cache.query) - _, _ = fmt.Fprintln(boil.DebugWriter, vals) - } - - if len(cache.retMapping) != 0 { - err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(returns...) - if err == sql.ErrNoRows { - err = nil // CockcorachDB doesn't return anything when there's no update - } - } else { - _, err = exec.ExecContext(ctx, cache.query, vals...) - } - if err != nil { - return errors.Wrap(err, "models: unable to upsert server_sku_aux_device") - } - - if !cached { - serverSkuAuxDeviceUpsertCacheMut.Lock() - serverSkuAuxDeviceUpsertCache[key] = cache - serverSkuAuxDeviceUpsertCacheMut.Unlock() - } - - return o.doAfterUpsertHooks(ctx, exec) -} diff --git a/internal/models/server_sku_aux_device_test.go b/internal/models/server_sku_aux_device_test.go deleted file mode 100644 index 37930d45..00000000 --- a/internal/models/server_sku_aux_device_test.go +++ /dev/null @@ -1,851 +0,0 @@ -// Code generated by SQLBoiler 4.15.0 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT. -// This file is meant to be re-generated in place and/or deleted at any time. - -package models - -import ( - "bytes" - "context" - "reflect" - "testing" - - "github.com/volatiletech/randomize" - "github.com/volatiletech/sqlboiler/v4/boil" - "github.com/volatiletech/sqlboiler/v4/queries" - "github.com/volatiletech/strmangle" -) - -func testServerSkuAuxDevicesUpsert(t *testing.T) { - t.Parallel() - - if len(serverSkuAuxDeviceAllColumns) == len(serverSkuAuxDevicePrimaryKeyColumns) { - t.Skip("Skipping table with only primary key columns") - } - - seed := randomize.NewSeed() - var err error - // Attempt the INSERT side of an UPSERT - o := ServerSkuAuxDevice{} - if err = randomize.Struct(seed, &o, serverSkuAuxDeviceDBTypes, true); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Upsert(ctx, tx, false, nil, boil.Infer(), boil.Infer()); err != nil { - t.Errorf("Unable to upsert ServerSkuAuxDevice: %s", err) - } - - count, err := ServerSkuAuxDevices().Count(ctx, tx) - if err != nil { - t.Error(err) - } - if count != 1 { - t.Error("want one record, got:", count) - } - - // Attempt the UPDATE side of an UPSERT - if err = randomize.Struct(seed, &o, serverSkuAuxDeviceDBTypes, false, serverSkuAuxDevicePrimaryKeyColumns...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - if err = o.Upsert(ctx, tx, true, nil, boil.Infer(), boil.Infer()); err != nil { - t.Errorf("Unable to upsert ServerSkuAuxDevice: %s", err) - } - - count, err = ServerSkuAuxDevices().Count(ctx, tx) - if err != nil { - t.Error(err) - } - if count != 1 { - t.Error("want one record, got:", count) - } -} - -var ( - // Relationships sometimes use the reflection helper queries.Equal/queries.Assign - // so force a package dependency in case they don't. - _ = queries.Equal -) - -func testServerSkuAuxDevices(t *testing.T) { - t.Parallel() - - query := ServerSkuAuxDevices() - - if query.Query == nil { - t.Error("expected a query, got nothing") - } -} - -func testServerSkuAuxDevicesDelete(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if rowsAff, err := o.Delete(ctx, tx); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only have deleted one row, but affected:", rowsAff) - } - - count, err := ServerSkuAuxDevices().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 0 { - t.Error("want zero records, got:", count) - } -} - -func testServerSkuAuxDevicesQueryDeleteAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if rowsAff, err := ServerSkuAuxDevices().DeleteAll(ctx, tx); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only have deleted one row, but affected:", rowsAff) - } - - count, err := ServerSkuAuxDevices().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 0 { - t.Error("want zero records, got:", count) - } -} - -func testServerSkuAuxDevicesSliceDeleteAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice := ServerSkuAuxDeviceSlice{o} - - if rowsAff, err := slice.DeleteAll(ctx, tx); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only have deleted one row, but affected:", rowsAff) - } - - count, err := ServerSkuAuxDevices().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 0 { - t.Error("want zero records, got:", count) - } -} - -func testServerSkuAuxDevicesExists(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - e, err := ServerSkuAuxDeviceExists(ctx, tx, o.ID) - if err != nil { - t.Errorf("Unable to check if ServerSkuAuxDevice exists: %s", err) - } - if !e { - t.Errorf("Expected ServerSkuAuxDeviceExists to return true, but got false.") - } -} - -func testServerSkuAuxDevicesFind(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - serverSkuAuxDeviceFound, err := FindServerSkuAuxDevice(ctx, tx, o.ID) - if err != nil { - t.Error(err) - } - - if serverSkuAuxDeviceFound == nil { - t.Error("want a record, got nil") - } -} - -func testServerSkuAuxDevicesBind(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if err = ServerSkuAuxDevices().Bind(ctx, tx, o); err != nil { - t.Error(err) - } -} - -func testServerSkuAuxDevicesOne(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if x, err := ServerSkuAuxDevices().One(ctx, tx); err != nil { - t.Error(err) - } else if x == nil { - t.Error("expected to get a non nil record") - } -} - -func testServerSkuAuxDevicesAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - serverSkuAuxDeviceOne := &ServerSkuAuxDevice{} - serverSkuAuxDeviceTwo := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, serverSkuAuxDeviceOne, serverSkuAuxDeviceDBTypes, false, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - if err = randomize.Struct(seed, serverSkuAuxDeviceTwo, serverSkuAuxDeviceDBTypes, false, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = serverSkuAuxDeviceOne.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - if err = serverSkuAuxDeviceTwo.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice, err := ServerSkuAuxDevices().All(ctx, tx) - if err != nil { - t.Error(err) - } - - if len(slice) != 2 { - t.Error("want 2 records, got:", len(slice)) - } -} - -func testServerSkuAuxDevicesCount(t *testing.T) { - t.Parallel() - - var err error - seed := randomize.NewSeed() - serverSkuAuxDeviceOne := &ServerSkuAuxDevice{} - serverSkuAuxDeviceTwo := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, serverSkuAuxDeviceOne, serverSkuAuxDeviceDBTypes, false, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - if err = randomize.Struct(seed, serverSkuAuxDeviceTwo, serverSkuAuxDeviceDBTypes, false, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = serverSkuAuxDeviceOne.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - if err = serverSkuAuxDeviceTwo.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuAuxDevices().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 2 { - t.Error("want 2 records, got:", count) - } -} - -func serverSkuAuxDeviceBeforeInsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuAuxDevice) error { - *o = ServerSkuAuxDevice{} - return nil -} - -func serverSkuAuxDeviceAfterInsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuAuxDevice) error { - *o = ServerSkuAuxDevice{} - return nil -} - -func serverSkuAuxDeviceAfterSelectHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuAuxDevice) error { - *o = ServerSkuAuxDevice{} - return nil -} - -func serverSkuAuxDeviceBeforeUpdateHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuAuxDevice) error { - *o = ServerSkuAuxDevice{} - return nil -} - -func serverSkuAuxDeviceAfterUpdateHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuAuxDevice) error { - *o = ServerSkuAuxDevice{} - return nil -} - -func serverSkuAuxDeviceBeforeDeleteHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuAuxDevice) error { - *o = ServerSkuAuxDevice{} - return nil -} - -func serverSkuAuxDeviceAfterDeleteHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuAuxDevice) error { - *o = ServerSkuAuxDevice{} - return nil -} - -func serverSkuAuxDeviceBeforeUpsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuAuxDevice) error { - *o = ServerSkuAuxDevice{} - return nil -} - -func serverSkuAuxDeviceAfterUpsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuAuxDevice) error { - *o = ServerSkuAuxDevice{} - return nil -} - -func testServerSkuAuxDevicesHooks(t *testing.T) { - t.Parallel() - - var err error - - ctx := context.Background() - empty := &ServerSkuAuxDevice{} - o := &ServerSkuAuxDevice{} - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, false); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice object: %s", err) - } - - AddServerSkuAuxDeviceHook(boil.BeforeInsertHook, serverSkuAuxDeviceBeforeInsertHook) - if err = o.doBeforeInsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeInsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeInsertHook function to empty object, but got: %#v", o) - } - serverSkuAuxDeviceBeforeInsertHooks = []ServerSkuAuxDeviceHook{} - - AddServerSkuAuxDeviceHook(boil.AfterInsertHook, serverSkuAuxDeviceAfterInsertHook) - if err = o.doAfterInsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterInsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterInsertHook function to empty object, but got: %#v", o) - } - serverSkuAuxDeviceAfterInsertHooks = []ServerSkuAuxDeviceHook{} - - AddServerSkuAuxDeviceHook(boil.AfterSelectHook, serverSkuAuxDeviceAfterSelectHook) - if err = o.doAfterSelectHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterSelectHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterSelectHook function to empty object, but got: %#v", o) - } - serverSkuAuxDeviceAfterSelectHooks = []ServerSkuAuxDeviceHook{} - - AddServerSkuAuxDeviceHook(boil.BeforeUpdateHook, serverSkuAuxDeviceBeforeUpdateHook) - if err = o.doBeforeUpdateHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeUpdateHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeUpdateHook function to empty object, but got: %#v", o) - } - serverSkuAuxDeviceBeforeUpdateHooks = []ServerSkuAuxDeviceHook{} - - AddServerSkuAuxDeviceHook(boil.AfterUpdateHook, serverSkuAuxDeviceAfterUpdateHook) - if err = o.doAfterUpdateHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterUpdateHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterUpdateHook function to empty object, but got: %#v", o) - } - serverSkuAuxDeviceAfterUpdateHooks = []ServerSkuAuxDeviceHook{} - - AddServerSkuAuxDeviceHook(boil.BeforeDeleteHook, serverSkuAuxDeviceBeforeDeleteHook) - if err = o.doBeforeDeleteHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeDeleteHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeDeleteHook function to empty object, but got: %#v", o) - } - serverSkuAuxDeviceBeforeDeleteHooks = []ServerSkuAuxDeviceHook{} - - AddServerSkuAuxDeviceHook(boil.AfterDeleteHook, serverSkuAuxDeviceAfterDeleteHook) - if err = o.doAfterDeleteHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterDeleteHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterDeleteHook function to empty object, but got: %#v", o) - } - serverSkuAuxDeviceAfterDeleteHooks = []ServerSkuAuxDeviceHook{} - - AddServerSkuAuxDeviceHook(boil.BeforeUpsertHook, serverSkuAuxDeviceBeforeUpsertHook) - if err = o.doBeforeUpsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeUpsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeUpsertHook function to empty object, but got: %#v", o) - } - serverSkuAuxDeviceBeforeUpsertHooks = []ServerSkuAuxDeviceHook{} - - AddServerSkuAuxDeviceHook(boil.AfterUpsertHook, serverSkuAuxDeviceAfterUpsertHook) - if err = o.doAfterUpsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterUpsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterUpsertHook function to empty object, but got: %#v", o) - } - serverSkuAuxDeviceAfterUpsertHooks = []ServerSkuAuxDeviceHook{} -} - -func testServerSkuAuxDevicesInsert(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuAuxDevices().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } -} - -func testServerSkuAuxDevicesInsertWhitelist(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Whitelist(serverSkuAuxDeviceColumnsWithoutDefault...)); err != nil { - t.Error(err) - } - - count, err := ServerSkuAuxDevices().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } -} - -func testServerSkuAuxDeviceToOneServerSkuUsingSku(t *testing.T) { - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var local ServerSkuAuxDevice - var foreign ServerSku - - seed := randomize.NewSeed() - if err := randomize.Struct(seed, &local, serverSkuAuxDeviceDBTypes, false, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - if err := randomize.Struct(seed, &foreign, serverSkuDBTypes, false, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - if err := foreign.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - local.SkuID = foreign.ID - if err := local.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - check, err := local.Sku().One(ctx, tx) - if err != nil { - t.Fatal(err) - } - - if check.ID != foreign.ID { - t.Errorf("want: %v, got %v", foreign.ID, check.ID) - } - - ranAfterSelectHook := false - AddServerSkuHook(boil.AfterSelectHook, func(ctx context.Context, e boil.ContextExecutor, o *ServerSku) error { - ranAfterSelectHook = true - return nil - }) - - slice := ServerSkuAuxDeviceSlice{&local} - if err = local.L.LoadSku(ctx, tx, false, (*[]*ServerSkuAuxDevice)(&slice), nil); err != nil { - t.Fatal(err) - } - if local.R.Sku == nil { - t.Error("struct should have been eager loaded") - } - - local.R.Sku = nil - if err = local.L.LoadSku(ctx, tx, true, &local, nil); err != nil { - t.Fatal(err) - } - if local.R.Sku == nil { - t.Error("struct should have been eager loaded") - } - - if !ranAfterSelectHook { - t.Error("failed to run AfterSelect hook for relationship") - } -} - -func testServerSkuAuxDeviceToOneSetOpServerSkuUsingSku(t *testing.T) { - var err error - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var a ServerSkuAuxDevice - var b, c ServerSku - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, &a, serverSkuAuxDeviceDBTypes, false, strmangle.SetComplement(serverSkuAuxDevicePrimaryKeyColumns, serverSkuAuxDeviceColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - if err = randomize.Struct(seed, &b, serverSkuDBTypes, false, strmangle.SetComplement(serverSkuPrimaryKeyColumns, serverSkuColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - if err = randomize.Struct(seed, &c, serverSkuDBTypes, false, strmangle.SetComplement(serverSkuPrimaryKeyColumns, serverSkuColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - - if err := a.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = b.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - for i, x := range []*ServerSku{&b, &c} { - err = a.SetSku(ctx, tx, i != 0, x) - if err != nil { - t.Fatal(err) - } - - if a.R.Sku != x { - t.Error("relationship struct not set to correct value") - } - - if x.R.SkuServerSkuAuxDevices[0] != &a { - t.Error("failed to append to foreign relationship struct") - } - if a.SkuID != x.ID { - t.Error("foreign key was wrong value", a.SkuID) - } - - zero := reflect.Zero(reflect.TypeOf(a.SkuID)) - reflect.Indirect(reflect.ValueOf(&a.SkuID)).Set(zero) - - if err = a.Reload(ctx, tx); err != nil { - t.Fatal("failed to reload", err) - } - - if a.SkuID != x.ID { - t.Error("foreign key was wrong value", a.SkuID, x.ID) - } - } -} - -func testServerSkuAuxDevicesReload(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if err = o.Reload(ctx, tx); err != nil { - t.Error(err) - } -} - -func testServerSkuAuxDevicesReloadAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice := ServerSkuAuxDeviceSlice{o} - - if err = slice.ReloadAll(ctx, tx); err != nil { - t.Error(err) - } -} - -func testServerSkuAuxDevicesSelect(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice, err := ServerSkuAuxDevices().All(ctx, tx) - if err != nil { - t.Error(err) - } - - if len(slice) != 1 { - t.Error("want one record, got:", len(slice)) - } -} - -var ( - serverSkuAuxDeviceDBTypes = map[string]string{`ID`: `uuid`, `SkuID`: `uuid`, `Vendor`: `string`, `Model`: `string`, `DeviceType`: `string`, `Details`: `jsonb`, `CreatedAt`: `timestamptz`, `UpdatedAt`: `timestamptz`} - _ = bytes.MinRead -) - -func testServerSkuAuxDevicesUpdate(t *testing.T) { - t.Parallel() - - if 0 == len(serverSkuAuxDevicePrimaryKeyColumns) { - t.Skip("Skipping table with no primary key columns") - } - if len(serverSkuAuxDeviceAllColumns) == len(serverSkuAuxDevicePrimaryKeyColumns) { - t.Skip("Skipping table with only primary key columns") - } - - seed := randomize.NewSeed() - var err error - o := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuAuxDevices().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } - - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true, serverSkuAuxDevicePrimaryKeyColumns...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - if rowsAff, err := o.Update(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only affect one row but affected", rowsAff) - } -} - -func testServerSkuAuxDevicesSliceUpdateAll(t *testing.T) { - t.Parallel() - - if len(serverSkuAuxDeviceAllColumns) == len(serverSkuAuxDevicePrimaryKeyColumns) { - t.Skip("Skipping table with only primary key columns") - } - - seed := randomize.NewSeed() - var err error - o := &ServerSkuAuxDevice{} - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuAuxDevices().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } - - if err = randomize.Struct(seed, o, serverSkuAuxDeviceDBTypes, true, serverSkuAuxDevicePrimaryKeyColumns...); err != nil { - t.Errorf("Unable to randomize ServerSkuAuxDevice struct: %s", err) - } - - // Remove Primary keys and unique columns from what we plan to update - var fields []string - if strmangle.StringSliceMatch(serverSkuAuxDeviceAllColumns, serverSkuAuxDevicePrimaryKeyColumns) { - fields = serverSkuAuxDeviceAllColumns - } else { - fields = strmangle.SetComplement( - serverSkuAuxDeviceAllColumns, - serverSkuAuxDevicePrimaryKeyColumns, - ) - } - - value := reflect.Indirect(reflect.ValueOf(o)) - typ := reflect.TypeOf(o).Elem() - n := typ.NumField() - - updateMap := M{} - for _, col := range fields { - for i := 0; i < n; i++ { - f := typ.Field(i) - if f.Tag.Get("boil") == col { - updateMap[col] = value.Field(i).Interface() - } - } - } - - slice := ServerSkuAuxDeviceSlice{o} - if rowsAff, err := slice.UpdateAll(ctx, tx, updateMap); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("wanted one record updated but got", rowsAff) - } -} diff --git a/internal/models/server_sku_disk.go b/internal/models/server_sku_disk.go deleted file mode 100644 index d91ac18b..00000000 --- a/internal/models/server_sku_disk.go +++ /dev/null @@ -1,1157 +0,0 @@ -// Code generated by SQLBoiler 4.15.0 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT. -// This file is meant to be re-generated in place and/or deleted at any time. - -package models - -import ( - "context" - "database/sql" - "fmt" - "reflect" - "strconv" - "strings" - "sync" - "time" - - "github.com/friendsofgo/errors" - "github.com/volatiletech/null/v8" - "github.com/volatiletech/sqlboiler/v4/boil" - "github.com/volatiletech/sqlboiler/v4/queries" - "github.com/volatiletech/sqlboiler/v4/queries/qm" - "github.com/volatiletech/sqlboiler/v4/queries/qmhelper" - "github.com/volatiletech/strmangle" -) - -// ServerSkuDisk is an object representing the database table. -type ServerSkuDisk struct { - ID string `boil:"id" json:"id" toml:"id" yaml:"id"` - SkuID string `boil:"sku_id" json:"sku_id" toml:"sku_id" yaml:"sku_id"` - Vendor string `boil:"vendor" json:"vendor" toml:"vendor" yaml:"vendor"` - Model string `boil:"model" json:"model" toml:"model" yaml:"model"` - Bytes int64 `boil:"bytes" json:"bytes" toml:"bytes" yaml:"bytes"` - Protocol string `boil:"protocol" json:"protocol" toml:"protocol" yaml:"protocol"` - Count int64 `boil:"count" json:"count" toml:"count" yaml:"count"` - CreatedAt null.Time `boil:"created_at" json:"created_at,omitempty" toml:"created_at" yaml:"created_at,omitempty"` - UpdatedAt null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"` - - R *serverSkuDiskR `boil:"-" json:"-" toml:"-" yaml:"-"` - L serverSkuDiskL `boil:"-" json:"-" toml:"-" yaml:"-"` -} - -var ServerSkuDiskColumns = struct { - ID string - SkuID string - Vendor string - Model string - Bytes string - Protocol string - Count string - CreatedAt string - UpdatedAt string -}{ - ID: "id", - SkuID: "sku_id", - Vendor: "vendor", - Model: "model", - Bytes: "bytes", - Protocol: "protocol", - Count: "count", - CreatedAt: "created_at", - UpdatedAt: "updated_at", -} - -var ServerSkuDiskTableColumns = struct { - ID string - SkuID string - Vendor string - Model string - Bytes string - Protocol string - Count string - CreatedAt string - UpdatedAt string -}{ - ID: "server_sku_disk.id", - SkuID: "server_sku_disk.sku_id", - Vendor: "server_sku_disk.vendor", - Model: "server_sku_disk.model", - Bytes: "server_sku_disk.bytes", - Protocol: "server_sku_disk.protocol", - Count: "server_sku_disk.count", - CreatedAt: "server_sku_disk.created_at", - UpdatedAt: "server_sku_disk.updated_at", -} - -// Generated where - -var ServerSkuDiskWhere = struct { - ID whereHelperstring - SkuID whereHelperstring - Vendor whereHelperstring - Model whereHelperstring - Bytes whereHelperint64 - Protocol whereHelperstring - Count whereHelperint64 - CreatedAt whereHelpernull_Time - UpdatedAt whereHelpernull_Time -}{ - ID: whereHelperstring{field: "\"server_sku_disk\".\"id\""}, - SkuID: whereHelperstring{field: "\"server_sku_disk\".\"sku_id\""}, - Vendor: whereHelperstring{field: "\"server_sku_disk\".\"vendor\""}, - Model: whereHelperstring{field: "\"server_sku_disk\".\"model\""}, - Bytes: whereHelperint64{field: "\"server_sku_disk\".\"bytes\""}, - Protocol: whereHelperstring{field: "\"server_sku_disk\".\"protocol\""}, - Count: whereHelperint64{field: "\"server_sku_disk\".\"count\""}, - CreatedAt: whereHelpernull_Time{field: "\"server_sku_disk\".\"created_at\""}, - UpdatedAt: whereHelpernull_Time{field: "\"server_sku_disk\".\"updated_at\""}, -} - -// ServerSkuDiskRels is where relationship names are stored. -var ServerSkuDiskRels = struct { - Sku string -}{ - Sku: "Sku", -} - -// serverSkuDiskR is where relationships are stored. -type serverSkuDiskR struct { - Sku *ServerSku `boil:"Sku" json:"Sku" toml:"Sku" yaml:"Sku"` -} - -// NewStruct creates a new relationship struct -func (*serverSkuDiskR) NewStruct() *serverSkuDiskR { - return &serverSkuDiskR{} -} - -func (r *serverSkuDiskR) GetSku() *ServerSku { - if r == nil { - return nil - } - return r.Sku -} - -// serverSkuDiskL is where Load methods for each relationship are stored. -type serverSkuDiskL struct{} - -var ( - serverSkuDiskAllColumns = []string{"id", "sku_id", "vendor", "model", "bytes", "protocol", "count", "created_at", "updated_at"} - serverSkuDiskColumnsWithoutDefault = []string{"sku_id", "vendor", "model", "bytes", "protocol", "count"} - serverSkuDiskColumnsWithDefault = []string{"id", "created_at", "updated_at"} - serverSkuDiskPrimaryKeyColumns = []string{"id"} - serverSkuDiskGeneratedColumns = []string{} -) - -type ( - // ServerSkuDiskSlice is an alias for a slice of pointers to ServerSkuDisk. - // This should almost always be used instead of []ServerSkuDisk. - ServerSkuDiskSlice []*ServerSkuDisk - // ServerSkuDiskHook is the signature for custom ServerSkuDisk hook methods - ServerSkuDiskHook func(context.Context, boil.ContextExecutor, *ServerSkuDisk) error - - serverSkuDiskQuery struct { - *queries.Query - } -) - -// Cache for insert, update and upsert -var ( - serverSkuDiskType = reflect.TypeOf(&ServerSkuDisk{}) - serverSkuDiskMapping = queries.MakeStructMapping(serverSkuDiskType) - serverSkuDiskPrimaryKeyMapping, _ = queries.BindMapping(serverSkuDiskType, serverSkuDiskMapping, serverSkuDiskPrimaryKeyColumns) - serverSkuDiskInsertCacheMut sync.RWMutex - serverSkuDiskInsertCache = make(map[string]insertCache) - serverSkuDiskUpdateCacheMut sync.RWMutex - serverSkuDiskUpdateCache = make(map[string]updateCache) - serverSkuDiskUpsertCacheMut sync.RWMutex - serverSkuDiskUpsertCache = make(map[string]insertCache) -) - -var ( - // Force time package dependency for automated UpdatedAt/CreatedAt. - _ = time.Second - // Force qmhelper dependency for where clause generation (which doesn't - // always happen) - _ = qmhelper.Where -) - -var serverSkuDiskAfterSelectHooks []ServerSkuDiskHook - -var serverSkuDiskBeforeInsertHooks []ServerSkuDiskHook -var serverSkuDiskAfterInsertHooks []ServerSkuDiskHook - -var serverSkuDiskBeforeUpdateHooks []ServerSkuDiskHook -var serverSkuDiskAfterUpdateHooks []ServerSkuDiskHook - -var serverSkuDiskBeforeDeleteHooks []ServerSkuDiskHook -var serverSkuDiskAfterDeleteHooks []ServerSkuDiskHook - -var serverSkuDiskBeforeUpsertHooks []ServerSkuDiskHook -var serverSkuDiskAfterUpsertHooks []ServerSkuDiskHook - -// doAfterSelectHooks executes all "after Select" hooks. -func (o *ServerSkuDisk) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuDiskAfterSelectHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeInsertHooks executes all "before insert" hooks. -func (o *ServerSkuDisk) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuDiskBeforeInsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterInsertHooks executes all "after Insert" hooks. -func (o *ServerSkuDisk) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuDiskAfterInsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeUpdateHooks executes all "before Update" hooks. -func (o *ServerSkuDisk) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuDiskBeforeUpdateHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterUpdateHooks executes all "after Update" hooks. -func (o *ServerSkuDisk) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuDiskAfterUpdateHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeDeleteHooks executes all "before Delete" hooks. -func (o *ServerSkuDisk) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuDiskBeforeDeleteHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterDeleteHooks executes all "after Delete" hooks. -func (o *ServerSkuDisk) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuDiskAfterDeleteHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeUpsertHooks executes all "before Upsert" hooks. -func (o *ServerSkuDisk) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuDiskBeforeUpsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterUpsertHooks executes all "after Upsert" hooks. -func (o *ServerSkuDisk) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuDiskAfterUpsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// AddServerSkuDiskHook registers your hook function for all future operations. -func AddServerSkuDiskHook(hookPoint boil.HookPoint, serverSkuDiskHook ServerSkuDiskHook) { - switch hookPoint { - case boil.AfterSelectHook: - serverSkuDiskAfterSelectHooks = append(serverSkuDiskAfterSelectHooks, serverSkuDiskHook) - case boil.BeforeInsertHook: - serverSkuDiskBeforeInsertHooks = append(serverSkuDiskBeforeInsertHooks, serverSkuDiskHook) - case boil.AfterInsertHook: - serverSkuDiskAfterInsertHooks = append(serverSkuDiskAfterInsertHooks, serverSkuDiskHook) - case boil.BeforeUpdateHook: - serverSkuDiskBeforeUpdateHooks = append(serverSkuDiskBeforeUpdateHooks, serverSkuDiskHook) - case boil.AfterUpdateHook: - serverSkuDiskAfterUpdateHooks = append(serverSkuDiskAfterUpdateHooks, serverSkuDiskHook) - case boil.BeforeDeleteHook: - serverSkuDiskBeforeDeleteHooks = append(serverSkuDiskBeforeDeleteHooks, serverSkuDiskHook) - case boil.AfterDeleteHook: - serverSkuDiskAfterDeleteHooks = append(serverSkuDiskAfterDeleteHooks, serverSkuDiskHook) - case boil.BeforeUpsertHook: - serverSkuDiskBeforeUpsertHooks = append(serverSkuDiskBeforeUpsertHooks, serverSkuDiskHook) - case boil.AfterUpsertHook: - serverSkuDiskAfterUpsertHooks = append(serverSkuDiskAfterUpsertHooks, serverSkuDiskHook) - } -} - -// One returns a single serverSkuDisk record from the query. -func (q serverSkuDiskQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServerSkuDisk, error) { - o := &ServerSkuDisk{} - - queries.SetLimit(q.Query, 1) - - err := q.Bind(ctx, exec, o) - if err != nil { - if errors.Is(err, sql.ErrNoRows) { - return nil, sql.ErrNoRows - } - return nil, errors.Wrap(err, "models: failed to execute a one query for server_sku_disk") - } - - if err := o.doAfterSelectHooks(ctx, exec); err != nil { - return o, err - } - - return o, nil -} - -// All returns all ServerSkuDisk records from the query. -func (q serverSkuDiskQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServerSkuDiskSlice, error) { - var o []*ServerSkuDisk - - err := q.Bind(ctx, exec, &o) - if err != nil { - return nil, errors.Wrap(err, "models: failed to assign all query results to ServerSkuDisk slice") - } - - if len(serverSkuDiskAfterSelectHooks) != 0 { - for _, obj := range o { - if err := obj.doAfterSelectHooks(ctx, exec); err != nil { - return o, err - } - } - } - - return o, nil -} - -// Count returns the count of all ServerSkuDisk records in the query. -func (q serverSkuDiskQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - var count int64 - - queries.SetSelect(q.Query, nil) - queries.SetCount(q.Query) - - err := q.Query.QueryRowContext(ctx, exec).Scan(&count) - if err != nil { - return 0, errors.Wrap(err, "models: failed to count server_sku_disk rows") - } - - return count, nil -} - -// Exists checks if the row exists in the table. -func (q serverSkuDiskQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { - var count int64 - - queries.SetSelect(q.Query, nil) - queries.SetCount(q.Query) - queries.SetLimit(q.Query, 1) - - err := q.Query.QueryRowContext(ctx, exec).Scan(&count) - if err != nil { - return false, errors.Wrap(err, "models: failed to check if server_sku_disk exists") - } - - return count > 0, nil -} - -// Sku pointed to by the foreign key. -func (o *ServerSkuDisk) Sku(mods ...qm.QueryMod) serverSkuQuery { - queryMods := []qm.QueryMod{ - qm.Where("\"id\" = ?", o.SkuID), - } - - queryMods = append(queryMods, mods...) - - return ServerSkus(queryMods...) -} - -// LoadSku allows an eager lookup of values, cached into the -// loaded structs of the objects. This is for an N-1 relationship. -func (serverSkuDiskL) LoadSku(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServerSkuDisk interface{}, mods queries.Applicator) error { - var slice []*ServerSkuDisk - var object *ServerSkuDisk - - if singular { - var ok bool - object, ok = maybeServerSkuDisk.(*ServerSkuDisk) - if !ok { - object = new(ServerSkuDisk) - ok = queries.SetFromEmbeddedStruct(&object, &maybeServerSkuDisk) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", object, maybeServerSkuDisk)) - } - } - } else { - s, ok := maybeServerSkuDisk.(*[]*ServerSkuDisk) - if ok { - slice = *s - } else { - ok = queries.SetFromEmbeddedStruct(&slice, maybeServerSkuDisk) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", slice, maybeServerSkuDisk)) - } - } - } - - args := make([]interface{}, 0, 1) - if singular { - if object.R == nil { - object.R = &serverSkuDiskR{} - } - args = append(args, object.SkuID) - - } else { - Outer: - for _, obj := range slice { - if obj.R == nil { - obj.R = &serverSkuDiskR{} - } - - for _, a := range args { - if a == obj.SkuID { - continue Outer - } - } - - args = append(args, obj.SkuID) - - } - } - - if len(args) == 0 { - return nil - } - - query := NewQuery( - qm.From(`server_sku`), - qm.WhereIn(`server_sku.id in ?`, args...), - ) - if mods != nil { - mods.Apply(query) - } - - results, err := query.QueryContext(ctx, e) - if err != nil { - return errors.Wrap(err, "failed to eager load ServerSku") - } - - var resultSlice []*ServerSku - if err = queries.Bind(results, &resultSlice); err != nil { - return errors.Wrap(err, "failed to bind eager loaded slice ServerSku") - } - - if err = results.Close(); err != nil { - return errors.Wrap(err, "failed to close results of eager load for server_sku") - } - if err = results.Err(); err != nil { - return errors.Wrap(err, "error occurred during iteration of eager loaded relations for server_sku") - } - - if len(serverSkuAfterSelectHooks) != 0 { - for _, obj := range resultSlice { - if err := obj.doAfterSelectHooks(ctx, e); err != nil { - return err - } - } - } - - if len(resultSlice) == 0 { - return nil - } - - if singular { - foreign := resultSlice[0] - object.R.Sku = foreign - if foreign.R == nil { - foreign.R = &serverSkuR{} - } - foreign.R.SkuServerSkuDisks = append(foreign.R.SkuServerSkuDisks, object) - return nil - } - - for _, local := range slice { - for _, foreign := range resultSlice { - if local.SkuID == foreign.ID { - local.R.Sku = foreign - if foreign.R == nil { - foreign.R = &serverSkuR{} - } - foreign.R.SkuServerSkuDisks = append(foreign.R.SkuServerSkuDisks, local) - break - } - } - } - - return nil -} - -// SetSku of the serverSkuDisk to the related item. -// Sets o.R.Sku to related. -// Adds o to related.R.SkuServerSkuDisks. -func (o *ServerSkuDisk) SetSku(ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServerSku) error { - var err error - if insert { - if err = related.Insert(ctx, exec, boil.Infer()); err != nil { - return errors.Wrap(err, "failed to insert into foreign table") - } - } - - updateQuery := fmt.Sprintf( - "UPDATE \"server_sku_disk\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, []string{"sku_id"}), - strmangle.WhereClause("\"", "\"", 2, serverSkuDiskPrimaryKeyColumns), - ) - values := []interface{}{related.ID, o.ID} - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, updateQuery) - fmt.Fprintln(writer, values) - } - if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { - return errors.Wrap(err, "failed to update local table") - } - - o.SkuID = related.ID - if o.R == nil { - o.R = &serverSkuDiskR{ - Sku: related, - } - } else { - o.R.Sku = related - } - - if related.R == nil { - related.R = &serverSkuR{ - SkuServerSkuDisks: ServerSkuDiskSlice{o}, - } - } else { - related.R.SkuServerSkuDisks = append(related.R.SkuServerSkuDisks, o) - } - - return nil -} - -// ServerSkuDisks retrieves all the records using an executor. -func ServerSkuDisks(mods ...qm.QueryMod) serverSkuDiskQuery { - mods = append(mods, qm.From("\"server_sku_disk\"")) - q := NewQuery(mods...) - if len(queries.GetSelect(q)) == 0 { - queries.SetSelect(q, []string{"\"server_sku_disk\".*"}) - } - - return serverSkuDiskQuery{q} -} - -// FindServerSkuDisk retrieves a single record by ID with an executor. -// If selectCols is empty Find will return all columns. -func FindServerSkuDisk(ctx context.Context, exec boil.ContextExecutor, iD string, selectCols ...string) (*ServerSkuDisk, error) { - serverSkuDiskObj := &ServerSkuDisk{} - - sel := "*" - if len(selectCols) > 0 { - sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",") - } - query := fmt.Sprintf( - "select %s from \"server_sku_disk\" where \"id\"=$1", sel, - ) - - q := queries.Raw(query, iD) - - err := q.Bind(ctx, exec, serverSkuDiskObj) - if err != nil { - if errors.Is(err, sql.ErrNoRows) { - return nil, sql.ErrNoRows - } - return nil, errors.Wrap(err, "models: unable to select from server_sku_disk") - } - - if err = serverSkuDiskObj.doAfterSelectHooks(ctx, exec); err != nil { - return serverSkuDiskObj, err - } - - return serverSkuDiskObj, nil -} - -// Insert a single record using an executor. -// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts. -func (o *ServerSkuDisk) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error { - if o == nil { - return errors.New("models: no server_sku_disk provided for insertion") - } - - var err error - if !boil.TimestampsAreSkipped(ctx) { - currTime := time.Now().In(boil.GetLocation()) - - if queries.MustTime(o.CreatedAt).IsZero() { - queries.SetScanner(&o.CreatedAt, currTime) - } - if queries.MustTime(o.UpdatedAt).IsZero() { - queries.SetScanner(&o.UpdatedAt, currTime) - } - } - - if err := o.doBeforeInsertHooks(ctx, exec); err != nil { - return err - } - - nzDefaults := queries.NonZeroDefaultSet(serverSkuDiskColumnsWithDefault, o) - - key := makeCacheKey(columns, nzDefaults) - serverSkuDiskInsertCacheMut.RLock() - cache, cached := serverSkuDiskInsertCache[key] - serverSkuDiskInsertCacheMut.RUnlock() - - if !cached { - wl, returnColumns := columns.InsertColumnSet( - serverSkuDiskAllColumns, - serverSkuDiskColumnsWithDefault, - serverSkuDiskColumnsWithoutDefault, - nzDefaults, - ) - - cache.valueMapping, err = queries.BindMapping(serverSkuDiskType, serverSkuDiskMapping, wl) - if err != nil { - return err - } - cache.retMapping, err = queries.BindMapping(serverSkuDiskType, serverSkuDiskMapping, returnColumns) - if err != nil { - return err - } - if len(wl) != 0 { - cache.query = fmt.Sprintf("INSERT INTO \"server_sku_disk\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1)) - } else { - cache.query = "INSERT INTO \"server_sku_disk\" %sDEFAULT VALUES%s" - } - - var queryOutput, queryReturning string - - if len(cache.retMapping) != 0 { - queryReturning = fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\"")) - } - - cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning) - } - - value := reflect.Indirect(reflect.ValueOf(o)) - vals := queries.ValuesFromMapping(value, cache.valueMapping) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, cache.query) - fmt.Fprintln(writer, vals) - } - - if len(cache.retMapping) != 0 { - err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...) - } else { - _, err = exec.ExecContext(ctx, cache.query, vals...) - } - - if err != nil { - return errors.Wrap(err, "models: unable to insert into server_sku_disk") - } - - if !cached { - serverSkuDiskInsertCacheMut.Lock() - serverSkuDiskInsertCache[key] = cache - serverSkuDiskInsertCacheMut.Unlock() - } - - return o.doAfterInsertHooks(ctx, exec) -} - -// Update uses an executor to update the ServerSkuDisk. -// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. -// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records. -func (o *ServerSkuDisk) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) { - if !boil.TimestampsAreSkipped(ctx) { - currTime := time.Now().In(boil.GetLocation()) - - queries.SetScanner(&o.UpdatedAt, currTime) - } - - var err error - if err = o.doBeforeUpdateHooks(ctx, exec); err != nil { - return 0, err - } - key := makeCacheKey(columns, nil) - serverSkuDiskUpdateCacheMut.RLock() - cache, cached := serverSkuDiskUpdateCache[key] - serverSkuDiskUpdateCacheMut.RUnlock() - - if !cached { - wl := columns.UpdateColumnSet( - serverSkuDiskAllColumns, - serverSkuDiskPrimaryKeyColumns, - ) - - if !columns.IsWhitelist() { - wl = strmangle.SetComplement(wl, []string{"created_at"}) - } - if len(wl) == 0 { - return 0, errors.New("models: unable to update server_sku_disk, could not build whitelist") - } - - cache.query = fmt.Sprintf("UPDATE \"server_sku_disk\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, wl), - strmangle.WhereClause("\"", "\"", len(wl)+1, serverSkuDiskPrimaryKeyColumns), - ) - cache.valueMapping, err = queries.BindMapping(serverSkuDiskType, serverSkuDiskMapping, append(wl, serverSkuDiskPrimaryKeyColumns...)) - if err != nil { - return 0, err - } - } - - values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, cache.query) - fmt.Fprintln(writer, values) - } - var result sql.Result - result, err = exec.ExecContext(ctx, cache.query, values...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to update server_sku_disk row") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by update for server_sku_disk") - } - - if !cached { - serverSkuDiskUpdateCacheMut.Lock() - serverSkuDiskUpdateCache[key] = cache - serverSkuDiskUpdateCacheMut.Unlock() - } - - return rowsAff, o.doAfterUpdateHooks(ctx, exec) -} - -// UpdateAll updates all rows with the specified column values. -func (q serverSkuDiskQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { - queries.SetUpdate(q.Query, cols) - - result, err := q.Query.ExecContext(ctx, exec) - if err != nil { - return 0, errors.Wrap(err, "models: unable to update all for server_sku_disk") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: unable to retrieve rows affected for server_sku_disk") - } - - return rowsAff, nil -} - -// UpdateAll updates all rows with the specified column values, using an executor. -func (o ServerSkuDiskSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { - ln := int64(len(o)) - if ln == 0 { - return 0, nil - } - - if len(cols) == 0 { - return 0, errors.New("models: update all requires at least one column argument") - } - - colNames := make([]string, len(cols)) - args := make([]interface{}, len(cols)) - - i := 0 - for name, value := range cols { - colNames[i] = name - args[i] = value - i++ - } - - // Append all of the primary key values for each column - for _, obj := range o { - pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), serverSkuDiskPrimaryKeyMapping) - args = append(args, pkeyArgs...) - } - - sql := fmt.Sprintf("UPDATE \"server_sku_disk\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, colNames), - strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), len(colNames)+1, serverSkuDiskPrimaryKeyColumns, len(o))) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, args...) - } - result, err := exec.ExecContext(ctx, sql, args...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to update all in serverSkuDisk slice") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: unable to retrieve rows affected all in update all serverSkuDisk") - } - return rowsAff, nil -} - -// Delete deletes a single ServerSkuDisk record with an executor. -// Delete will match against the primary key column to find the record to delete. -func (o *ServerSkuDisk) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - if o == nil { - return 0, errors.New("models: no ServerSkuDisk provided for delete") - } - - if err := o.doBeforeDeleteHooks(ctx, exec); err != nil { - return 0, err - } - - args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), serverSkuDiskPrimaryKeyMapping) - sql := "DELETE FROM \"server_sku_disk\" WHERE \"id\"=$1" - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, args...) - } - result, err := exec.ExecContext(ctx, sql, args...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to delete from server_sku_disk") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by delete for server_sku_disk") - } - - if err := o.doAfterDeleteHooks(ctx, exec); err != nil { - return 0, err - } - - return rowsAff, nil -} - -// DeleteAll deletes all matching rows. -func (q serverSkuDiskQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - if q.Query == nil { - return 0, errors.New("models: no serverSkuDiskQuery provided for delete all") - } - - queries.SetDelete(q.Query) - - result, err := q.Query.ExecContext(ctx, exec) - if err != nil { - return 0, errors.Wrap(err, "models: unable to delete all from server_sku_disk") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for server_sku_disk") - } - - return rowsAff, nil -} - -// DeleteAll deletes all rows in the slice, using an executor. -func (o ServerSkuDiskSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - if len(o) == 0 { - return 0, nil - } - - if len(serverSkuDiskBeforeDeleteHooks) != 0 { - for _, obj := range o { - if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil { - return 0, err - } - } - } - - var args []interface{} - for _, obj := range o { - pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), serverSkuDiskPrimaryKeyMapping) - args = append(args, pkeyArgs...) - } - - sql := "DELETE FROM \"server_sku_disk\" WHERE " + - strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, serverSkuDiskPrimaryKeyColumns, len(o)) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, args) - } - result, err := exec.ExecContext(ctx, sql, args...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to delete all from serverSkuDisk slice") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for server_sku_disk") - } - - if len(serverSkuDiskAfterDeleteHooks) != 0 { - for _, obj := range o { - if err := obj.doAfterDeleteHooks(ctx, exec); err != nil { - return 0, err - } - } - } - - return rowsAff, nil -} - -// Reload refetches the object from the database -// using the primary keys with an executor. -func (o *ServerSkuDisk) Reload(ctx context.Context, exec boil.ContextExecutor) error { - ret, err := FindServerSkuDisk(ctx, exec, o.ID) - if err != nil { - return err - } - - *o = *ret - return nil -} - -// ReloadAll refetches every row with matching primary key column values -// and overwrites the original object slice with the newly updated slice. -func (o *ServerSkuDiskSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error { - if o == nil || len(*o) == 0 { - return nil - } - - slice := ServerSkuDiskSlice{} - var args []interface{} - for _, obj := range *o { - pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), serverSkuDiskPrimaryKeyMapping) - args = append(args, pkeyArgs...) - } - - sql := "SELECT \"server_sku_disk\".* FROM \"server_sku_disk\" WHERE " + - strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, serverSkuDiskPrimaryKeyColumns, len(*o)) - - q := queries.Raw(sql, args...) - - err := q.Bind(ctx, exec, &slice) - if err != nil { - return errors.Wrap(err, "models: unable to reload all in ServerSkuDiskSlice") - } - - *o = slice - - return nil -} - -// ServerSkuDiskExists checks if the ServerSkuDisk row exists. -func ServerSkuDiskExists(ctx context.Context, exec boil.ContextExecutor, iD string) (bool, error) { - var exists bool - sql := "select exists(select 1 from \"server_sku_disk\" where \"id\"=$1 limit 1)" - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, iD) - } - row := exec.QueryRowContext(ctx, sql, iD) - - err := row.Scan(&exists) - if err != nil { - return false, errors.Wrap(err, "models: unable to check if server_sku_disk exists") - } - - return exists, nil -} - -// Exists checks if the ServerSkuDisk row exists. -func (o *ServerSkuDisk) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { - return ServerSkuDiskExists(ctx, exec, o.ID) -} - -// Upsert attempts an insert using an executor, and does an update or ignore on conflict. -// See boil.Columns documentation for how to properly use updateColumns and insertColumns. -func (o *ServerSkuDisk) Upsert(ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error { - if o == nil { - return errors.New("models: no server_sku_disk provided for upsert") - } - if !boil.TimestampsAreSkipped(ctx) { - currTime := time.Now().In(boil.GetLocation()) - - if queries.MustTime(o.CreatedAt).IsZero() { - queries.SetScanner(&o.CreatedAt, currTime) - } - queries.SetScanner(&o.UpdatedAt, currTime) - } - - if err := o.doBeforeUpsertHooks(ctx, exec); err != nil { - return err - } - - nzDefaults := queries.NonZeroDefaultSet(serverSkuDiskColumnsWithDefault, o) - - // Build cache key in-line uglily - mysql vs psql problems - buf := strmangle.GetBuffer() - if updateOnConflict { - buf.WriteByte('t') - } else { - buf.WriteByte('f') - } - buf.WriteByte('.') - for _, c := range conflictColumns { - buf.WriteString(c) - } - buf.WriteByte('.') - buf.WriteString(strconv.Itoa(updateColumns.Kind)) - for _, c := range updateColumns.Cols { - buf.WriteString(c) - } - buf.WriteByte('.') - buf.WriteString(strconv.Itoa(insertColumns.Kind)) - for _, c := range insertColumns.Cols { - buf.WriteString(c) - } - buf.WriteByte('.') - for _, c := range nzDefaults { - buf.WriteString(c) - } - key := buf.String() - strmangle.PutBuffer(buf) - - serverSkuDiskUpsertCacheMut.RLock() - cache, cached := serverSkuDiskUpsertCache[key] - serverSkuDiskUpsertCacheMut.RUnlock() - - var err error - - if !cached { - insert, ret := insertColumns.InsertColumnSet( - serverSkuDiskAllColumns, - serverSkuDiskColumnsWithDefault, - serverSkuDiskColumnsWithoutDefault, - nzDefaults, - ) - update := updateColumns.UpdateColumnSet( - serverSkuDiskAllColumns, - serverSkuDiskPrimaryKeyColumns, - ) - - if updateOnConflict && len(update) == 0 { - return errors.New("models: unable to upsert server_sku_disk, could not build update column list") - } - - conflict := conflictColumns - if len(conflict) == 0 { - conflict = make([]string, len(serverSkuDiskPrimaryKeyColumns)) - copy(conflict, serverSkuDiskPrimaryKeyColumns) - } - cache.query = buildUpsertQueryCockroachDB(dialect, "\"server_sku_disk\"", updateOnConflict, ret, update, conflict, insert) - - cache.valueMapping, err = queries.BindMapping(serverSkuDiskType, serverSkuDiskMapping, insert) - if err != nil { - return err - } - if len(ret) != 0 { - cache.retMapping, err = queries.BindMapping(serverSkuDiskType, serverSkuDiskMapping, ret) - if err != nil { - return err - } - } - } - - value := reflect.Indirect(reflect.ValueOf(o)) - vals := queries.ValuesFromMapping(value, cache.valueMapping) - var returns []interface{} - if len(cache.retMapping) != 0 { - returns = queries.PtrsFromMapping(value, cache.retMapping) - } - - if boil.DebugMode { - _, _ = fmt.Fprintln(boil.DebugWriter, cache.query) - _, _ = fmt.Fprintln(boil.DebugWriter, vals) - } - - if len(cache.retMapping) != 0 { - err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(returns...) - if err == sql.ErrNoRows { - err = nil // CockcorachDB doesn't return anything when there's no update - } - } else { - _, err = exec.ExecContext(ctx, cache.query, vals...) - } - if err != nil { - return errors.Wrap(err, "models: unable to upsert server_sku_disk") - } - - if !cached { - serverSkuDiskUpsertCacheMut.Lock() - serverSkuDiskUpsertCache[key] = cache - serverSkuDiskUpsertCacheMut.Unlock() - } - - return o.doAfterUpsertHooks(ctx, exec) -} diff --git a/internal/models/server_sku_disk_test.go b/internal/models/server_sku_disk_test.go deleted file mode 100644 index 1621d6bd..00000000 --- a/internal/models/server_sku_disk_test.go +++ /dev/null @@ -1,851 +0,0 @@ -// Code generated by SQLBoiler 4.15.0 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT. -// This file is meant to be re-generated in place and/or deleted at any time. - -package models - -import ( - "bytes" - "context" - "reflect" - "testing" - - "github.com/volatiletech/randomize" - "github.com/volatiletech/sqlboiler/v4/boil" - "github.com/volatiletech/sqlboiler/v4/queries" - "github.com/volatiletech/strmangle" -) - -func testServerSkuDisksUpsert(t *testing.T) { - t.Parallel() - - if len(serverSkuDiskAllColumns) == len(serverSkuDiskPrimaryKeyColumns) { - t.Skip("Skipping table with only primary key columns") - } - - seed := randomize.NewSeed() - var err error - // Attempt the INSERT side of an UPSERT - o := ServerSkuDisk{} - if err = randomize.Struct(seed, &o, serverSkuDiskDBTypes, true); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Upsert(ctx, tx, false, nil, boil.Infer(), boil.Infer()); err != nil { - t.Errorf("Unable to upsert ServerSkuDisk: %s", err) - } - - count, err := ServerSkuDisks().Count(ctx, tx) - if err != nil { - t.Error(err) - } - if count != 1 { - t.Error("want one record, got:", count) - } - - // Attempt the UPDATE side of an UPSERT - if err = randomize.Struct(seed, &o, serverSkuDiskDBTypes, false, serverSkuDiskPrimaryKeyColumns...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - if err = o.Upsert(ctx, tx, true, nil, boil.Infer(), boil.Infer()); err != nil { - t.Errorf("Unable to upsert ServerSkuDisk: %s", err) - } - - count, err = ServerSkuDisks().Count(ctx, tx) - if err != nil { - t.Error(err) - } - if count != 1 { - t.Error("want one record, got:", count) - } -} - -var ( - // Relationships sometimes use the reflection helper queries.Equal/queries.Assign - // so force a package dependency in case they don't. - _ = queries.Equal -) - -func testServerSkuDisks(t *testing.T) { - t.Parallel() - - query := ServerSkuDisks() - - if query.Query == nil { - t.Error("expected a query, got nothing") - } -} - -func testServerSkuDisksDelete(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuDisk{} - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if rowsAff, err := o.Delete(ctx, tx); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only have deleted one row, but affected:", rowsAff) - } - - count, err := ServerSkuDisks().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 0 { - t.Error("want zero records, got:", count) - } -} - -func testServerSkuDisksQueryDeleteAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuDisk{} - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if rowsAff, err := ServerSkuDisks().DeleteAll(ctx, tx); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only have deleted one row, but affected:", rowsAff) - } - - count, err := ServerSkuDisks().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 0 { - t.Error("want zero records, got:", count) - } -} - -func testServerSkuDisksSliceDeleteAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuDisk{} - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice := ServerSkuDiskSlice{o} - - if rowsAff, err := slice.DeleteAll(ctx, tx); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only have deleted one row, but affected:", rowsAff) - } - - count, err := ServerSkuDisks().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 0 { - t.Error("want zero records, got:", count) - } -} - -func testServerSkuDisksExists(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuDisk{} - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - e, err := ServerSkuDiskExists(ctx, tx, o.ID) - if err != nil { - t.Errorf("Unable to check if ServerSkuDisk exists: %s", err) - } - if !e { - t.Errorf("Expected ServerSkuDiskExists to return true, but got false.") - } -} - -func testServerSkuDisksFind(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuDisk{} - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - serverSkuDiskFound, err := FindServerSkuDisk(ctx, tx, o.ID) - if err != nil { - t.Error(err) - } - - if serverSkuDiskFound == nil { - t.Error("want a record, got nil") - } -} - -func testServerSkuDisksBind(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuDisk{} - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if err = ServerSkuDisks().Bind(ctx, tx, o); err != nil { - t.Error(err) - } -} - -func testServerSkuDisksOne(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuDisk{} - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if x, err := ServerSkuDisks().One(ctx, tx); err != nil { - t.Error(err) - } else if x == nil { - t.Error("expected to get a non nil record") - } -} - -func testServerSkuDisksAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - serverSkuDiskOne := &ServerSkuDisk{} - serverSkuDiskTwo := &ServerSkuDisk{} - if err = randomize.Struct(seed, serverSkuDiskOne, serverSkuDiskDBTypes, false, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - if err = randomize.Struct(seed, serverSkuDiskTwo, serverSkuDiskDBTypes, false, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = serverSkuDiskOne.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - if err = serverSkuDiskTwo.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice, err := ServerSkuDisks().All(ctx, tx) - if err != nil { - t.Error(err) - } - - if len(slice) != 2 { - t.Error("want 2 records, got:", len(slice)) - } -} - -func testServerSkuDisksCount(t *testing.T) { - t.Parallel() - - var err error - seed := randomize.NewSeed() - serverSkuDiskOne := &ServerSkuDisk{} - serverSkuDiskTwo := &ServerSkuDisk{} - if err = randomize.Struct(seed, serverSkuDiskOne, serverSkuDiskDBTypes, false, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - if err = randomize.Struct(seed, serverSkuDiskTwo, serverSkuDiskDBTypes, false, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = serverSkuDiskOne.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - if err = serverSkuDiskTwo.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuDisks().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 2 { - t.Error("want 2 records, got:", count) - } -} - -func serverSkuDiskBeforeInsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuDisk) error { - *o = ServerSkuDisk{} - return nil -} - -func serverSkuDiskAfterInsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuDisk) error { - *o = ServerSkuDisk{} - return nil -} - -func serverSkuDiskAfterSelectHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuDisk) error { - *o = ServerSkuDisk{} - return nil -} - -func serverSkuDiskBeforeUpdateHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuDisk) error { - *o = ServerSkuDisk{} - return nil -} - -func serverSkuDiskAfterUpdateHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuDisk) error { - *o = ServerSkuDisk{} - return nil -} - -func serverSkuDiskBeforeDeleteHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuDisk) error { - *o = ServerSkuDisk{} - return nil -} - -func serverSkuDiskAfterDeleteHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuDisk) error { - *o = ServerSkuDisk{} - return nil -} - -func serverSkuDiskBeforeUpsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuDisk) error { - *o = ServerSkuDisk{} - return nil -} - -func serverSkuDiskAfterUpsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuDisk) error { - *o = ServerSkuDisk{} - return nil -} - -func testServerSkuDisksHooks(t *testing.T) { - t.Parallel() - - var err error - - ctx := context.Background() - empty := &ServerSkuDisk{} - o := &ServerSkuDisk{} - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, false); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk object: %s", err) - } - - AddServerSkuDiskHook(boil.BeforeInsertHook, serverSkuDiskBeforeInsertHook) - if err = o.doBeforeInsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeInsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeInsertHook function to empty object, but got: %#v", o) - } - serverSkuDiskBeforeInsertHooks = []ServerSkuDiskHook{} - - AddServerSkuDiskHook(boil.AfterInsertHook, serverSkuDiskAfterInsertHook) - if err = o.doAfterInsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterInsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterInsertHook function to empty object, but got: %#v", o) - } - serverSkuDiskAfterInsertHooks = []ServerSkuDiskHook{} - - AddServerSkuDiskHook(boil.AfterSelectHook, serverSkuDiskAfterSelectHook) - if err = o.doAfterSelectHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterSelectHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterSelectHook function to empty object, but got: %#v", o) - } - serverSkuDiskAfterSelectHooks = []ServerSkuDiskHook{} - - AddServerSkuDiskHook(boil.BeforeUpdateHook, serverSkuDiskBeforeUpdateHook) - if err = o.doBeforeUpdateHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeUpdateHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeUpdateHook function to empty object, but got: %#v", o) - } - serverSkuDiskBeforeUpdateHooks = []ServerSkuDiskHook{} - - AddServerSkuDiskHook(boil.AfterUpdateHook, serverSkuDiskAfterUpdateHook) - if err = o.doAfterUpdateHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterUpdateHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterUpdateHook function to empty object, but got: %#v", o) - } - serverSkuDiskAfterUpdateHooks = []ServerSkuDiskHook{} - - AddServerSkuDiskHook(boil.BeforeDeleteHook, serverSkuDiskBeforeDeleteHook) - if err = o.doBeforeDeleteHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeDeleteHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeDeleteHook function to empty object, but got: %#v", o) - } - serverSkuDiskBeforeDeleteHooks = []ServerSkuDiskHook{} - - AddServerSkuDiskHook(boil.AfterDeleteHook, serverSkuDiskAfterDeleteHook) - if err = o.doAfterDeleteHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterDeleteHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterDeleteHook function to empty object, but got: %#v", o) - } - serverSkuDiskAfterDeleteHooks = []ServerSkuDiskHook{} - - AddServerSkuDiskHook(boil.BeforeUpsertHook, serverSkuDiskBeforeUpsertHook) - if err = o.doBeforeUpsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeUpsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeUpsertHook function to empty object, but got: %#v", o) - } - serverSkuDiskBeforeUpsertHooks = []ServerSkuDiskHook{} - - AddServerSkuDiskHook(boil.AfterUpsertHook, serverSkuDiskAfterUpsertHook) - if err = o.doAfterUpsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterUpsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterUpsertHook function to empty object, but got: %#v", o) - } - serverSkuDiskAfterUpsertHooks = []ServerSkuDiskHook{} -} - -func testServerSkuDisksInsert(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuDisk{} - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuDisks().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } -} - -func testServerSkuDisksInsertWhitelist(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuDisk{} - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Whitelist(serverSkuDiskColumnsWithoutDefault...)); err != nil { - t.Error(err) - } - - count, err := ServerSkuDisks().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } -} - -func testServerSkuDiskToOneServerSkuUsingSku(t *testing.T) { - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var local ServerSkuDisk - var foreign ServerSku - - seed := randomize.NewSeed() - if err := randomize.Struct(seed, &local, serverSkuDiskDBTypes, false, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - if err := randomize.Struct(seed, &foreign, serverSkuDBTypes, false, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - if err := foreign.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - local.SkuID = foreign.ID - if err := local.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - check, err := local.Sku().One(ctx, tx) - if err != nil { - t.Fatal(err) - } - - if check.ID != foreign.ID { - t.Errorf("want: %v, got %v", foreign.ID, check.ID) - } - - ranAfterSelectHook := false - AddServerSkuHook(boil.AfterSelectHook, func(ctx context.Context, e boil.ContextExecutor, o *ServerSku) error { - ranAfterSelectHook = true - return nil - }) - - slice := ServerSkuDiskSlice{&local} - if err = local.L.LoadSku(ctx, tx, false, (*[]*ServerSkuDisk)(&slice), nil); err != nil { - t.Fatal(err) - } - if local.R.Sku == nil { - t.Error("struct should have been eager loaded") - } - - local.R.Sku = nil - if err = local.L.LoadSku(ctx, tx, true, &local, nil); err != nil { - t.Fatal(err) - } - if local.R.Sku == nil { - t.Error("struct should have been eager loaded") - } - - if !ranAfterSelectHook { - t.Error("failed to run AfterSelect hook for relationship") - } -} - -func testServerSkuDiskToOneSetOpServerSkuUsingSku(t *testing.T) { - var err error - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var a ServerSkuDisk - var b, c ServerSku - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, &a, serverSkuDiskDBTypes, false, strmangle.SetComplement(serverSkuDiskPrimaryKeyColumns, serverSkuDiskColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - if err = randomize.Struct(seed, &b, serverSkuDBTypes, false, strmangle.SetComplement(serverSkuPrimaryKeyColumns, serverSkuColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - if err = randomize.Struct(seed, &c, serverSkuDBTypes, false, strmangle.SetComplement(serverSkuPrimaryKeyColumns, serverSkuColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - - if err := a.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = b.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - for i, x := range []*ServerSku{&b, &c} { - err = a.SetSku(ctx, tx, i != 0, x) - if err != nil { - t.Fatal(err) - } - - if a.R.Sku != x { - t.Error("relationship struct not set to correct value") - } - - if x.R.SkuServerSkuDisks[0] != &a { - t.Error("failed to append to foreign relationship struct") - } - if a.SkuID != x.ID { - t.Error("foreign key was wrong value", a.SkuID) - } - - zero := reflect.Zero(reflect.TypeOf(a.SkuID)) - reflect.Indirect(reflect.ValueOf(&a.SkuID)).Set(zero) - - if err = a.Reload(ctx, tx); err != nil { - t.Fatal("failed to reload", err) - } - - if a.SkuID != x.ID { - t.Error("foreign key was wrong value", a.SkuID, x.ID) - } - } -} - -func testServerSkuDisksReload(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuDisk{} - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if err = o.Reload(ctx, tx); err != nil { - t.Error(err) - } -} - -func testServerSkuDisksReloadAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuDisk{} - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice := ServerSkuDiskSlice{o} - - if err = slice.ReloadAll(ctx, tx); err != nil { - t.Error(err) - } -} - -func testServerSkuDisksSelect(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuDisk{} - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice, err := ServerSkuDisks().All(ctx, tx) - if err != nil { - t.Error(err) - } - - if len(slice) != 1 { - t.Error("want one record, got:", len(slice)) - } -} - -var ( - serverSkuDiskDBTypes = map[string]string{`ID`: `uuid`, `SkuID`: `uuid`, `Vendor`: `string`, `Model`: `string`, `Bytes`: `int8`, `Protocol`: `string`, `Count`: `int8`, `CreatedAt`: `timestamptz`, `UpdatedAt`: `timestamptz`} - _ = bytes.MinRead -) - -func testServerSkuDisksUpdate(t *testing.T) { - t.Parallel() - - if 0 == len(serverSkuDiskPrimaryKeyColumns) { - t.Skip("Skipping table with no primary key columns") - } - if len(serverSkuDiskAllColumns) == len(serverSkuDiskPrimaryKeyColumns) { - t.Skip("Skipping table with only primary key columns") - } - - seed := randomize.NewSeed() - var err error - o := &ServerSkuDisk{} - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuDisks().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } - - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true, serverSkuDiskPrimaryKeyColumns...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - if rowsAff, err := o.Update(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only affect one row but affected", rowsAff) - } -} - -func testServerSkuDisksSliceUpdateAll(t *testing.T) { - t.Parallel() - - if len(serverSkuDiskAllColumns) == len(serverSkuDiskPrimaryKeyColumns) { - t.Skip("Skipping table with only primary key columns") - } - - seed := randomize.NewSeed() - var err error - o := &ServerSkuDisk{} - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true, serverSkuDiskColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuDisks().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } - - if err = randomize.Struct(seed, o, serverSkuDiskDBTypes, true, serverSkuDiskPrimaryKeyColumns...); err != nil { - t.Errorf("Unable to randomize ServerSkuDisk struct: %s", err) - } - - // Remove Primary keys and unique columns from what we plan to update - var fields []string - if strmangle.StringSliceMatch(serverSkuDiskAllColumns, serverSkuDiskPrimaryKeyColumns) { - fields = serverSkuDiskAllColumns - } else { - fields = strmangle.SetComplement( - serverSkuDiskAllColumns, - serverSkuDiskPrimaryKeyColumns, - ) - } - - value := reflect.Indirect(reflect.ValueOf(o)) - typ := reflect.TypeOf(o).Elem() - n := typ.NumField() - - updateMap := M{} - for _, col := range fields { - for i := 0; i < n; i++ { - f := typ.Field(i) - if f.Tag.Get("boil") == col { - updateMap[col] = value.Field(i).Interface() - } - } - } - - slice := ServerSkuDiskSlice{o} - if rowsAff, err := slice.UpdateAll(ctx, tx, updateMap); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("wanted one record updated but got", rowsAff) - } -} diff --git a/internal/models/server_sku_memory.go b/internal/models/server_sku_memory.go deleted file mode 100644 index 9f4a0227..00000000 --- a/internal/models/server_sku_memory.go +++ /dev/null @@ -1,1150 +0,0 @@ -// Code generated by SQLBoiler 4.15.0 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT. -// This file is meant to be re-generated in place and/or deleted at any time. - -package models - -import ( - "context" - "database/sql" - "fmt" - "reflect" - "strconv" - "strings" - "sync" - "time" - - "github.com/friendsofgo/errors" - "github.com/volatiletech/null/v8" - "github.com/volatiletech/sqlboiler/v4/boil" - "github.com/volatiletech/sqlboiler/v4/queries" - "github.com/volatiletech/sqlboiler/v4/queries/qm" - "github.com/volatiletech/sqlboiler/v4/queries/qmhelper" - "github.com/volatiletech/strmangle" -) - -// ServerSkuMemory is an object representing the database table. -type ServerSkuMemory struct { - ID string `boil:"id" json:"id" toml:"id" yaml:"id"` - SkuID string `boil:"sku_id" json:"sku_id" toml:"sku_id" yaml:"sku_id"` - Vendor string `boil:"vendor" json:"vendor" toml:"vendor" yaml:"vendor"` - Model string `boil:"model" json:"model" toml:"model" yaml:"model"` - Bytes int64 `boil:"bytes" json:"bytes" toml:"bytes" yaml:"bytes"` - Count int64 `boil:"count" json:"count" toml:"count" yaml:"count"` - CreatedAt null.Time `boil:"created_at" json:"created_at,omitempty" toml:"created_at" yaml:"created_at,omitempty"` - UpdatedAt null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"` - - R *serverSkuMemoryR `boil:"-" json:"-" toml:"-" yaml:"-"` - L serverSkuMemoryL `boil:"-" json:"-" toml:"-" yaml:"-"` -} - -var ServerSkuMemoryColumns = struct { - ID string - SkuID string - Vendor string - Model string - Bytes string - Count string - CreatedAt string - UpdatedAt string -}{ - ID: "id", - SkuID: "sku_id", - Vendor: "vendor", - Model: "model", - Bytes: "bytes", - Count: "count", - CreatedAt: "created_at", - UpdatedAt: "updated_at", -} - -var ServerSkuMemoryTableColumns = struct { - ID string - SkuID string - Vendor string - Model string - Bytes string - Count string - CreatedAt string - UpdatedAt string -}{ - ID: "server_sku_memory.id", - SkuID: "server_sku_memory.sku_id", - Vendor: "server_sku_memory.vendor", - Model: "server_sku_memory.model", - Bytes: "server_sku_memory.bytes", - Count: "server_sku_memory.count", - CreatedAt: "server_sku_memory.created_at", - UpdatedAt: "server_sku_memory.updated_at", -} - -// Generated where - -var ServerSkuMemoryWhere = struct { - ID whereHelperstring - SkuID whereHelperstring - Vendor whereHelperstring - Model whereHelperstring - Bytes whereHelperint64 - Count whereHelperint64 - CreatedAt whereHelpernull_Time - UpdatedAt whereHelpernull_Time -}{ - ID: whereHelperstring{field: "\"server_sku_memory\".\"id\""}, - SkuID: whereHelperstring{field: "\"server_sku_memory\".\"sku_id\""}, - Vendor: whereHelperstring{field: "\"server_sku_memory\".\"vendor\""}, - Model: whereHelperstring{field: "\"server_sku_memory\".\"model\""}, - Bytes: whereHelperint64{field: "\"server_sku_memory\".\"bytes\""}, - Count: whereHelperint64{field: "\"server_sku_memory\".\"count\""}, - CreatedAt: whereHelpernull_Time{field: "\"server_sku_memory\".\"created_at\""}, - UpdatedAt: whereHelpernull_Time{field: "\"server_sku_memory\".\"updated_at\""}, -} - -// ServerSkuMemoryRels is where relationship names are stored. -var ServerSkuMemoryRels = struct { - Sku string -}{ - Sku: "Sku", -} - -// serverSkuMemoryR is where relationships are stored. -type serverSkuMemoryR struct { - Sku *ServerSku `boil:"Sku" json:"Sku" toml:"Sku" yaml:"Sku"` -} - -// NewStruct creates a new relationship struct -func (*serverSkuMemoryR) NewStruct() *serverSkuMemoryR { - return &serverSkuMemoryR{} -} - -func (r *serverSkuMemoryR) GetSku() *ServerSku { - if r == nil { - return nil - } - return r.Sku -} - -// serverSkuMemoryL is where Load methods for each relationship are stored. -type serverSkuMemoryL struct{} - -var ( - serverSkuMemoryAllColumns = []string{"id", "sku_id", "vendor", "model", "bytes", "count", "created_at", "updated_at"} - serverSkuMemoryColumnsWithoutDefault = []string{"sku_id", "vendor", "model", "bytes", "count"} - serverSkuMemoryColumnsWithDefault = []string{"id", "created_at", "updated_at"} - serverSkuMemoryPrimaryKeyColumns = []string{"id"} - serverSkuMemoryGeneratedColumns = []string{} -) - -type ( - // ServerSkuMemorySlice is an alias for a slice of pointers to ServerSkuMemory. - // This should almost always be used instead of []ServerSkuMemory. - ServerSkuMemorySlice []*ServerSkuMemory - // ServerSkuMemoryHook is the signature for custom ServerSkuMemory hook methods - ServerSkuMemoryHook func(context.Context, boil.ContextExecutor, *ServerSkuMemory) error - - serverSkuMemoryQuery struct { - *queries.Query - } -) - -// Cache for insert, update and upsert -var ( - serverSkuMemoryType = reflect.TypeOf(&ServerSkuMemory{}) - serverSkuMemoryMapping = queries.MakeStructMapping(serverSkuMemoryType) - serverSkuMemoryPrimaryKeyMapping, _ = queries.BindMapping(serverSkuMemoryType, serverSkuMemoryMapping, serverSkuMemoryPrimaryKeyColumns) - serverSkuMemoryInsertCacheMut sync.RWMutex - serverSkuMemoryInsertCache = make(map[string]insertCache) - serverSkuMemoryUpdateCacheMut sync.RWMutex - serverSkuMemoryUpdateCache = make(map[string]updateCache) - serverSkuMemoryUpsertCacheMut sync.RWMutex - serverSkuMemoryUpsertCache = make(map[string]insertCache) -) - -var ( - // Force time package dependency for automated UpdatedAt/CreatedAt. - _ = time.Second - // Force qmhelper dependency for where clause generation (which doesn't - // always happen) - _ = qmhelper.Where -) - -var serverSkuMemoryAfterSelectHooks []ServerSkuMemoryHook - -var serverSkuMemoryBeforeInsertHooks []ServerSkuMemoryHook -var serverSkuMemoryAfterInsertHooks []ServerSkuMemoryHook - -var serverSkuMemoryBeforeUpdateHooks []ServerSkuMemoryHook -var serverSkuMemoryAfterUpdateHooks []ServerSkuMemoryHook - -var serverSkuMemoryBeforeDeleteHooks []ServerSkuMemoryHook -var serverSkuMemoryAfterDeleteHooks []ServerSkuMemoryHook - -var serverSkuMemoryBeforeUpsertHooks []ServerSkuMemoryHook -var serverSkuMemoryAfterUpsertHooks []ServerSkuMemoryHook - -// doAfterSelectHooks executes all "after Select" hooks. -func (o *ServerSkuMemory) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuMemoryAfterSelectHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeInsertHooks executes all "before insert" hooks. -func (o *ServerSkuMemory) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuMemoryBeforeInsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterInsertHooks executes all "after Insert" hooks. -func (o *ServerSkuMemory) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuMemoryAfterInsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeUpdateHooks executes all "before Update" hooks. -func (o *ServerSkuMemory) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuMemoryBeforeUpdateHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterUpdateHooks executes all "after Update" hooks. -func (o *ServerSkuMemory) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuMemoryAfterUpdateHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeDeleteHooks executes all "before Delete" hooks. -func (o *ServerSkuMemory) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuMemoryBeforeDeleteHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterDeleteHooks executes all "after Delete" hooks. -func (o *ServerSkuMemory) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuMemoryAfterDeleteHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeUpsertHooks executes all "before Upsert" hooks. -func (o *ServerSkuMemory) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuMemoryBeforeUpsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterUpsertHooks executes all "after Upsert" hooks. -func (o *ServerSkuMemory) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuMemoryAfterUpsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// AddServerSkuMemoryHook registers your hook function for all future operations. -func AddServerSkuMemoryHook(hookPoint boil.HookPoint, serverSkuMemoryHook ServerSkuMemoryHook) { - switch hookPoint { - case boil.AfterSelectHook: - serverSkuMemoryAfterSelectHooks = append(serverSkuMemoryAfterSelectHooks, serverSkuMemoryHook) - case boil.BeforeInsertHook: - serverSkuMemoryBeforeInsertHooks = append(serverSkuMemoryBeforeInsertHooks, serverSkuMemoryHook) - case boil.AfterInsertHook: - serverSkuMemoryAfterInsertHooks = append(serverSkuMemoryAfterInsertHooks, serverSkuMemoryHook) - case boil.BeforeUpdateHook: - serverSkuMemoryBeforeUpdateHooks = append(serverSkuMemoryBeforeUpdateHooks, serverSkuMemoryHook) - case boil.AfterUpdateHook: - serverSkuMemoryAfterUpdateHooks = append(serverSkuMemoryAfterUpdateHooks, serverSkuMemoryHook) - case boil.BeforeDeleteHook: - serverSkuMemoryBeforeDeleteHooks = append(serverSkuMemoryBeforeDeleteHooks, serverSkuMemoryHook) - case boil.AfterDeleteHook: - serverSkuMemoryAfterDeleteHooks = append(serverSkuMemoryAfterDeleteHooks, serverSkuMemoryHook) - case boil.BeforeUpsertHook: - serverSkuMemoryBeforeUpsertHooks = append(serverSkuMemoryBeforeUpsertHooks, serverSkuMemoryHook) - case boil.AfterUpsertHook: - serverSkuMemoryAfterUpsertHooks = append(serverSkuMemoryAfterUpsertHooks, serverSkuMemoryHook) - } -} - -// One returns a single serverSkuMemory record from the query. -func (q serverSkuMemoryQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServerSkuMemory, error) { - o := &ServerSkuMemory{} - - queries.SetLimit(q.Query, 1) - - err := q.Bind(ctx, exec, o) - if err != nil { - if errors.Is(err, sql.ErrNoRows) { - return nil, sql.ErrNoRows - } - return nil, errors.Wrap(err, "models: failed to execute a one query for server_sku_memory") - } - - if err := o.doAfterSelectHooks(ctx, exec); err != nil { - return o, err - } - - return o, nil -} - -// All returns all ServerSkuMemory records from the query. -func (q serverSkuMemoryQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServerSkuMemorySlice, error) { - var o []*ServerSkuMemory - - err := q.Bind(ctx, exec, &o) - if err != nil { - return nil, errors.Wrap(err, "models: failed to assign all query results to ServerSkuMemory slice") - } - - if len(serverSkuMemoryAfterSelectHooks) != 0 { - for _, obj := range o { - if err := obj.doAfterSelectHooks(ctx, exec); err != nil { - return o, err - } - } - } - - return o, nil -} - -// Count returns the count of all ServerSkuMemory records in the query. -func (q serverSkuMemoryQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - var count int64 - - queries.SetSelect(q.Query, nil) - queries.SetCount(q.Query) - - err := q.Query.QueryRowContext(ctx, exec).Scan(&count) - if err != nil { - return 0, errors.Wrap(err, "models: failed to count server_sku_memory rows") - } - - return count, nil -} - -// Exists checks if the row exists in the table. -func (q serverSkuMemoryQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { - var count int64 - - queries.SetSelect(q.Query, nil) - queries.SetCount(q.Query) - queries.SetLimit(q.Query, 1) - - err := q.Query.QueryRowContext(ctx, exec).Scan(&count) - if err != nil { - return false, errors.Wrap(err, "models: failed to check if server_sku_memory exists") - } - - return count > 0, nil -} - -// Sku pointed to by the foreign key. -func (o *ServerSkuMemory) Sku(mods ...qm.QueryMod) serverSkuQuery { - queryMods := []qm.QueryMod{ - qm.Where("\"id\" = ?", o.SkuID), - } - - queryMods = append(queryMods, mods...) - - return ServerSkus(queryMods...) -} - -// LoadSku allows an eager lookup of values, cached into the -// loaded structs of the objects. This is for an N-1 relationship. -func (serverSkuMemoryL) LoadSku(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServerSkuMemory interface{}, mods queries.Applicator) error { - var slice []*ServerSkuMemory - var object *ServerSkuMemory - - if singular { - var ok bool - object, ok = maybeServerSkuMemory.(*ServerSkuMemory) - if !ok { - object = new(ServerSkuMemory) - ok = queries.SetFromEmbeddedStruct(&object, &maybeServerSkuMemory) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", object, maybeServerSkuMemory)) - } - } - } else { - s, ok := maybeServerSkuMemory.(*[]*ServerSkuMemory) - if ok { - slice = *s - } else { - ok = queries.SetFromEmbeddedStruct(&slice, maybeServerSkuMemory) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", slice, maybeServerSkuMemory)) - } - } - } - - args := make([]interface{}, 0, 1) - if singular { - if object.R == nil { - object.R = &serverSkuMemoryR{} - } - args = append(args, object.SkuID) - - } else { - Outer: - for _, obj := range slice { - if obj.R == nil { - obj.R = &serverSkuMemoryR{} - } - - for _, a := range args { - if a == obj.SkuID { - continue Outer - } - } - - args = append(args, obj.SkuID) - - } - } - - if len(args) == 0 { - return nil - } - - query := NewQuery( - qm.From(`server_sku`), - qm.WhereIn(`server_sku.id in ?`, args...), - ) - if mods != nil { - mods.Apply(query) - } - - results, err := query.QueryContext(ctx, e) - if err != nil { - return errors.Wrap(err, "failed to eager load ServerSku") - } - - var resultSlice []*ServerSku - if err = queries.Bind(results, &resultSlice); err != nil { - return errors.Wrap(err, "failed to bind eager loaded slice ServerSku") - } - - if err = results.Close(); err != nil { - return errors.Wrap(err, "failed to close results of eager load for server_sku") - } - if err = results.Err(); err != nil { - return errors.Wrap(err, "error occurred during iteration of eager loaded relations for server_sku") - } - - if len(serverSkuAfterSelectHooks) != 0 { - for _, obj := range resultSlice { - if err := obj.doAfterSelectHooks(ctx, e); err != nil { - return err - } - } - } - - if len(resultSlice) == 0 { - return nil - } - - if singular { - foreign := resultSlice[0] - object.R.Sku = foreign - if foreign.R == nil { - foreign.R = &serverSkuR{} - } - foreign.R.SkuServerSkuMemories = append(foreign.R.SkuServerSkuMemories, object) - return nil - } - - for _, local := range slice { - for _, foreign := range resultSlice { - if local.SkuID == foreign.ID { - local.R.Sku = foreign - if foreign.R == nil { - foreign.R = &serverSkuR{} - } - foreign.R.SkuServerSkuMemories = append(foreign.R.SkuServerSkuMemories, local) - break - } - } - } - - return nil -} - -// SetSku of the serverSkuMemory to the related item. -// Sets o.R.Sku to related. -// Adds o to related.R.SkuServerSkuMemories. -func (o *ServerSkuMemory) SetSku(ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServerSku) error { - var err error - if insert { - if err = related.Insert(ctx, exec, boil.Infer()); err != nil { - return errors.Wrap(err, "failed to insert into foreign table") - } - } - - updateQuery := fmt.Sprintf( - "UPDATE \"server_sku_memory\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, []string{"sku_id"}), - strmangle.WhereClause("\"", "\"", 2, serverSkuMemoryPrimaryKeyColumns), - ) - values := []interface{}{related.ID, o.ID} - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, updateQuery) - fmt.Fprintln(writer, values) - } - if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { - return errors.Wrap(err, "failed to update local table") - } - - o.SkuID = related.ID - if o.R == nil { - o.R = &serverSkuMemoryR{ - Sku: related, - } - } else { - o.R.Sku = related - } - - if related.R == nil { - related.R = &serverSkuR{ - SkuServerSkuMemories: ServerSkuMemorySlice{o}, - } - } else { - related.R.SkuServerSkuMemories = append(related.R.SkuServerSkuMemories, o) - } - - return nil -} - -// ServerSkuMemories retrieves all the records using an executor. -func ServerSkuMemories(mods ...qm.QueryMod) serverSkuMemoryQuery { - mods = append(mods, qm.From("\"server_sku_memory\"")) - q := NewQuery(mods...) - if len(queries.GetSelect(q)) == 0 { - queries.SetSelect(q, []string{"\"server_sku_memory\".*"}) - } - - return serverSkuMemoryQuery{q} -} - -// FindServerSkuMemory retrieves a single record by ID with an executor. -// If selectCols is empty Find will return all columns. -func FindServerSkuMemory(ctx context.Context, exec boil.ContextExecutor, iD string, selectCols ...string) (*ServerSkuMemory, error) { - serverSkuMemoryObj := &ServerSkuMemory{} - - sel := "*" - if len(selectCols) > 0 { - sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",") - } - query := fmt.Sprintf( - "select %s from \"server_sku_memory\" where \"id\"=$1", sel, - ) - - q := queries.Raw(query, iD) - - err := q.Bind(ctx, exec, serverSkuMemoryObj) - if err != nil { - if errors.Is(err, sql.ErrNoRows) { - return nil, sql.ErrNoRows - } - return nil, errors.Wrap(err, "models: unable to select from server_sku_memory") - } - - if err = serverSkuMemoryObj.doAfterSelectHooks(ctx, exec); err != nil { - return serverSkuMemoryObj, err - } - - return serverSkuMemoryObj, nil -} - -// Insert a single record using an executor. -// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts. -func (o *ServerSkuMemory) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error { - if o == nil { - return errors.New("models: no server_sku_memory provided for insertion") - } - - var err error - if !boil.TimestampsAreSkipped(ctx) { - currTime := time.Now().In(boil.GetLocation()) - - if queries.MustTime(o.CreatedAt).IsZero() { - queries.SetScanner(&o.CreatedAt, currTime) - } - if queries.MustTime(o.UpdatedAt).IsZero() { - queries.SetScanner(&o.UpdatedAt, currTime) - } - } - - if err := o.doBeforeInsertHooks(ctx, exec); err != nil { - return err - } - - nzDefaults := queries.NonZeroDefaultSet(serverSkuMemoryColumnsWithDefault, o) - - key := makeCacheKey(columns, nzDefaults) - serverSkuMemoryInsertCacheMut.RLock() - cache, cached := serverSkuMemoryInsertCache[key] - serverSkuMemoryInsertCacheMut.RUnlock() - - if !cached { - wl, returnColumns := columns.InsertColumnSet( - serverSkuMemoryAllColumns, - serverSkuMemoryColumnsWithDefault, - serverSkuMemoryColumnsWithoutDefault, - nzDefaults, - ) - - cache.valueMapping, err = queries.BindMapping(serverSkuMemoryType, serverSkuMemoryMapping, wl) - if err != nil { - return err - } - cache.retMapping, err = queries.BindMapping(serverSkuMemoryType, serverSkuMemoryMapping, returnColumns) - if err != nil { - return err - } - if len(wl) != 0 { - cache.query = fmt.Sprintf("INSERT INTO \"server_sku_memory\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1)) - } else { - cache.query = "INSERT INTO \"server_sku_memory\" %sDEFAULT VALUES%s" - } - - var queryOutput, queryReturning string - - if len(cache.retMapping) != 0 { - queryReturning = fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\"")) - } - - cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning) - } - - value := reflect.Indirect(reflect.ValueOf(o)) - vals := queries.ValuesFromMapping(value, cache.valueMapping) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, cache.query) - fmt.Fprintln(writer, vals) - } - - if len(cache.retMapping) != 0 { - err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...) - } else { - _, err = exec.ExecContext(ctx, cache.query, vals...) - } - - if err != nil { - return errors.Wrap(err, "models: unable to insert into server_sku_memory") - } - - if !cached { - serverSkuMemoryInsertCacheMut.Lock() - serverSkuMemoryInsertCache[key] = cache - serverSkuMemoryInsertCacheMut.Unlock() - } - - return o.doAfterInsertHooks(ctx, exec) -} - -// Update uses an executor to update the ServerSkuMemory. -// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. -// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records. -func (o *ServerSkuMemory) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) { - if !boil.TimestampsAreSkipped(ctx) { - currTime := time.Now().In(boil.GetLocation()) - - queries.SetScanner(&o.UpdatedAt, currTime) - } - - var err error - if err = o.doBeforeUpdateHooks(ctx, exec); err != nil { - return 0, err - } - key := makeCacheKey(columns, nil) - serverSkuMemoryUpdateCacheMut.RLock() - cache, cached := serverSkuMemoryUpdateCache[key] - serverSkuMemoryUpdateCacheMut.RUnlock() - - if !cached { - wl := columns.UpdateColumnSet( - serverSkuMemoryAllColumns, - serverSkuMemoryPrimaryKeyColumns, - ) - - if !columns.IsWhitelist() { - wl = strmangle.SetComplement(wl, []string{"created_at"}) - } - if len(wl) == 0 { - return 0, errors.New("models: unable to update server_sku_memory, could not build whitelist") - } - - cache.query = fmt.Sprintf("UPDATE \"server_sku_memory\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, wl), - strmangle.WhereClause("\"", "\"", len(wl)+1, serverSkuMemoryPrimaryKeyColumns), - ) - cache.valueMapping, err = queries.BindMapping(serverSkuMemoryType, serverSkuMemoryMapping, append(wl, serverSkuMemoryPrimaryKeyColumns...)) - if err != nil { - return 0, err - } - } - - values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, cache.query) - fmt.Fprintln(writer, values) - } - var result sql.Result - result, err = exec.ExecContext(ctx, cache.query, values...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to update server_sku_memory row") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by update for server_sku_memory") - } - - if !cached { - serverSkuMemoryUpdateCacheMut.Lock() - serverSkuMemoryUpdateCache[key] = cache - serverSkuMemoryUpdateCacheMut.Unlock() - } - - return rowsAff, o.doAfterUpdateHooks(ctx, exec) -} - -// UpdateAll updates all rows with the specified column values. -func (q serverSkuMemoryQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { - queries.SetUpdate(q.Query, cols) - - result, err := q.Query.ExecContext(ctx, exec) - if err != nil { - return 0, errors.Wrap(err, "models: unable to update all for server_sku_memory") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: unable to retrieve rows affected for server_sku_memory") - } - - return rowsAff, nil -} - -// UpdateAll updates all rows with the specified column values, using an executor. -func (o ServerSkuMemorySlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { - ln := int64(len(o)) - if ln == 0 { - return 0, nil - } - - if len(cols) == 0 { - return 0, errors.New("models: update all requires at least one column argument") - } - - colNames := make([]string, len(cols)) - args := make([]interface{}, len(cols)) - - i := 0 - for name, value := range cols { - colNames[i] = name - args[i] = value - i++ - } - - // Append all of the primary key values for each column - for _, obj := range o { - pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), serverSkuMemoryPrimaryKeyMapping) - args = append(args, pkeyArgs...) - } - - sql := fmt.Sprintf("UPDATE \"server_sku_memory\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, colNames), - strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), len(colNames)+1, serverSkuMemoryPrimaryKeyColumns, len(o))) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, args...) - } - result, err := exec.ExecContext(ctx, sql, args...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to update all in serverSkuMemory slice") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: unable to retrieve rows affected all in update all serverSkuMemory") - } - return rowsAff, nil -} - -// Delete deletes a single ServerSkuMemory record with an executor. -// Delete will match against the primary key column to find the record to delete. -func (o *ServerSkuMemory) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - if o == nil { - return 0, errors.New("models: no ServerSkuMemory provided for delete") - } - - if err := o.doBeforeDeleteHooks(ctx, exec); err != nil { - return 0, err - } - - args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), serverSkuMemoryPrimaryKeyMapping) - sql := "DELETE FROM \"server_sku_memory\" WHERE \"id\"=$1" - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, args...) - } - result, err := exec.ExecContext(ctx, sql, args...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to delete from server_sku_memory") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by delete for server_sku_memory") - } - - if err := o.doAfterDeleteHooks(ctx, exec); err != nil { - return 0, err - } - - return rowsAff, nil -} - -// DeleteAll deletes all matching rows. -func (q serverSkuMemoryQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - if q.Query == nil { - return 0, errors.New("models: no serverSkuMemoryQuery provided for delete all") - } - - queries.SetDelete(q.Query) - - result, err := q.Query.ExecContext(ctx, exec) - if err != nil { - return 0, errors.Wrap(err, "models: unable to delete all from server_sku_memory") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for server_sku_memory") - } - - return rowsAff, nil -} - -// DeleteAll deletes all rows in the slice, using an executor. -func (o ServerSkuMemorySlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - if len(o) == 0 { - return 0, nil - } - - if len(serverSkuMemoryBeforeDeleteHooks) != 0 { - for _, obj := range o { - if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil { - return 0, err - } - } - } - - var args []interface{} - for _, obj := range o { - pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), serverSkuMemoryPrimaryKeyMapping) - args = append(args, pkeyArgs...) - } - - sql := "DELETE FROM \"server_sku_memory\" WHERE " + - strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, serverSkuMemoryPrimaryKeyColumns, len(o)) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, args) - } - result, err := exec.ExecContext(ctx, sql, args...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to delete all from serverSkuMemory slice") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for server_sku_memory") - } - - if len(serverSkuMemoryAfterDeleteHooks) != 0 { - for _, obj := range o { - if err := obj.doAfterDeleteHooks(ctx, exec); err != nil { - return 0, err - } - } - } - - return rowsAff, nil -} - -// Reload refetches the object from the database -// using the primary keys with an executor. -func (o *ServerSkuMemory) Reload(ctx context.Context, exec boil.ContextExecutor) error { - ret, err := FindServerSkuMemory(ctx, exec, o.ID) - if err != nil { - return err - } - - *o = *ret - return nil -} - -// ReloadAll refetches every row with matching primary key column values -// and overwrites the original object slice with the newly updated slice. -func (o *ServerSkuMemorySlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error { - if o == nil || len(*o) == 0 { - return nil - } - - slice := ServerSkuMemorySlice{} - var args []interface{} - for _, obj := range *o { - pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), serverSkuMemoryPrimaryKeyMapping) - args = append(args, pkeyArgs...) - } - - sql := "SELECT \"server_sku_memory\".* FROM \"server_sku_memory\" WHERE " + - strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, serverSkuMemoryPrimaryKeyColumns, len(*o)) - - q := queries.Raw(sql, args...) - - err := q.Bind(ctx, exec, &slice) - if err != nil { - return errors.Wrap(err, "models: unable to reload all in ServerSkuMemorySlice") - } - - *o = slice - - return nil -} - -// ServerSkuMemoryExists checks if the ServerSkuMemory row exists. -func ServerSkuMemoryExists(ctx context.Context, exec boil.ContextExecutor, iD string) (bool, error) { - var exists bool - sql := "select exists(select 1 from \"server_sku_memory\" where \"id\"=$1 limit 1)" - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, iD) - } - row := exec.QueryRowContext(ctx, sql, iD) - - err := row.Scan(&exists) - if err != nil { - return false, errors.Wrap(err, "models: unable to check if server_sku_memory exists") - } - - return exists, nil -} - -// Exists checks if the ServerSkuMemory row exists. -func (o *ServerSkuMemory) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { - return ServerSkuMemoryExists(ctx, exec, o.ID) -} - -// Upsert attempts an insert using an executor, and does an update or ignore on conflict. -// See boil.Columns documentation for how to properly use updateColumns and insertColumns. -func (o *ServerSkuMemory) Upsert(ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error { - if o == nil { - return errors.New("models: no server_sku_memory provided for upsert") - } - if !boil.TimestampsAreSkipped(ctx) { - currTime := time.Now().In(boil.GetLocation()) - - if queries.MustTime(o.CreatedAt).IsZero() { - queries.SetScanner(&o.CreatedAt, currTime) - } - queries.SetScanner(&o.UpdatedAt, currTime) - } - - if err := o.doBeforeUpsertHooks(ctx, exec); err != nil { - return err - } - - nzDefaults := queries.NonZeroDefaultSet(serverSkuMemoryColumnsWithDefault, o) - - // Build cache key in-line uglily - mysql vs psql problems - buf := strmangle.GetBuffer() - if updateOnConflict { - buf.WriteByte('t') - } else { - buf.WriteByte('f') - } - buf.WriteByte('.') - for _, c := range conflictColumns { - buf.WriteString(c) - } - buf.WriteByte('.') - buf.WriteString(strconv.Itoa(updateColumns.Kind)) - for _, c := range updateColumns.Cols { - buf.WriteString(c) - } - buf.WriteByte('.') - buf.WriteString(strconv.Itoa(insertColumns.Kind)) - for _, c := range insertColumns.Cols { - buf.WriteString(c) - } - buf.WriteByte('.') - for _, c := range nzDefaults { - buf.WriteString(c) - } - key := buf.String() - strmangle.PutBuffer(buf) - - serverSkuMemoryUpsertCacheMut.RLock() - cache, cached := serverSkuMemoryUpsertCache[key] - serverSkuMemoryUpsertCacheMut.RUnlock() - - var err error - - if !cached { - insert, ret := insertColumns.InsertColumnSet( - serverSkuMemoryAllColumns, - serverSkuMemoryColumnsWithDefault, - serverSkuMemoryColumnsWithoutDefault, - nzDefaults, - ) - update := updateColumns.UpdateColumnSet( - serverSkuMemoryAllColumns, - serverSkuMemoryPrimaryKeyColumns, - ) - - if updateOnConflict && len(update) == 0 { - return errors.New("models: unable to upsert server_sku_memory, could not build update column list") - } - - conflict := conflictColumns - if len(conflict) == 0 { - conflict = make([]string, len(serverSkuMemoryPrimaryKeyColumns)) - copy(conflict, serverSkuMemoryPrimaryKeyColumns) - } - cache.query = buildUpsertQueryCockroachDB(dialect, "\"server_sku_memory\"", updateOnConflict, ret, update, conflict, insert) - - cache.valueMapping, err = queries.BindMapping(serverSkuMemoryType, serverSkuMemoryMapping, insert) - if err != nil { - return err - } - if len(ret) != 0 { - cache.retMapping, err = queries.BindMapping(serverSkuMemoryType, serverSkuMemoryMapping, ret) - if err != nil { - return err - } - } - } - - value := reflect.Indirect(reflect.ValueOf(o)) - vals := queries.ValuesFromMapping(value, cache.valueMapping) - var returns []interface{} - if len(cache.retMapping) != 0 { - returns = queries.PtrsFromMapping(value, cache.retMapping) - } - - if boil.DebugMode { - _, _ = fmt.Fprintln(boil.DebugWriter, cache.query) - _, _ = fmt.Fprintln(boil.DebugWriter, vals) - } - - if len(cache.retMapping) != 0 { - err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(returns...) - if err == sql.ErrNoRows { - err = nil // CockcorachDB doesn't return anything when there's no update - } - } else { - _, err = exec.ExecContext(ctx, cache.query, vals...) - } - if err != nil { - return errors.Wrap(err, "models: unable to upsert server_sku_memory") - } - - if !cached { - serverSkuMemoryUpsertCacheMut.Lock() - serverSkuMemoryUpsertCache[key] = cache - serverSkuMemoryUpsertCacheMut.Unlock() - } - - return o.doAfterUpsertHooks(ctx, exec) -} diff --git a/internal/models/server_sku_memory_test.go b/internal/models/server_sku_memory_test.go deleted file mode 100644 index d4751124..00000000 --- a/internal/models/server_sku_memory_test.go +++ /dev/null @@ -1,851 +0,0 @@ -// Code generated by SQLBoiler 4.15.0 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT. -// This file is meant to be re-generated in place and/or deleted at any time. - -package models - -import ( - "bytes" - "context" - "reflect" - "testing" - - "github.com/volatiletech/randomize" - "github.com/volatiletech/sqlboiler/v4/boil" - "github.com/volatiletech/sqlboiler/v4/queries" - "github.com/volatiletech/strmangle" -) - -func testServerSkuMemoriesUpsert(t *testing.T) { - t.Parallel() - - if len(serverSkuMemoryAllColumns) == len(serverSkuMemoryPrimaryKeyColumns) { - t.Skip("Skipping table with only primary key columns") - } - - seed := randomize.NewSeed() - var err error - // Attempt the INSERT side of an UPSERT - o := ServerSkuMemory{} - if err = randomize.Struct(seed, &o, serverSkuMemoryDBTypes, true); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Upsert(ctx, tx, false, nil, boil.Infer(), boil.Infer()); err != nil { - t.Errorf("Unable to upsert ServerSkuMemory: %s", err) - } - - count, err := ServerSkuMemories().Count(ctx, tx) - if err != nil { - t.Error(err) - } - if count != 1 { - t.Error("want one record, got:", count) - } - - // Attempt the UPDATE side of an UPSERT - if err = randomize.Struct(seed, &o, serverSkuMemoryDBTypes, false, serverSkuMemoryPrimaryKeyColumns...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - if err = o.Upsert(ctx, tx, true, nil, boil.Infer(), boil.Infer()); err != nil { - t.Errorf("Unable to upsert ServerSkuMemory: %s", err) - } - - count, err = ServerSkuMemories().Count(ctx, tx) - if err != nil { - t.Error(err) - } - if count != 1 { - t.Error("want one record, got:", count) - } -} - -var ( - // Relationships sometimes use the reflection helper queries.Equal/queries.Assign - // so force a package dependency in case they don't. - _ = queries.Equal -) - -func testServerSkuMemories(t *testing.T) { - t.Parallel() - - query := ServerSkuMemories() - - if query.Query == nil { - t.Error("expected a query, got nothing") - } -} - -func testServerSkuMemoriesDelete(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuMemory{} - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if rowsAff, err := o.Delete(ctx, tx); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only have deleted one row, but affected:", rowsAff) - } - - count, err := ServerSkuMemories().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 0 { - t.Error("want zero records, got:", count) - } -} - -func testServerSkuMemoriesQueryDeleteAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuMemory{} - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if rowsAff, err := ServerSkuMemories().DeleteAll(ctx, tx); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only have deleted one row, but affected:", rowsAff) - } - - count, err := ServerSkuMemories().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 0 { - t.Error("want zero records, got:", count) - } -} - -func testServerSkuMemoriesSliceDeleteAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuMemory{} - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice := ServerSkuMemorySlice{o} - - if rowsAff, err := slice.DeleteAll(ctx, tx); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only have deleted one row, but affected:", rowsAff) - } - - count, err := ServerSkuMemories().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 0 { - t.Error("want zero records, got:", count) - } -} - -func testServerSkuMemoriesExists(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuMemory{} - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - e, err := ServerSkuMemoryExists(ctx, tx, o.ID) - if err != nil { - t.Errorf("Unable to check if ServerSkuMemory exists: %s", err) - } - if !e { - t.Errorf("Expected ServerSkuMemoryExists to return true, but got false.") - } -} - -func testServerSkuMemoriesFind(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuMemory{} - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - serverSkuMemoryFound, err := FindServerSkuMemory(ctx, tx, o.ID) - if err != nil { - t.Error(err) - } - - if serverSkuMemoryFound == nil { - t.Error("want a record, got nil") - } -} - -func testServerSkuMemoriesBind(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuMemory{} - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if err = ServerSkuMemories().Bind(ctx, tx, o); err != nil { - t.Error(err) - } -} - -func testServerSkuMemoriesOne(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuMemory{} - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if x, err := ServerSkuMemories().One(ctx, tx); err != nil { - t.Error(err) - } else if x == nil { - t.Error("expected to get a non nil record") - } -} - -func testServerSkuMemoriesAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - serverSkuMemoryOne := &ServerSkuMemory{} - serverSkuMemoryTwo := &ServerSkuMemory{} - if err = randomize.Struct(seed, serverSkuMemoryOne, serverSkuMemoryDBTypes, false, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - if err = randomize.Struct(seed, serverSkuMemoryTwo, serverSkuMemoryDBTypes, false, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = serverSkuMemoryOne.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - if err = serverSkuMemoryTwo.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice, err := ServerSkuMemories().All(ctx, tx) - if err != nil { - t.Error(err) - } - - if len(slice) != 2 { - t.Error("want 2 records, got:", len(slice)) - } -} - -func testServerSkuMemoriesCount(t *testing.T) { - t.Parallel() - - var err error - seed := randomize.NewSeed() - serverSkuMemoryOne := &ServerSkuMemory{} - serverSkuMemoryTwo := &ServerSkuMemory{} - if err = randomize.Struct(seed, serverSkuMemoryOne, serverSkuMemoryDBTypes, false, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - if err = randomize.Struct(seed, serverSkuMemoryTwo, serverSkuMemoryDBTypes, false, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = serverSkuMemoryOne.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - if err = serverSkuMemoryTwo.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuMemories().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 2 { - t.Error("want 2 records, got:", count) - } -} - -func serverSkuMemoryBeforeInsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuMemory) error { - *o = ServerSkuMemory{} - return nil -} - -func serverSkuMemoryAfterInsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuMemory) error { - *o = ServerSkuMemory{} - return nil -} - -func serverSkuMemoryAfterSelectHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuMemory) error { - *o = ServerSkuMemory{} - return nil -} - -func serverSkuMemoryBeforeUpdateHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuMemory) error { - *o = ServerSkuMemory{} - return nil -} - -func serverSkuMemoryAfterUpdateHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuMemory) error { - *o = ServerSkuMemory{} - return nil -} - -func serverSkuMemoryBeforeDeleteHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuMemory) error { - *o = ServerSkuMemory{} - return nil -} - -func serverSkuMemoryAfterDeleteHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuMemory) error { - *o = ServerSkuMemory{} - return nil -} - -func serverSkuMemoryBeforeUpsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuMemory) error { - *o = ServerSkuMemory{} - return nil -} - -func serverSkuMemoryAfterUpsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuMemory) error { - *o = ServerSkuMemory{} - return nil -} - -func testServerSkuMemoriesHooks(t *testing.T) { - t.Parallel() - - var err error - - ctx := context.Background() - empty := &ServerSkuMemory{} - o := &ServerSkuMemory{} - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, false); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory object: %s", err) - } - - AddServerSkuMemoryHook(boil.BeforeInsertHook, serverSkuMemoryBeforeInsertHook) - if err = o.doBeforeInsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeInsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeInsertHook function to empty object, but got: %#v", o) - } - serverSkuMemoryBeforeInsertHooks = []ServerSkuMemoryHook{} - - AddServerSkuMemoryHook(boil.AfterInsertHook, serverSkuMemoryAfterInsertHook) - if err = o.doAfterInsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterInsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterInsertHook function to empty object, but got: %#v", o) - } - serverSkuMemoryAfterInsertHooks = []ServerSkuMemoryHook{} - - AddServerSkuMemoryHook(boil.AfterSelectHook, serverSkuMemoryAfterSelectHook) - if err = o.doAfterSelectHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterSelectHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterSelectHook function to empty object, but got: %#v", o) - } - serverSkuMemoryAfterSelectHooks = []ServerSkuMemoryHook{} - - AddServerSkuMemoryHook(boil.BeforeUpdateHook, serverSkuMemoryBeforeUpdateHook) - if err = o.doBeforeUpdateHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeUpdateHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeUpdateHook function to empty object, but got: %#v", o) - } - serverSkuMemoryBeforeUpdateHooks = []ServerSkuMemoryHook{} - - AddServerSkuMemoryHook(boil.AfterUpdateHook, serverSkuMemoryAfterUpdateHook) - if err = o.doAfterUpdateHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterUpdateHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterUpdateHook function to empty object, but got: %#v", o) - } - serverSkuMemoryAfterUpdateHooks = []ServerSkuMemoryHook{} - - AddServerSkuMemoryHook(boil.BeforeDeleteHook, serverSkuMemoryBeforeDeleteHook) - if err = o.doBeforeDeleteHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeDeleteHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeDeleteHook function to empty object, but got: %#v", o) - } - serverSkuMemoryBeforeDeleteHooks = []ServerSkuMemoryHook{} - - AddServerSkuMemoryHook(boil.AfterDeleteHook, serverSkuMemoryAfterDeleteHook) - if err = o.doAfterDeleteHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterDeleteHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterDeleteHook function to empty object, but got: %#v", o) - } - serverSkuMemoryAfterDeleteHooks = []ServerSkuMemoryHook{} - - AddServerSkuMemoryHook(boil.BeforeUpsertHook, serverSkuMemoryBeforeUpsertHook) - if err = o.doBeforeUpsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeUpsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeUpsertHook function to empty object, but got: %#v", o) - } - serverSkuMemoryBeforeUpsertHooks = []ServerSkuMemoryHook{} - - AddServerSkuMemoryHook(boil.AfterUpsertHook, serverSkuMemoryAfterUpsertHook) - if err = o.doAfterUpsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterUpsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterUpsertHook function to empty object, but got: %#v", o) - } - serverSkuMemoryAfterUpsertHooks = []ServerSkuMemoryHook{} -} - -func testServerSkuMemoriesInsert(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuMemory{} - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuMemories().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } -} - -func testServerSkuMemoriesInsertWhitelist(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuMemory{} - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Whitelist(serverSkuMemoryColumnsWithoutDefault...)); err != nil { - t.Error(err) - } - - count, err := ServerSkuMemories().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } -} - -func testServerSkuMemoryToOneServerSkuUsingSku(t *testing.T) { - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var local ServerSkuMemory - var foreign ServerSku - - seed := randomize.NewSeed() - if err := randomize.Struct(seed, &local, serverSkuMemoryDBTypes, false, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - if err := randomize.Struct(seed, &foreign, serverSkuDBTypes, false, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - if err := foreign.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - local.SkuID = foreign.ID - if err := local.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - check, err := local.Sku().One(ctx, tx) - if err != nil { - t.Fatal(err) - } - - if check.ID != foreign.ID { - t.Errorf("want: %v, got %v", foreign.ID, check.ID) - } - - ranAfterSelectHook := false - AddServerSkuHook(boil.AfterSelectHook, func(ctx context.Context, e boil.ContextExecutor, o *ServerSku) error { - ranAfterSelectHook = true - return nil - }) - - slice := ServerSkuMemorySlice{&local} - if err = local.L.LoadSku(ctx, tx, false, (*[]*ServerSkuMemory)(&slice), nil); err != nil { - t.Fatal(err) - } - if local.R.Sku == nil { - t.Error("struct should have been eager loaded") - } - - local.R.Sku = nil - if err = local.L.LoadSku(ctx, tx, true, &local, nil); err != nil { - t.Fatal(err) - } - if local.R.Sku == nil { - t.Error("struct should have been eager loaded") - } - - if !ranAfterSelectHook { - t.Error("failed to run AfterSelect hook for relationship") - } -} - -func testServerSkuMemoryToOneSetOpServerSkuUsingSku(t *testing.T) { - var err error - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var a ServerSkuMemory - var b, c ServerSku - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, &a, serverSkuMemoryDBTypes, false, strmangle.SetComplement(serverSkuMemoryPrimaryKeyColumns, serverSkuMemoryColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - if err = randomize.Struct(seed, &b, serverSkuDBTypes, false, strmangle.SetComplement(serverSkuPrimaryKeyColumns, serverSkuColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - if err = randomize.Struct(seed, &c, serverSkuDBTypes, false, strmangle.SetComplement(serverSkuPrimaryKeyColumns, serverSkuColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - - if err := a.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = b.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - for i, x := range []*ServerSku{&b, &c} { - err = a.SetSku(ctx, tx, i != 0, x) - if err != nil { - t.Fatal(err) - } - - if a.R.Sku != x { - t.Error("relationship struct not set to correct value") - } - - if x.R.SkuServerSkuMemories[0] != &a { - t.Error("failed to append to foreign relationship struct") - } - if a.SkuID != x.ID { - t.Error("foreign key was wrong value", a.SkuID) - } - - zero := reflect.Zero(reflect.TypeOf(a.SkuID)) - reflect.Indirect(reflect.ValueOf(&a.SkuID)).Set(zero) - - if err = a.Reload(ctx, tx); err != nil { - t.Fatal("failed to reload", err) - } - - if a.SkuID != x.ID { - t.Error("foreign key was wrong value", a.SkuID, x.ID) - } - } -} - -func testServerSkuMemoriesReload(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuMemory{} - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if err = o.Reload(ctx, tx); err != nil { - t.Error(err) - } -} - -func testServerSkuMemoriesReloadAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuMemory{} - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice := ServerSkuMemorySlice{o} - - if err = slice.ReloadAll(ctx, tx); err != nil { - t.Error(err) - } -} - -func testServerSkuMemoriesSelect(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuMemory{} - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice, err := ServerSkuMemories().All(ctx, tx) - if err != nil { - t.Error(err) - } - - if len(slice) != 1 { - t.Error("want one record, got:", len(slice)) - } -} - -var ( - serverSkuMemoryDBTypes = map[string]string{`ID`: `uuid`, `SkuID`: `uuid`, `Vendor`: `string`, `Model`: `string`, `Bytes`: `int8`, `Count`: `int8`, `CreatedAt`: `timestamptz`, `UpdatedAt`: `timestamptz`} - _ = bytes.MinRead -) - -func testServerSkuMemoriesUpdate(t *testing.T) { - t.Parallel() - - if 0 == len(serverSkuMemoryPrimaryKeyColumns) { - t.Skip("Skipping table with no primary key columns") - } - if len(serverSkuMemoryAllColumns) == len(serverSkuMemoryPrimaryKeyColumns) { - t.Skip("Skipping table with only primary key columns") - } - - seed := randomize.NewSeed() - var err error - o := &ServerSkuMemory{} - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuMemories().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } - - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true, serverSkuMemoryPrimaryKeyColumns...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - if rowsAff, err := o.Update(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only affect one row but affected", rowsAff) - } -} - -func testServerSkuMemoriesSliceUpdateAll(t *testing.T) { - t.Parallel() - - if len(serverSkuMemoryAllColumns) == len(serverSkuMemoryPrimaryKeyColumns) { - t.Skip("Skipping table with only primary key columns") - } - - seed := randomize.NewSeed() - var err error - o := &ServerSkuMemory{} - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuMemories().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } - - if err = randomize.Struct(seed, o, serverSkuMemoryDBTypes, true, serverSkuMemoryPrimaryKeyColumns...); err != nil { - t.Errorf("Unable to randomize ServerSkuMemory struct: %s", err) - } - - // Remove Primary keys and unique columns from what we plan to update - var fields []string - if strmangle.StringSliceMatch(serverSkuMemoryAllColumns, serverSkuMemoryPrimaryKeyColumns) { - fields = serverSkuMemoryAllColumns - } else { - fields = strmangle.SetComplement( - serverSkuMemoryAllColumns, - serverSkuMemoryPrimaryKeyColumns, - ) - } - - value := reflect.Indirect(reflect.ValueOf(o)) - typ := reflect.TypeOf(o).Elem() - n := typ.NumField() - - updateMap := M{} - for _, col := range fields { - for i := 0; i < n; i++ { - f := typ.Field(i) - if f.Tag.Get("boil") == col { - updateMap[col] = value.Field(i).Interface() - } - } - } - - slice := ServerSkuMemorySlice{o} - if rowsAff, err := slice.UpdateAll(ctx, tx, updateMap); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("wanted one record updated but got", rowsAff) - } -} diff --git a/internal/models/server_sku_nic.go b/internal/models/server_sku_nic.go deleted file mode 100644 index 1ab21f89..00000000 --- a/internal/models/server_sku_nic.go +++ /dev/null @@ -1,1157 +0,0 @@ -// Code generated by SQLBoiler 4.15.0 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT. -// This file is meant to be re-generated in place and/or deleted at any time. - -package models - -import ( - "context" - "database/sql" - "fmt" - "reflect" - "strconv" - "strings" - "sync" - "time" - - "github.com/friendsofgo/errors" - "github.com/volatiletech/null/v8" - "github.com/volatiletech/sqlboiler/v4/boil" - "github.com/volatiletech/sqlboiler/v4/queries" - "github.com/volatiletech/sqlboiler/v4/queries/qm" - "github.com/volatiletech/sqlboiler/v4/queries/qmhelper" - "github.com/volatiletech/strmangle" -) - -// ServerSkuNic is an object representing the database table. -type ServerSkuNic struct { - ID string `boil:"id" json:"id" toml:"id" yaml:"id"` - SkuID string `boil:"sku_id" json:"sku_id" toml:"sku_id" yaml:"sku_id"` - Vendor string `boil:"vendor" json:"vendor" toml:"vendor" yaml:"vendor"` - Model string `boil:"model" json:"model" toml:"model" yaml:"model"` - PortBandwidth int64 `boil:"port_bandwidth" json:"port_bandwidth" toml:"port_bandwidth" yaml:"port_bandwidth"` - PortCount int64 `boil:"port_count" json:"port_count" toml:"port_count" yaml:"port_count"` - Count int64 `boil:"count" json:"count" toml:"count" yaml:"count"` - CreatedAt null.Time `boil:"created_at" json:"created_at,omitempty" toml:"created_at" yaml:"created_at,omitempty"` - UpdatedAt null.Time `boil:"updated_at" json:"updated_at,omitempty" toml:"updated_at" yaml:"updated_at,omitempty"` - - R *serverSkuNicR `boil:"-" json:"-" toml:"-" yaml:"-"` - L serverSkuNicL `boil:"-" json:"-" toml:"-" yaml:"-"` -} - -var ServerSkuNicColumns = struct { - ID string - SkuID string - Vendor string - Model string - PortBandwidth string - PortCount string - Count string - CreatedAt string - UpdatedAt string -}{ - ID: "id", - SkuID: "sku_id", - Vendor: "vendor", - Model: "model", - PortBandwidth: "port_bandwidth", - PortCount: "port_count", - Count: "count", - CreatedAt: "created_at", - UpdatedAt: "updated_at", -} - -var ServerSkuNicTableColumns = struct { - ID string - SkuID string - Vendor string - Model string - PortBandwidth string - PortCount string - Count string - CreatedAt string - UpdatedAt string -}{ - ID: "server_sku_nic.id", - SkuID: "server_sku_nic.sku_id", - Vendor: "server_sku_nic.vendor", - Model: "server_sku_nic.model", - PortBandwidth: "server_sku_nic.port_bandwidth", - PortCount: "server_sku_nic.port_count", - Count: "server_sku_nic.count", - CreatedAt: "server_sku_nic.created_at", - UpdatedAt: "server_sku_nic.updated_at", -} - -// Generated where - -var ServerSkuNicWhere = struct { - ID whereHelperstring - SkuID whereHelperstring - Vendor whereHelperstring - Model whereHelperstring - PortBandwidth whereHelperint64 - PortCount whereHelperint64 - Count whereHelperint64 - CreatedAt whereHelpernull_Time - UpdatedAt whereHelpernull_Time -}{ - ID: whereHelperstring{field: "\"server_sku_nic\".\"id\""}, - SkuID: whereHelperstring{field: "\"server_sku_nic\".\"sku_id\""}, - Vendor: whereHelperstring{field: "\"server_sku_nic\".\"vendor\""}, - Model: whereHelperstring{field: "\"server_sku_nic\".\"model\""}, - PortBandwidth: whereHelperint64{field: "\"server_sku_nic\".\"port_bandwidth\""}, - PortCount: whereHelperint64{field: "\"server_sku_nic\".\"port_count\""}, - Count: whereHelperint64{field: "\"server_sku_nic\".\"count\""}, - CreatedAt: whereHelpernull_Time{field: "\"server_sku_nic\".\"created_at\""}, - UpdatedAt: whereHelpernull_Time{field: "\"server_sku_nic\".\"updated_at\""}, -} - -// ServerSkuNicRels is where relationship names are stored. -var ServerSkuNicRels = struct { - Sku string -}{ - Sku: "Sku", -} - -// serverSkuNicR is where relationships are stored. -type serverSkuNicR struct { - Sku *ServerSku `boil:"Sku" json:"Sku" toml:"Sku" yaml:"Sku"` -} - -// NewStruct creates a new relationship struct -func (*serverSkuNicR) NewStruct() *serverSkuNicR { - return &serverSkuNicR{} -} - -func (r *serverSkuNicR) GetSku() *ServerSku { - if r == nil { - return nil - } - return r.Sku -} - -// serverSkuNicL is where Load methods for each relationship are stored. -type serverSkuNicL struct{} - -var ( - serverSkuNicAllColumns = []string{"id", "sku_id", "vendor", "model", "port_bandwidth", "port_count", "count", "created_at", "updated_at"} - serverSkuNicColumnsWithoutDefault = []string{"sku_id", "vendor", "model", "port_bandwidth", "port_count", "count"} - serverSkuNicColumnsWithDefault = []string{"id", "created_at", "updated_at"} - serverSkuNicPrimaryKeyColumns = []string{"id"} - serverSkuNicGeneratedColumns = []string{} -) - -type ( - // ServerSkuNicSlice is an alias for a slice of pointers to ServerSkuNic. - // This should almost always be used instead of []ServerSkuNic. - ServerSkuNicSlice []*ServerSkuNic - // ServerSkuNicHook is the signature for custom ServerSkuNic hook methods - ServerSkuNicHook func(context.Context, boil.ContextExecutor, *ServerSkuNic) error - - serverSkuNicQuery struct { - *queries.Query - } -) - -// Cache for insert, update and upsert -var ( - serverSkuNicType = reflect.TypeOf(&ServerSkuNic{}) - serverSkuNicMapping = queries.MakeStructMapping(serverSkuNicType) - serverSkuNicPrimaryKeyMapping, _ = queries.BindMapping(serverSkuNicType, serverSkuNicMapping, serverSkuNicPrimaryKeyColumns) - serverSkuNicInsertCacheMut sync.RWMutex - serverSkuNicInsertCache = make(map[string]insertCache) - serverSkuNicUpdateCacheMut sync.RWMutex - serverSkuNicUpdateCache = make(map[string]updateCache) - serverSkuNicUpsertCacheMut sync.RWMutex - serverSkuNicUpsertCache = make(map[string]insertCache) -) - -var ( - // Force time package dependency for automated UpdatedAt/CreatedAt. - _ = time.Second - // Force qmhelper dependency for where clause generation (which doesn't - // always happen) - _ = qmhelper.Where -) - -var serverSkuNicAfterSelectHooks []ServerSkuNicHook - -var serverSkuNicBeforeInsertHooks []ServerSkuNicHook -var serverSkuNicAfterInsertHooks []ServerSkuNicHook - -var serverSkuNicBeforeUpdateHooks []ServerSkuNicHook -var serverSkuNicAfterUpdateHooks []ServerSkuNicHook - -var serverSkuNicBeforeDeleteHooks []ServerSkuNicHook -var serverSkuNicAfterDeleteHooks []ServerSkuNicHook - -var serverSkuNicBeforeUpsertHooks []ServerSkuNicHook -var serverSkuNicAfterUpsertHooks []ServerSkuNicHook - -// doAfterSelectHooks executes all "after Select" hooks. -func (o *ServerSkuNic) doAfterSelectHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuNicAfterSelectHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeInsertHooks executes all "before insert" hooks. -func (o *ServerSkuNic) doBeforeInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuNicBeforeInsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterInsertHooks executes all "after Insert" hooks. -func (o *ServerSkuNic) doAfterInsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuNicAfterInsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeUpdateHooks executes all "before Update" hooks. -func (o *ServerSkuNic) doBeforeUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuNicBeforeUpdateHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterUpdateHooks executes all "after Update" hooks. -func (o *ServerSkuNic) doAfterUpdateHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuNicAfterUpdateHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeDeleteHooks executes all "before Delete" hooks. -func (o *ServerSkuNic) doBeforeDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuNicBeforeDeleteHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterDeleteHooks executes all "after Delete" hooks. -func (o *ServerSkuNic) doAfterDeleteHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuNicAfterDeleteHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doBeforeUpsertHooks executes all "before Upsert" hooks. -func (o *ServerSkuNic) doBeforeUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuNicBeforeUpsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// doAfterUpsertHooks executes all "after Upsert" hooks. -func (o *ServerSkuNic) doAfterUpsertHooks(ctx context.Context, exec boil.ContextExecutor) (err error) { - if boil.HooksAreSkipped(ctx) { - return nil - } - - for _, hook := range serverSkuNicAfterUpsertHooks { - if err := hook(ctx, exec, o); err != nil { - return err - } - } - - return nil -} - -// AddServerSkuNicHook registers your hook function for all future operations. -func AddServerSkuNicHook(hookPoint boil.HookPoint, serverSkuNicHook ServerSkuNicHook) { - switch hookPoint { - case boil.AfterSelectHook: - serverSkuNicAfterSelectHooks = append(serverSkuNicAfterSelectHooks, serverSkuNicHook) - case boil.BeforeInsertHook: - serverSkuNicBeforeInsertHooks = append(serverSkuNicBeforeInsertHooks, serverSkuNicHook) - case boil.AfterInsertHook: - serverSkuNicAfterInsertHooks = append(serverSkuNicAfterInsertHooks, serverSkuNicHook) - case boil.BeforeUpdateHook: - serverSkuNicBeforeUpdateHooks = append(serverSkuNicBeforeUpdateHooks, serverSkuNicHook) - case boil.AfterUpdateHook: - serverSkuNicAfterUpdateHooks = append(serverSkuNicAfterUpdateHooks, serverSkuNicHook) - case boil.BeforeDeleteHook: - serverSkuNicBeforeDeleteHooks = append(serverSkuNicBeforeDeleteHooks, serverSkuNicHook) - case boil.AfterDeleteHook: - serverSkuNicAfterDeleteHooks = append(serverSkuNicAfterDeleteHooks, serverSkuNicHook) - case boil.BeforeUpsertHook: - serverSkuNicBeforeUpsertHooks = append(serverSkuNicBeforeUpsertHooks, serverSkuNicHook) - case boil.AfterUpsertHook: - serverSkuNicAfterUpsertHooks = append(serverSkuNicAfterUpsertHooks, serverSkuNicHook) - } -} - -// One returns a single serverSkuNic record from the query. -func (q serverSkuNicQuery) One(ctx context.Context, exec boil.ContextExecutor) (*ServerSkuNic, error) { - o := &ServerSkuNic{} - - queries.SetLimit(q.Query, 1) - - err := q.Bind(ctx, exec, o) - if err != nil { - if errors.Is(err, sql.ErrNoRows) { - return nil, sql.ErrNoRows - } - return nil, errors.Wrap(err, "models: failed to execute a one query for server_sku_nic") - } - - if err := o.doAfterSelectHooks(ctx, exec); err != nil { - return o, err - } - - return o, nil -} - -// All returns all ServerSkuNic records from the query. -func (q serverSkuNicQuery) All(ctx context.Context, exec boil.ContextExecutor) (ServerSkuNicSlice, error) { - var o []*ServerSkuNic - - err := q.Bind(ctx, exec, &o) - if err != nil { - return nil, errors.Wrap(err, "models: failed to assign all query results to ServerSkuNic slice") - } - - if len(serverSkuNicAfterSelectHooks) != 0 { - for _, obj := range o { - if err := obj.doAfterSelectHooks(ctx, exec); err != nil { - return o, err - } - } - } - - return o, nil -} - -// Count returns the count of all ServerSkuNic records in the query. -func (q serverSkuNicQuery) Count(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - var count int64 - - queries.SetSelect(q.Query, nil) - queries.SetCount(q.Query) - - err := q.Query.QueryRowContext(ctx, exec).Scan(&count) - if err != nil { - return 0, errors.Wrap(err, "models: failed to count server_sku_nic rows") - } - - return count, nil -} - -// Exists checks if the row exists in the table. -func (q serverSkuNicQuery) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { - var count int64 - - queries.SetSelect(q.Query, nil) - queries.SetCount(q.Query) - queries.SetLimit(q.Query, 1) - - err := q.Query.QueryRowContext(ctx, exec).Scan(&count) - if err != nil { - return false, errors.Wrap(err, "models: failed to check if server_sku_nic exists") - } - - return count > 0, nil -} - -// Sku pointed to by the foreign key. -func (o *ServerSkuNic) Sku(mods ...qm.QueryMod) serverSkuQuery { - queryMods := []qm.QueryMod{ - qm.Where("\"id\" = ?", o.SkuID), - } - - queryMods = append(queryMods, mods...) - - return ServerSkus(queryMods...) -} - -// LoadSku allows an eager lookup of values, cached into the -// loaded structs of the objects. This is for an N-1 relationship. -func (serverSkuNicL) LoadSku(ctx context.Context, e boil.ContextExecutor, singular bool, maybeServerSkuNic interface{}, mods queries.Applicator) error { - var slice []*ServerSkuNic - var object *ServerSkuNic - - if singular { - var ok bool - object, ok = maybeServerSkuNic.(*ServerSkuNic) - if !ok { - object = new(ServerSkuNic) - ok = queries.SetFromEmbeddedStruct(&object, &maybeServerSkuNic) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", object, maybeServerSkuNic)) - } - } - } else { - s, ok := maybeServerSkuNic.(*[]*ServerSkuNic) - if ok { - slice = *s - } else { - ok = queries.SetFromEmbeddedStruct(&slice, maybeServerSkuNic) - if !ok { - return errors.New(fmt.Sprintf("failed to set %T from embedded struct %T", slice, maybeServerSkuNic)) - } - } - } - - args := make([]interface{}, 0, 1) - if singular { - if object.R == nil { - object.R = &serverSkuNicR{} - } - args = append(args, object.SkuID) - - } else { - Outer: - for _, obj := range slice { - if obj.R == nil { - obj.R = &serverSkuNicR{} - } - - for _, a := range args { - if a == obj.SkuID { - continue Outer - } - } - - args = append(args, obj.SkuID) - - } - } - - if len(args) == 0 { - return nil - } - - query := NewQuery( - qm.From(`server_sku`), - qm.WhereIn(`server_sku.id in ?`, args...), - ) - if mods != nil { - mods.Apply(query) - } - - results, err := query.QueryContext(ctx, e) - if err != nil { - return errors.Wrap(err, "failed to eager load ServerSku") - } - - var resultSlice []*ServerSku - if err = queries.Bind(results, &resultSlice); err != nil { - return errors.Wrap(err, "failed to bind eager loaded slice ServerSku") - } - - if err = results.Close(); err != nil { - return errors.Wrap(err, "failed to close results of eager load for server_sku") - } - if err = results.Err(); err != nil { - return errors.Wrap(err, "error occurred during iteration of eager loaded relations for server_sku") - } - - if len(serverSkuAfterSelectHooks) != 0 { - for _, obj := range resultSlice { - if err := obj.doAfterSelectHooks(ctx, e); err != nil { - return err - } - } - } - - if len(resultSlice) == 0 { - return nil - } - - if singular { - foreign := resultSlice[0] - object.R.Sku = foreign - if foreign.R == nil { - foreign.R = &serverSkuR{} - } - foreign.R.SkuServerSkuNics = append(foreign.R.SkuServerSkuNics, object) - return nil - } - - for _, local := range slice { - for _, foreign := range resultSlice { - if local.SkuID == foreign.ID { - local.R.Sku = foreign - if foreign.R == nil { - foreign.R = &serverSkuR{} - } - foreign.R.SkuServerSkuNics = append(foreign.R.SkuServerSkuNics, local) - break - } - } - } - - return nil -} - -// SetSku of the serverSkuNic to the related item. -// Sets o.R.Sku to related. -// Adds o to related.R.SkuServerSkuNics. -func (o *ServerSkuNic) SetSku(ctx context.Context, exec boil.ContextExecutor, insert bool, related *ServerSku) error { - var err error - if insert { - if err = related.Insert(ctx, exec, boil.Infer()); err != nil { - return errors.Wrap(err, "failed to insert into foreign table") - } - } - - updateQuery := fmt.Sprintf( - "UPDATE \"server_sku_nic\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, []string{"sku_id"}), - strmangle.WhereClause("\"", "\"", 2, serverSkuNicPrimaryKeyColumns), - ) - values := []interface{}{related.ID, o.ID} - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, updateQuery) - fmt.Fprintln(writer, values) - } - if _, err = exec.ExecContext(ctx, updateQuery, values...); err != nil { - return errors.Wrap(err, "failed to update local table") - } - - o.SkuID = related.ID - if o.R == nil { - o.R = &serverSkuNicR{ - Sku: related, - } - } else { - o.R.Sku = related - } - - if related.R == nil { - related.R = &serverSkuR{ - SkuServerSkuNics: ServerSkuNicSlice{o}, - } - } else { - related.R.SkuServerSkuNics = append(related.R.SkuServerSkuNics, o) - } - - return nil -} - -// ServerSkuNics retrieves all the records using an executor. -func ServerSkuNics(mods ...qm.QueryMod) serverSkuNicQuery { - mods = append(mods, qm.From("\"server_sku_nic\"")) - q := NewQuery(mods...) - if len(queries.GetSelect(q)) == 0 { - queries.SetSelect(q, []string{"\"server_sku_nic\".*"}) - } - - return serverSkuNicQuery{q} -} - -// FindServerSkuNic retrieves a single record by ID with an executor. -// If selectCols is empty Find will return all columns. -func FindServerSkuNic(ctx context.Context, exec boil.ContextExecutor, iD string, selectCols ...string) (*ServerSkuNic, error) { - serverSkuNicObj := &ServerSkuNic{} - - sel := "*" - if len(selectCols) > 0 { - sel = strings.Join(strmangle.IdentQuoteSlice(dialect.LQ, dialect.RQ, selectCols), ",") - } - query := fmt.Sprintf( - "select %s from \"server_sku_nic\" where \"id\"=$1", sel, - ) - - q := queries.Raw(query, iD) - - err := q.Bind(ctx, exec, serverSkuNicObj) - if err != nil { - if errors.Is(err, sql.ErrNoRows) { - return nil, sql.ErrNoRows - } - return nil, errors.Wrap(err, "models: unable to select from server_sku_nic") - } - - if err = serverSkuNicObj.doAfterSelectHooks(ctx, exec); err != nil { - return serverSkuNicObj, err - } - - return serverSkuNicObj, nil -} - -// Insert a single record using an executor. -// See boil.Columns.InsertColumnSet documentation to understand column list inference for inserts. -func (o *ServerSkuNic) Insert(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) error { - if o == nil { - return errors.New("models: no server_sku_nic provided for insertion") - } - - var err error - if !boil.TimestampsAreSkipped(ctx) { - currTime := time.Now().In(boil.GetLocation()) - - if queries.MustTime(o.CreatedAt).IsZero() { - queries.SetScanner(&o.CreatedAt, currTime) - } - if queries.MustTime(o.UpdatedAt).IsZero() { - queries.SetScanner(&o.UpdatedAt, currTime) - } - } - - if err := o.doBeforeInsertHooks(ctx, exec); err != nil { - return err - } - - nzDefaults := queries.NonZeroDefaultSet(serverSkuNicColumnsWithDefault, o) - - key := makeCacheKey(columns, nzDefaults) - serverSkuNicInsertCacheMut.RLock() - cache, cached := serverSkuNicInsertCache[key] - serverSkuNicInsertCacheMut.RUnlock() - - if !cached { - wl, returnColumns := columns.InsertColumnSet( - serverSkuNicAllColumns, - serverSkuNicColumnsWithDefault, - serverSkuNicColumnsWithoutDefault, - nzDefaults, - ) - - cache.valueMapping, err = queries.BindMapping(serverSkuNicType, serverSkuNicMapping, wl) - if err != nil { - return err - } - cache.retMapping, err = queries.BindMapping(serverSkuNicType, serverSkuNicMapping, returnColumns) - if err != nil { - return err - } - if len(wl) != 0 { - cache.query = fmt.Sprintf("INSERT INTO \"server_sku_nic\" (\"%s\") %%sVALUES (%s)%%s", strings.Join(wl, "\",\""), strmangle.Placeholders(dialect.UseIndexPlaceholders, len(wl), 1, 1)) - } else { - cache.query = "INSERT INTO \"server_sku_nic\" %sDEFAULT VALUES%s" - } - - var queryOutput, queryReturning string - - if len(cache.retMapping) != 0 { - queryReturning = fmt.Sprintf(" RETURNING \"%s\"", strings.Join(returnColumns, "\",\"")) - } - - cache.query = fmt.Sprintf(cache.query, queryOutput, queryReturning) - } - - value := reflect.Indirect(reflect.ValueOf(o)) - vals := queries.ValuesFromMapping(value, cache.valueMapping) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, cache.query) - fmt.Fprintln(writer, vals) - } - - if len(cache.retMapping) != 0 { - err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(queries.PtrsFromMapping(value, cache.retMapping)...) - } else { - _, err = exec.ExecContext(ctx, cache.query, vals...) - } - - if err != nil { - return errors.Wrap(err, "models: unable to insert into server_sku_nic") - } - - if !cached { - serverSkuNicInsertCacheMut.Lock() - serverSkuNicInsertCache[key] = cache - serverSkuNicInsertCacheMut.Unlock() - } - - return o.doAfterInsertHooks(ctx, exec) -} - -// Update uses an executor to update the ServerSkuNic. -// See boil.Columns.UpdateColumnSet documentation to understand column list inference for updates. -// Update does not automatically update the record in case of default values. Use .Reload() to refresh the records. -func (o *ServerSkuNic) Update(ctx context.Context, exec boil.ContextExecutor, columns boil.Columns) (int64, error) { - if !boil.TimestampsAreSkipped(ctx) { - currTime := time.Now().In(boil.GetLocation()) - - queries.SetScanner(&o.UpdatedAt, currTime) - } - - var err error - if err = o.doBeforeUpdateHooks(ctx, exec); err != nil { - return 0, err - } - key := makeCacheKey(columns, nil) - serverSkuNicUpdateCacheMut.RLock() - cache, cached := serverSkuNicUpdateCache[key] - serverSkuNicUpdateCacheMut.RUnlock() - - if !cached { - wl := columns.UpdateColumnSet( - serverSkuNicAllColumns, - serverSkuNicPrimaryKeyColumns, - ) - - if !columns.IsWhitelist() { - wl = strmangle.SetComplement(wl, []string{"created_at"}) - } - if len(wl) == 0 { - return 0, errors.New("models: unable to update server_sku_nic, could not build whitelist") - } - - cache.query = fmt.Sprintf("UPDATE \"server_sku_nic\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, wl), - strmangle.WhereClause("\"", "\"", len(wl)+1, serverSkuNicPrimaryKeyColumns), - ) - cache.valueMapping, err = queries.BindMapping(serverSkuNicType, serverSkuNicMapping, append(wl, serverSkuNicPrimaryKeyColumns...)) - if err != nil { - return 0, err - } - } - - values := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), cache.valueMapping) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, cache.query) - fmt.Fprintln(writer, values) - } - var result sql.Result - result, err = exec.ExecContext(ctx, cache.query, values...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to update server_sku_nic row") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by update for server_sku_nic") - } - - if !cached { - serverSkuNicUpdateCacheMut.Lock() - serverSkuNicUpdateCache[key] = cache - serverSkuNicUpdateCacheMut.Unlock() - } - - return rowsAff, o.doAfterUpdateHooks(ctx, exec) -} - -// UpdateAll updates all rows with the specified column values. -func (q serverSkuNicQuery) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { - queries.SetUpdate(q.Query, cols) - - result, err := q.Query.ExecContext(ctx, exec) - if err != nil { - return 0, errors.Wrap(err, "models: unable to update all for server_sku_nic") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: unable to retrieve rows affected for server_sku_nic") - } - - return rowsAff, nil -} - -// UpdateAll updates all rows with the specified column values, using an executor. -func (o ServerSkuNicSlice) UpdateAll(ctx context.Context, exec boil.ContextExecutor, cols M) (int64, error) { - ln := int64(len(o)) - if ln == 0 { - return 0, nil - } - - if len(cols) == 0 { - return 0, errors.New("models: update all requires at least one column argument") - } - - colNames := make([]string, len(cols)) - args := make([]interface{}, len(cols)) - - i := 0 - for name, value := range cols { - colNames[i] = name - args[i] = value - i++ - } - - // Append all of the primary key values for each column - for _, obj := range o { - pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), serverSkuNicPrimaryKeyMapping) - args = append(args, pkeyArgs...) - } - - sql := fmt.Sprintf("UPDATE \"server_sku_nic\" SET %s WHERE %s", - strmangle.SetParamNames("\"", "\"", 1, colNames), - strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), len(colNames)+1, serverSkuNicPrimaryKeyColumns, len(o))) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, args...) - } - result, err := exec.ExecContext(ctx, sql, args...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to update all in serverSkuNic slice") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: unable to retrieve rows affected all in update all serverSkuNic") - } - return rowsAff, nil -} - -// Delete deletes a single ServerSkuNic record with an executor. -// Delete will match against the primary key column to find the record to delete. -func (o *ServerSkuNic) Delete(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - if o == nil { - return 0, errors.New("models: no ServerSkuNic provided for delete") - } - - if err := o.doBeforeDeleteHooks(ctx, exec); err != nil { - return 0, err - } - - args := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(o)), serverSkuNicPrimaryKeyMapping) - sql := "DELETE FROM \"server_sku_nic\" WHERE \"id\"=$1" - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, args...) - } - result, err := exec.ExecContext(ctx, sql, args...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to delete from server_sku_nic") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by delete for server_sku_nic") - } - - if err := o.doAfterDeleteHooks(ctx, exec); err != nil { - return 0, err - } - - return rowsAff, nil -} - -// DeleteAll deletes all matching rows. -func (q serverSkuNicQuery) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - if q.Query == nil { - return 0, errors.New("models: no serverSkuNicQuery provided for delete all") - } - - queries.SetDelete(q.Query) - - result, err := q.Query.ExecContext(ctx, exec) - if err != nil { - return 0, errors.Wrap(err, "models: unable to delete all from server_sku_nic") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for server_sku_nic") - } - - return rowsAff, nil -} - -// DeleteAll deletes all rows in the slice, using an executor. -func (o ServerSkuNicSlice) DeleteAll(ctx context.Context, exec boil.ContextExecutor) (int64, error) { - if len(o) == 0 { - return 0, nil - } - - if len(serverSkuNicBeforeDeleteHooks) != 0 { - for _, obj := range o { - if err := obj.doBeforeDeleteHooks(ctx, exec); err != nil { - return 0, err - } - } - } - - var args []interface{} - for _, obj := range o { - pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), serverSkuNicPrimaryKeyMapping) - args = append(args, pkeyArgs...) - } - - sql := "DELETE FROM \"server_sku_nic\" WHERE " + - strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, serverSkuNicPrimaryKeyColumns, len(o)) - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, args) - } - result, err := exec.ExecContext(ctx, sql, args...) - if err != nil { - return 0, errors.Wrap(err, "models: unable to delete all from serverSkuNic slice") - } - - rowsAff, err := result.RowsAffected() - if err != nil { - return 0, errors.Wrap(err, "models: failed to get rows affected by deleteall for server_sku_nic") - } - - if len(serverSkuNicAfterDeleteHooks) != 0 { - for _, obj := range o { - if err := obj.doAfterDeleteHooks(ctx, exec); err != nil { - return 0, err - } - } - } - - return rowsAff, nil -} - -// Reload refetches the object from the database -// using the primary keys with an executor. -func (o *ServerSkuNic) Reload(ctx context.Context, exec boil.ContextExecutor) error { - ret, err := FindServerSkuNic(ctx, exec, o.ID) - if err != nil { - return err - } - - *o = *ret - return nil -} - -// ReloadAll refetches every row with matching primary key column values -// and overwrites the original object slice with the newly updated slice. -func (o *ServerSkuNicSlice) ReloadAll(ctx context.Context, exec boil.ContextExecutor) error { - if o == nil || len(*o) == 0 { - return nil - } - - slice := ServerSkuNicSlice{} - var args []interface{} - for _, obj := range *o { - pkeyArgs := queries.ValuesFromMapping(reflect.Indirect(reflect.ValueOf(obj)), serverSkuNicPrimaryKeyMapping) - args = append(args, pkeyArgs...) - } - - sql := "SELECT \"server_sku_nic\".* FROM \"server_sku_nic\" WHERE " + - strmangle.WhereClauseRepeated(string(dialect.LQ), string(dialect.RQ), 1, serverSkuNicPrimaryKeyColumns, len(*o)) - - q := queries.Raw(sql, args...) - - err := q.Bind(ctx, exec, &slice) - if err != nil { - return errors.Wrap(err, "models: unable to reload all in ServerSkuNicSlice") - } - - *o = slice - - return nil -} - -// ServerSkuNicExists checks if the ServerSkuNic row exists. -func ServerSkuNicExists(ctx context.Context, exec boil.ContextExecutor, iD string) (bool, error) { - var exists bool - sql := "select exists(select 1 from \"server_sku_nic\" where \"id\"=$1 limit 1)" - - if boil.IsDebug(ctx) { - writer := boil.DebugWriterFrom(ctx) - fmt.Fprintln(writer, sql) - fmt.Fprintln(writer, iD) - } - row := exec.QueryRowContext(ctx, sql, iD) - - err := row.Scan(&exists) - if err != nil { - return false, errors.Wrap(err, "models: unable to check if server_sku_nic exists") - } - - return exists, nil -} - -// Exists checks if the ServerSkuNic row exists. -func (o *ServerSkuNic) Exists(ctx context.Context, exec boil.ContextExecutor) (bool, error) { - return ServerSkuNicExists(ctx, exec, o.ID) -} - -// Upsert attempts an insert using an executor, and does an update or ignore on conflict. -// See boil.Columns documentation for how to properly use updateColumns and insertColumns. -func (o *ServerSkuNic) Upsert(ctx context.Context, exec boil.ContextExecutor, updateOnConflict bool, conflictColumns []string, updateColumns, insertColumns boil.Columns) error { - if o == nil { - return errors.New("models: no server_sku_nic provided for upsert") - } - if !boil.TimestampsAreSkipped(ctx) { - currTime := time.Now().In(boil.GetLocation()) - - if queries.MustTime(o.CreatedAt).IsZero() { - queries.SetScanner(&o.CreatedAt, currTime) - } - queries.SetScanner(&o.UpdatedAt, currTime) - } - - if err := o.doBeforeUpsertHooks(ctx, exec); err != nil { - return err - } - - nzDefaults := queries.NonZeroDefaultSet(serverSkuNicColumnsWithDefault, o) - - // Build cache key in-line uglily - mysql vs psql problems - buf := strmangle.GetBuffer() - if updateOnConflict { - buf.WriteByte('t') - } else { - buf.WriteByte('f') - } - buf.WriteByte('.') - for _, c := range conflictColumns { - buf.WriteString(c) - } - buf.WriteByte('.') - buf.WriteString(strconv.Itoa(updateColumns.Kind)) - for _, c := range updateColumns.Cols { - buf.WriteString(c) - } - buf.WriteByte('.') - buf.WriteString(strconv.Itoa(insertColumns.Kind)) - for _, c := range insertColumns.Cols { - buf.WriteString(c) - } - buf.WriteByte('.') - for _, c := range nzDefaults { - buf.WriteString(c) - } - key := buf.String() - strmangle.PutBuffer(buf) - - serverSkuNicUpsertCacheMut.RLock() - cache, cached := serverSkuNicUpsertCache[key] - serverSkuNicUpsertCacheMut.RUnlock() - - var err error - - if !cached { - insert, ret := insertColumns.InsertColumnSet( - serverSkuNicAllColumns, - serverSkuNicColumnsWithDefault, - serverSkuNicColumnsWithoutDefault, - nzDefaults, - ) - update := updateColumns.UpdateColumnSet( - serverSkuNicAllColumns, - serverSkuNicPrimaryKeyColumns, - ) - - if updateOnConflict && len(update) == 0 { - return errors.New("models: unable to upsert server_sku_nic, could not build update column list") - } - - conflict := conflictColumns - if len(conflict) == 0 { - conflict = make([]string, len(serverSkuNicPrimaryKeyColumns)) - copy(conflict, serverSkuNicPrimaryKeyColumns) - } - cache.query = buildUpsertQueryCockroachDB(dialect, "\"server_sku_nic\"", updateOnConflict, ret, update, conflict, insert) - - cache.valueMapping, err = queries.BindMapping(serverSkuNicType, serverSkuNicMapping, insert) - if err != nil { - return err - } - if len(ret) != 0 { - cache.retMapping, err = queries.BindMapping(serverSkuNicType, serverSkuNicMapping, ret) - if err != nil { - return err - } - } - } - - value := reflect.Indirect(reflect.ValueOf(o)) - vals := queries.ValuesFromMapping(value, cache.valueMapping) - var returns []interface{} - if len(cache.retMapping) != 0 { - returns = queries.PtrsFromMapping(value, cache.retMapping) - } - - if boil.DebugMode { - _, _ = fmt.Fprintln(boil.DebugWriter, cache.query) - _, _ = fmt.Fprintln(boil.DebugWriter, vals) - } - - if len(cache.retMapping) != 0 { - err = exec.QueryRowContext(ctx, cache.query, vals...).Scan(returns...) - if err == sql.ErrNoRows { - err = nil // CockcorachDB doesn't return anything when there's no update - } - } else { - _, err = exec.ExecContext(ctx, cache.query, vals...) - } - if err != nil { - return errors.Wrap(err, "models: unable to upsert server_sku_nic") - } - - if !cached { - serverSkuNicUpsertCacheMut.Lock() - serverSkuNicUpsertCache[key] = cache - serverSkuNicUpsertCacheMut.Unlock() - } - - return o.doAfterUpsertHooks(ctx, exec) -} diff --git a/internal/models/server_sku_nic_test.go b/internal/models/server_sku_nic_test.go deleted file mode 100644 index 195a7d9c..00000000 --- a/internal/models/server_sku_nic_test.go +++ /dev/null @@ -1,851 +0,0 @@ -// Code generated by SQLBoiler 4.15.0 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT. -// This file is meant to be re-generated in place and/or deleted at any time. - -package models - -import ( - "bytes" - "context" - "reflect" - "testing" - - "github.com/volatiletech/randomize" - "github.com/volatiletech/sqlboiler/v4/boil" - "github.com/volatiletech/sqlboiler/v4/queries" - "github.com/volatiletech/strmangle" -) - -func testServerSkuNicsUpsert(t *testing.T) { - t.Parallel() - - if len(serverSkuNicAllColumns) == len(serverSkuNicPrimaryKeyColumns) { - t.Skip("Skipping table with only primary key columns") - } - - seed := randomize.NewSeed() - var err error - // Attempt the INSERT side of an UPSERT - o := ServerSkuNic{} - if err = randomize.Struct(seed, &o, serverSkuNicDBTypes, true); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Upsert(ctx, tx, false, nil, boil.Infer(), boil.Infer()); err != nil { - t.Errorf("Unable to upsert ServerSkuNic: %s", err) - } - - count, err := ServerSkuNics().Count(ctx, tx) - if err != nil { - t.Error(err) - } - if count != 1 { - t.Error("want one record, got:", count) - } - - // Attempt the UPDATE side of an UPSERT - if err = randomize.Struct(seed, &o, serverSkuNicDBTypes, false, serverSkuNicPrimaryKeyColumns...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - if err = o.Upsert(ctx, tx, true, nil, boil.Infer(), boil.Infer()); err != nil { - t.Errorf("Unable to upsert ServerSkuNic: %s", err) - } - - count, err = ServerSkuNics().Count(ctx, tx) - if err != nil { - t.Error(err) - } - if count != 1 { - t.Error("want one record, got:", count) - } -} - -var ( - // Relationships sometimes use the reflection helper queries.Equal/queries.Assign - // so force a package dependency in case they don't. - _ = queries.Equal -) - -func testServerSkuNics(t *testing.T) { - t.Parallel() - - query := ServerSkuNics() - - if query.Query == nil { - t.Error("expected a query, got nothing") - } -} - -func testServerSkuNicsDelete(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuNic{} - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if rowsAff, err := o.Delete(ctx, tx); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only have deleted one row, but affected:", rowsAff) - } - - count, err := ServerSkuNics().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 0 { - t.Error("want zero records, got:", count) - } -} - -func testServerSkuNicsQueryDeleteAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuNic{} - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if rowsAff, err := ServerSkuNics().DeleteAll(ctx, tx); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only have deleted one row, but affected:", rowsAff) - } - - count, err := ServerSkuNics().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 0 { - t.Error("want zero records, got:", count) - } -} - -func testServerSkuNicsSliceDeleteAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuNic{} - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice := ServerSkuNicSlice{o} - - if rowsAff, err := slice.DeleteAll(ctx, tx); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only have deleted one row, but affected:", rowsAff) - } - - count, err := ServerSkuNics().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 0 { - t.Error("want zero records, got:", count) - } -} - -func testServerSkuNicsExists(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuNic{} - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - e, err := ServerSkuNicExists(ctx, tx, o.ID) - if err != nil { - t.Errorf("Unable to check if ServerSkuNic exists: %s", err) - } - if !e { - t.Errorf("Expected ServerSkuNicExists to return true, but got false.") - } -} - -func testServerSkuNicsFind(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuNic{} - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - serverSkuNicFound, err := FindServerSkuNic(ctx, tx, o.ID) - if err != nil { - t.Error(err) - } - - if serverSkuNicFound == nil { - t.Error("want a record, got nil") - } -} - -func testServerSkuNicsBind(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuNic{} - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if err = ServerSkuNics().Bind(ctx, tx, o); err != nil { - t.Error(err) - } -} - -func testServerSkuNicsOne(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuNic{} - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if x, err := ServerSkuNics().One(ctx, tx); err != nil { - t.Error(err) - } else if x == nil { - t.Error("expected to get a non nil record") - } -} - -func testServerSkuNicsAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - serverSkuNicOne := &ServerSkuNic{} - serverSkuNicTwo := &ServerSkuNic{} - if err = randomize.Struct(seed, serverSkuNicOne, serverSkuNicDBTypes, false, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - if err = randomize.Struct(seed, serverSkuNicTwo, serverSkuNicDBTypes, false, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = serverSkuNicOne.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - if err = serverSkuNicTwo.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice, err := ServerSkuNics().All(ctx, tx) - if err != nil { - t.Error(err) - } - - if len(slice) != 2 { - t.Error("want 2 records, got:", len(slice)) - } -} - -func testServerSkuNicsCount(t *testing.T) { - t.Parallel() - - var err error - seed := randomize.NewSeed() - serverSkuNicOne := &ServerSkuNic{} - serverSkuNicTwo := &ServerSkuNic{} - if err = randomize.Struct(seed, serverSkuNicOne, serverSkuNicDBTypes, false, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - if err = randomize.Struct(seed, serverSkuNicTwo, serverSkuNicDBTypes, false, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = serverSkuNicOne.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - if err = serverSkuNicTwo.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuNics().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 2 { - t.Error("want 2 records, got:", count) - } -} - -func serverSkuNicBeforeInsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuNic) error { - *o = ServerSkuNic{} - return nil -} - -func serverSkuNicAfterInsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuNic) error { - *o = ServerSkuNic{} - return nil -} - -func serverSkuNicAfterSelectHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuNic) error { - *o = ServerSkuNic{} - return nil -} - -func serverSkuNicBeforeUpdateHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuNic) error { - *o = ServerSkuNic{} - return nil -} - -func serverSkuNicAfterUpdateHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuNic) error { - *o = ServerSkuNic{} - return nil -} - -func serverSkuNicBeforeDeleteHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuNic) error { - *o = ServerSkuNic{} - return nil -} - -func serverSkuNicAfterDeleteHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuNic) error { - *o = ServerSkuNic{} - return nil -} - -func serverSkuNicBeforeUpsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuNic) error { - *o = ServerSkuNic{} - return nil -} - -func serverSkuNicAfterUpsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSkuNic) error { - *o = ServerSkuNic{} - return nil -} - -func testServerSkuNicsHooks(t *testing.T) { - t.Parallel() - - var err error - - ctx := context.Background() - empty := &ServerSkuNic{} - o := &ServerSkuNic{} - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, false); err != nil { - t.Errorf("Unable to randomize ServerSkuNic object: %s", err) - } - - AddServerSkuNicHook(boil.BeforeInsertHook, serverSkuNicBeforeInsertHook) - if err = o.doBeforeInsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeInsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeInsertHook function to empty object, but got: %#v", o) - } - serverSkuNicBeforeInsertHooks = []ServerSkuNicHook{} - - AddServerSkuNicHook(boil.AfterInsertHook, serverSkuNicAfterInsertHook) - if err = o.doAfterInsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterInsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterInsertHook function to empty object, but got: %#v", o) - } - serverSkuNicAfterInsertHooks = []ServerSkuNicHook{} - - AddServerSkuNicHook(boil.AfterSelectHook, serverSkuNicAfterSelectHook) - if err = o.doAfterSelectHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterSelectHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterSelectHook function to empty object, but got: %#v", o) - } - serverSkuNicAfterSelectHooks = []ServerSkuNicHook{} - - AddServerSkuNicHook(boil.BeforeUpdateHook, serverSkuNicBeforeUpdateHook) - if err = o.doBeforeUpdateHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeUpdateHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeUpdateHook function to empty object, but got: %#v", o) - } - serverSkuNicBeforeUpdateHooks = []ServerSkuNicHook{} - - AddServerSkuNicHook(boil.AfterUpdateHook, serverSkuNicAfterUpdateHook) - if err = o.doAfterUpdateHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterUpdateHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterUpdateHook function to empty object, but got: %#v", o) - } - serverSkuNicAfterUpdateHooks = []ServerSkuNicHook{} - - AddServerSkuNicHook(boil.BeforeDeleteHook, serverSkuNicBeforeDeleteHook) - if err = o.doBeforeDeleteHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeDeleteHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeDeleteHook function to empty object, but got: %#v", o) - } - serverSkuNicBeforeDeleteHooks = []ServerSkuNicHook{} - - AddServerSkuNicHook(boil.AfterDeleteHook, serverSkuNicAfterDeleteHook) - if err = o.doAfterDeleteHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterDeleteHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterDeleteHook function to empty object, but got: %#v", o) - } - serverSkuNicAfterDeleteHooks = []ServerSkuNicHook{} - - AddServerSkuNicHook(boil.BeforeUpsertHook, serverSkuNicBeforeUpsertHook) - if err = o.doBeforeUpsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeUpsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeUpsertHook function to empty object, but got: %#v", o) - } - serverSkuNicBeforeUpsertHooks = []ServerSkuNicHook{} - - AddServerSkuNicHook(boil.AfterUpsertHook, serverSkuNicAfterUpsertHook) - if err = o.doAfterUpsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterUpsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterUpsertHook function to empty object, but got: %#v", o) - } - serverSkuNicAfterUpsertHooks = []ServerSkuNicHook{} -} - -func testServerSkuNicsInsert(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuNic{} - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuNics().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } -} - -func testServerSkuNicsInsertWhitelist(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuNic{} - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Whitelist(serverSkuNicColumnsWithoutDefault...)); err != nil { - t.Error(err) - } - - count, err := ServerSkuNics().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } -} - -func testServerSkuNicToOneServerSkuUsingSku(t *testing.T) { - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var local ServerSkuNic - var foreign ServerSku - - seed := randomize.NewSeed() - if err := randomize.Struct(seed, &local, serverSkuNicDBTypes, false, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - if err := randomize.Struct(seed, &foreign, serverSkuDBTypes, false, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - if err := foreign.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - local.SkuID = foreign.ID - if err := local.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - check, err := local.Sku().One(ctx, tx) - if err != nil { - t.Fatal(err) - } - - if check.ID != foreign.ID { - t.Errorf("want: %v, got %v", foreign.ID, check.ID) - } - - ranAfterSelectHook := false - AddServerSkuHook(boil.AfterSelectHook, func(ctx context.Context, e boil.ContextExecutor, o *ServerSku) error { - ranAfterSelectHook = true - return nil - }) - - slice := ServerSkuNicSlice{&local} - if err = local.L.LoadSku(ctx, tx, false, (*[]*ServerSkuNic)(&slice), nil); err != nil { - t.Fatal(err) - } - if local.R.Sku == nil { - t.Error("struct should have been eager loaded") - } - - local.R.Sku = nil - if err = local.L.LoadSku(ctx, tx, true, &local, nil); err != nil { - t.Fatal(err) - } - if local.R.Sku == nil { - t.Error("struct should have been eager loaded") - } - - if !ranAfterSelectHook { - t.Error("failed to run AfterSelect hook for relationship") - } -} - -func testServerSkuNicToOneSetOpServerSkuUsingSku(t *testing.T) { - var err error - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var a ServerSkuNic - var b, c ServerSku - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, &a, serverSkuNicDBTypes, false, strmangle.SetComplement(serverSkuNicPrimaryKeyColumns, serverSkuNicColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - if err = randomize.Struct(seed, &b, serverSkuDBTypes, false, strmangle.SetComplement(serverSkuPrimaryKeyColumns, serverSkuColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - if err = randomize.Struct(seed, &c, serverSkuDBTypes, false, strmangle.SetComplement(serverSkuPrimaryKeyColumns, serverSkuColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - - if err := a.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = b.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - for i, x := range []*ServerSku{&b, &c} { - err = a.SetSku(ctx, tx, i != 0, x) - if err != nil { - t.Fatal(err) - } - - if a.R.Sku != x { - t.Error("relationship struct not set to correct value") - } - - if x.R.SkuServerSkuNics[0] != &a { - t.Error("failed to append to foreign relationship struct") - } - if a.SkuID != x.ID { - t.Error("foreign key was wrong value", a.SkuID) - } - - zero := reflect.Zero(reflect.TypeOf(a.SkuID)) - reflect.Indirect(reflect.ValueOf(&a.SkuID)).Set(zero) - - if err = a.Reload(ctx, tx); err != nil { - t.Fatal("failed to reload", err) - } - - if a.SkuID != x.ID { - t.Error("foreign key was wrong value", a.SkuID, x.ID) - } - } -} - -func testServerSkuNicsReload(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuNic{} - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if err = o.Reload(ctx, tx); err != nil { - t.Error(err) - } -} - -func testServerSkuNicsReloadAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuNic{} - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice := ServerSkuNicSlice{o} - - if err = slice.ReloadAll(ctx, tx); err != nil { - t.Error(err) - } -} - -func testServerSkuNicsSelect(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSkuNic{} - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice, err := ServerSkuNics().All(ctx, tx) - if err != nil { - t.Error(err) - } - - if len(slice) != 1 { - t.Error("want one record, got:", len(slice)) - } -} - -var ( - serverSkuNicDBTypes = map[string]string{`ID`: `uuid`, `SkuID`: `uuid`, `Vendor`: `string`, `Model`: `string`, `PortBandwidth`: `int8`, `PortCount`: `int8`, `Count`: `int8`, `CreatedAt`: `timestamptz`, `UpdatedAt`: `timestamptz`} - _ = bytes.MinRead -) - -func testServerSkuNicsUpdate(t *testing.T) { - t.Parallel() - - if 0 == len(serverSkuNicPrimaryKeyColumns) { - t.Skip("Skipping table with no primary key columns") - } - if len(serverSkuNicAllColumns) == len(serverSkuNicPrimaryKeyColumns) { - t.Skip("Skipping table with only primary key columns") - } - - seed := randomize.NewSeed() - var err error - o := &ServerSkuNic{} - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuNics().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } - - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true, serverSkuNicPrimaryKeyColumns...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - if rowsAff, err := o.Update(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only affect one row but affected", rowsAff) - } -} - -func testServerSkuNicsSliceUpdateAll(t *testing.T) { - t.Parallel() - - if len(serverSkuNicAllColumns) == len(serverSkuNicPrimaryKeyColumns) { - t.Skip("Skipping table with only primary key columns") - } - - seed := randomize.NewSeed() - var err error - o := &ServerSkuNic{} - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true, serverSkuNicColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkuNics().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } - - if err = randomize.Struct(seed, o, serverSkuNicDBTypes, true, serverSkuNicPrimaryKeyColumns...); err != nil { - t.Errorf("Unable to randomize ServerSkuNic struct: %s", err) - } - - // Remove Primary keys and unique columns from what we plan to update - var fields []string - if strmangle.StringSliceMatch(serverSkuNicAllColumns, serverSkuNicPrimaryKeyColumns) { - fields = serverSkuNicAllColumns - } else { - fields = strmangle.SetComplement( - serverSkuNicAllColumns, - serverSkuNicPrimaryKeyColumns, - ) - } - - value := reflect.Indirect(reflect.ValueOf(o)) - typ := reflect.TypeOf(o).Elem() - n := typ.NumField() - - updateMap := M{} - for _, col := range fields { - for i := 0; i < n; i++ { - f := typ.Field(i) - if f.Tag.Get("boil") == col { - updateMap[col] = value.Field(i).Interface() - } - } - } - - slice := ServerSkuNicSlice{o} - if rowsAff, err := slice.UpdateAll(ctx, tx, updateMap); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("wanted one record updated but got", rowsAff) - } -} diff --git a/internal/models/server_sku_test.go b/internal/models/server_sku_test.go deleted file mode 100644 index 1266c12e..00000000 --- a/internal/models/server_sku_test.go +++ /dev/null @@ -1,1345 +0,0 @@ -// Code generated by SQLBoiler 4.15.0 (https://github.com/volatiletech/sqlboiler). DO NOT EDIT. -// This file is meant to be re-generated in place and/or deleted at any time. - -package models - -import ( - "bytes" - "context" - "reflect" - "testing" - - "github.com/volatiletech/randomize" - "github.com/volatiletech/sqlboiler/v4/boil" - "github.com/volatiletech/sqlboiler/v4/queries" - "github.com/volatiletech/strmangle" -) - -func testServerSkusUpsert(t *testing.T) { - t.Parallel() - - if len(serverSkuAllColumns) == len(serverSkuPrimaryKeyColumns) { - t.Skip("Skipping table with only primary key columns") - } - - seed := randomize.NewSeed() - var err error - // Attempt the INSERT side of an UPSERT - o := ServerSku{} - if err = randomize.Struct(seed, &o, serverSkuDBTypes, true); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Upsert(ctx, tx, false, nil, boil.Infer(), boil.Infer()); err != nil { - t.Errorf("Unable to upsert ServerSku: %s", err) - } - - count, err := ServerSkus().Count(ctx, tx) - if err != nil { - t.Error(err) - } - if count != 1 { - t.Error("want one record, got:", count) - } - - // Attempt the UPDATE side of an UPSERT - if err = randomize.Struct(seed, &o, serverSkuDBTypes, false, serverSkuPrimaryKeyColumns...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - if err = o.Upsert(ctx, tx, true, nil, boil.Infer(), boil.Infer()); err != nil { - t.Errorf("Unable to upsert ServerSku: %s", err) - } - - count, err = ServerSkus().Count(ctx, tx) - if err != nil { - t.Error(err) - } - if count != 1 { - t.Error("want one record, got:", count) - } -} - -var ( - // Relationships sometimes use the reflection helper queries.Equal/queries.Assign - // so force a package dependency in case they don't. - _ = queries.Equal -) - -func testServerSkus(t *testing.T) { - t.Parallel() - - query := ServerSkus() - - if query.Query == nil { - t.Error("expected a query, got nothing") - } -} - -func testServerSkusDelete(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSku{} - if err = randomize.Struct(seed, o, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if rowsAff, err := o.Delete(ctx, tx); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only have deleted one row, but affected:", rowsAff) - } - - count, err := ServerSkus().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 0 { - t.Error("want zero records, got:", count) - } -} - -func testServerSkusQueryDeleteAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSku{} - if err = randomize.Struct(seed, o, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if rowsAff, err := ServerSkus().DeleteAll(ctx, tx); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only have deleted one row, but affected:", rowsAff) - } - - count, err := ServerSkus().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 0 { - t.Error("want zero records, got:", count) - } -} - -func testServerSkusSliceDeleteAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSku{} - if err = randomize.Struct(seed, o, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice := ServerSkuSlice{o} - - if rowsAff, err := slice.DeleteAll(ctx, tx); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only have deleted one row, but affected:", rowsAff) - } - - count, err := ServerSkus().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 0 { - t.Error("want zero records, got:", count) - } -} - -func testServerSkusExists(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSku{} - if err = randomize.Struct(seed, o, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - e, err := ServerSkuExists(ctx, tx, o.ID) - if err != nil { - t.Errorf("Unable to check if ServerSku exists: %s", err) - } - if !e { - t.Errorf("Expected ServerSkuExists to return true, but got false.") - } -} - -func testServerSkusFind(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSku{} - if err = randomize.Struct(seed, o, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - serverSkuFound, err := FindServerSku(ctx, tx, o.ID) - if err != nil { - t.Error(err) - } - - if serverSkuFound == nil { - t.Error("want a record, got nil") - } -} - -func testServerSkusBind(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSku{} - if err = randomize.Struct(seed, o, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if err = ServerSkus().Bind(ctx, tx, o); err != nil { - t.Error(err) - } -} - -func testServerSkusOne(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSku{} - if err = randomize.Struct(seed, o, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if x, err := ServerSkus().One(ctx, tx); err != nil { - t.Error(err) - } else if x == nil { - t.Error("expected to get a non nil record") - } -} - -func testServerSkusAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - serverSkuOne := &ServerSku{} - serverSkuTwo := &ServerSku{} - if err = randomize.Struct(seed, serverSkuOne, serverSkuDBTypes, false, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - if err = randomize.Struct(seed, serverSkuTwo, serverSkuDBTypes, false, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = serverSkuOne.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - if err = serverSkuTwo.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice, err := ServerSkus().All(ctx, tx) - if err != nil { - t.Error(err) - } - - if len(slice) != 2 { - t.Error("want 2 records, got:", len(slice)) - } -} - -func testServerSkusCount(t *testing.T) { - t.Parallel() - - var err error - seed := randomize.NewSeed() - serverSkuOne := &ServerSku{} - serverSkuTwo := &ServerSku{} - if err = randomize.Struct(seed, serverSkuOne, serverSkuDBTypes, false, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - if err = randomize.Struct(seed, serverSkuTwo, serverSkuDBTypes, false, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = serverSkuOne.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - if err = serverSkuTwo.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkus().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 2 { - t.Error("want 2 records, got:", count) - } -} - -func serverSkuBeforeInsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSku) error { - *o = ServerSku{} - return nil -} - -func serverSkuAfterInsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSku) error { - *o = ServerSku{} - return nil -} - -func serverSkuAfterSelectHook(ctx context.Context, e boil.ContextExecutor, o *ServerSku) error { - *o = ServerSku{} - return nil -} - -func serverSkuBeforeUpdateHook(ctx context.Context, e boil.ContextExecutor, o *ServerSku) error { - *o = ServerSku{} - return nil -} - -func serverSkuAfterUpdateHook(ctx context.Context, e boil.ContextExecutor, o *ServerSku) error { - *o = ServerSku{} - return nil -} - -func serverSkuBeforeDeleteHook(ctx context.Context, e boil.ContextExecutor, o *ServerSku) error { - *o = ServerSku{} - return nil -} - -func serverSkuAfterDeleteHook(ctx context.Context, e boil.ContextExecutor, o *ServerSku) error { - *o = ServerSku{} - return nil -} - -func serverSkuBeforeUpsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSku) error { - *o = ServerSku{} - return nil -} - -func serverSkuAfterUpsertHook(ctx context.Context, e boil.ContextExecutor, o *ServerSku) error { - *o = ServerSku{} - return nil -} - -func testServerSkusHooks(t *testing.T) { - t.Parallel() - - var err error - - ctx := context.Background() - empty := &ServerSku{} - o := &ServerSku{} - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, o, serverSkuDBTypes, false); err != nil { - t.Errorf("Unable to randomize ServerSku object: %s", err) - } - - AddServerSkuHook(boil.BeforeInsertHook, serverSkuBeforeInsertHook) - if err = o.doBeforeInsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeInsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeInsertHook function to empty object, but got: %#v", o) - } - serverSkuBeforeInsertHooks = []ServerSkuHook{} - - AddServerSkuHook(boil.AfterInsertHook, serverSkuAfterInsertHook) - if err = o.doAfterInsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterInsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterInsertHook function to empty object, but got: %#v", o) - } - serverSkuAfterInsertHooks = []ServerSkuHook{} - - AddServerSkuHook(boil.AfterSelectHook, serverSkuAfterSelectHook) - if err = o.doAfterSelectHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterSelectHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterSelectHook function to empty object, but got: %#v", o) - } - serverSkuAfterSelectHooks = []ServerSkuHook{} - - AddServerSkuHook(boil.BeforeUpdateHook, serverSkuBeforeUpdateHook) - if err = o.doBeforeUpdateHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeUpdateHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeUpdateHook function to empty object, but got: %#v", o) - } - serverSkuBeforeUpdateHooks = []ServerSkuHook{} - - AddServerSkuHook(boil.AfterUpdateHook, serverSkuAfterUpdateHook) - if err = o.doAfterUpdateHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterUpdateHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterUpdateHook function to empty object, but got: %#v", o) - } - serverSkuAfterUpdateHooks = []ServerSkuHook{} - - AddServerSkuHook(boil.BeforeDeleteHook, serverSkuBeforeDeleteHook) - if err = o.doBeforeDeleteHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeDeleteHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeDeleteHook function to empty object, but got: %#v", o) - } - serverSkuBeforeDeleteHooks = []ServerSkuHook{} - - AddServerSkuHook(boil.AfterDeleteHook, serverSkuAfterDeleteHook) - if err = o.doAfterDeleteHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterDeleteHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterDeleteHook function to empty object, but got: %#v", o) - } - serverSkuAfterDeleteHooks = []ServerSkuHook{} - - AddServerSkuHook(boil.BeforeUpsertHook, serverSkuBeforeUpsertHook) - if err = o.doBeforeUpsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doBeforeUpsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected BeforeUpsertHook function to empty object, but got: %#v", o) - } - serverSkuBeforeUpsertHooks = []ServerSkuHook{} - - AddServerSkuHook(boil.AfterUpsertHook, serverSkuAfterUpsertHook) - if err = o.doAfterUpsertHooks(ctx, nil); err != nil { - t.Errorf("Unable to execute doAfterUpsertHooks: %s", err) - } - if !reflect.DeepEqual(o, empty) { - t.Errorf("Expected AfterUpsertHook function to empty object, but got: %#v", o) - } - serverSkuAfterUpsertHooks = []ServerSkuHook{} -} - -func testServerSkusInsert(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSku{} - if err = randomize.Struct(seed, o, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkus().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } -} - -func testServerSkusInsertWhitelist(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSku{} - if err = randomize.Struct(seed, o, serverSkuDBTypes, true); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Whitelist(serverSkuColumnsWithoutDefault...)); err != nil { - t.Error(err) - } - - count, err := ServerSkus().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } -} - -func testServerSkuToManySkuServerSkuAuxDevices(t *testing.T) { - var err error - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var a ServerSku - var b, c ServerSkuAuxDevice - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, &a, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - if err := a.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - if err = randomize.Struct(seed, &b, serverSkuAuxDeviceDBTypes, false, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Fatal(err) - } - if err = randomize.Struct(seed, &c, serverSkuAuxDeviceDBTypes, false, serverSkuAuxDeviceColumnsWithDefault...); err != nil { - t.Fatal(err) - } - - b.SkuID = a.ID - c.SkuID = a.ID - - if err = b.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = c.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - check, err := a.SkuServerSkuAuxDevices().All(ctx, tx) - if err != nil { - t.Fatal(err) - } - - bFound, cFound := false, false - for _, v := range check { - if v.SkuID == b.SkuID { - bFound = true - } - if v.SkuID == c.SkuID { - cFound = true - } - } - - if !bFound { - t.Error("expected to find b") - } - if !cFound { - t.Error("expected to find c") - } - - slice := ServerSkuSlice{&a} - if err = a.L.LoadSkuServerSkuAuxDevices(ctx, tx, false, (*[]*ServerSku)(&slice), nil); err != nil { - t.Fatal(err) - } - if got := len(a.R.SkuServerSkuAuxDevices); got != 2 { - t.Error("number of eager loaded records wrong, got:", got) - } - - a.R.SkuServerSkuAuxDevices = nil - if err = a.L.LoadSkuServerSkuAuxDevices(ctx, tx, true, &a, nil); err != nil { - t.Fatal(err) - } - if got := len(a.R.SkuServerSkuAuxDevices); got != 2 { - t.Error("number of eager loaded records wrong, got:", got) - } - - if t.Failed() { - t.Logf("%#v", check) - } -} - -func testServerSkuToManySkuServerSkuDisks(t *testing.T) { - var err error - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var a ServerSku - var b, c ServerSkuDisk - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, &a, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - if err := a.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - if err = randomize.Struct(seed, &b, serverSkuDiskDBTypes, false, serverSkuDiskColumnsWithDefault...); err != nil { - t.Fatal(err) - } - if err = randomize.Struct(seed, &c, serverSkuDiskDBTypes, false, serverSkuDiskColumnsWithDefault...); err != nil { - t.Fatal(err) - } - - b.SkuID = a.ID - c.SkuID = a.ID - - if err = b.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = c.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - check, err := a.SkuServerSkuDisks().All(ctx, tx) - if err != nil { - t.Fatal(err) - } - - bFound, cFound := false, false - for _, v := range check { - if v.SkuID == b.SkuID { - bFound = true - } - if v.SkuID == c.SkuID { - cFound = true - } - } - - if !bFound { - t.Error("expected to find b") - } - if !cFound { - t.Error("expected to find c") - } - - slice := ServerSkuSlice{&a} - if err = a.L.LoadSkuServerSkuDisks(ctx, tx, false, (*[]*ServerSku)(&slice), nil); err != nil { - t.Fatal(err) - } - if got := len(a.R.SkuServerSkuDisks); got != 2 { - t.Error("number of eager loaded records wrong, got:", got) - } - - a.R.SkuServerSkuDisks = nil - if err = a.L.LoadSkuServerSkuDisks(ctx, tx, true, &a, nil); err != nil { - t.Fatal(err) - } - if got := len(a.R.SkuServerSkuDisks); got != 2 { - t.Error("number of eager loaded records wrong, got:", got) - } - - if t.Failed() { - t.Logf("%#v", check) - } -} - -func testServerSkuToManySkuServerSkuMemories(t *testing.T) { - var err error - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var a ServerSku - var b, c ServerSkuMemory - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, &a, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - if err := a.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - if err = randomize.Struct(seed, &b, serverSkuMemoryDBTypes, false, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Fatal(err) - } - if err = randomize.Struct(seed, &c, serverSkuMemoryDBTypes, false, serverSkuMemoryColumnsWithDefault...); err != nil { - t.Fatal(err) - } - - b.SkuID = a.ID - c.SkuID = a.ID - - if err = b.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = c.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - check, err := a.SkuServerSkuMemories().All(ctx, tx) - if err != nil { - t.Fatal(err) - } - - bFound, cFound := false, false - for _, v := range check { - if v.SkuID == b.SkuID { - bFound = true - } - if v.SkuID == c.SkuID { - cFound = true - } - } - - if !bFound { - t.Error("expected to find b") - } - if !cFound { - t.Error("expected to find c") - } - - slice := ServerSkuSlice{&a} - if err = a.L.LoadSkuServerSkuMemories(ctx, tx, false, (*[]*ServerSku)(&slice), nil); err != nil { - t.Fatal(err) - } - if got := len(a.R.SkuServerSkuMemories); got != 2 { - t.Error("number of eager loaded records wrong, got:", got) - } - - a.R.SkuServerSkuMemories = nil - if err = a.L.LoadSkuServerSkuMemories(ctx, tx, true, &a, nil); err != nil { - t.Fatal(err) - } - if got := len(a.R.SkuServerSkuMemories); got != 2 { - t.Error("number of eager loaded records wrong, got:", got) - } - - if t.Failed() { - t.Logf("%#v", check) - } -} - -func testServerSkuToManySkuServerSkuNics(t *testing.T) { - var err error - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var a ServerSku - var b, c ServerSkuNic - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, &a, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - if err := a.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - if err = randomize.Struct(seed, &b, serverSkuNicDBTypes, false, serverSkuNicColumnsWithDefault...); err != nil { - t.Fatal(err) - } - if err = randomize.Struct(seed, &c, serverSkuNicDBTypes, false, serverSkuNicColumnsWithDefault...); err != nil { - t.Fatal(err) - } - - b.SkuID = a.ID - c.SkuID = a.ID - - if err = b.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = c.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - check, err := a.SkuServerSkuNics().All(ctx, tx) - if err != nil { - t.Fatal(err) - } - - bFound, cFound := false, false - for _, v := range check { - if v.SkuID == b.SkuID { - bFound = true - } - if v.SkuID == c.SkuID { - cFound = true - } - } - - if !bFound { - t.Error("expected to find b") - } - if !cFound { - t.Error("expected to find c") - } - - slice := ServerSkuSlice{&a} - if err = a.L.LoadSkuServerSkuNics(ctx, tx, false, (*[]*ServerSku)(&slice), nil); err != nil { - t.Fatal(err) - } - if got := len(a.R.SkuServerSkuNics); got != 2 { - t.Error("number of eager loaded records wrong, got:", got) - } - - a.R.SkuServerSkuNics = nil - if err = a.L.LoadSkuServerSkuNics(ctx, tx, true, &a, nil); err != nil { - t.Fatal(err) - } - if got := len(a.R.SkuServerSkuNics); got != 2 { - t.Error("number of eager loaded records wrong, got:", got) - } - - if t.Failed() { - t.Logf("%#v", check) - } -} - -func testServerSkuToManyAddOpSkuServerSkuAuxDevices(t *testing.T) { - var err error - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var a ServerSku - var b, c, d, e ServerSkuAuxDevice - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, &a, serverSkuDBTypes, false, strmangle.SetComplement(serverSkuPrimaryKeyColumns, serverSkuColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - foreigners := []*ServerSkuAuxDevice{&b, &c, &d, &e} - for _, x := range foreigners { - if err = randomize.Struct(seed, x, serverSkuAuxDeviceDBTypes, false, strmangle.SetComplement(serverSkuAuxDevicePrimaryKeyColumns, serverSkuAuxDeviceColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - } - - if err := a.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = b.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = c.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - foreignersSplitByInsertion := [][]*ServerSkuAuxDevice{ - {&b, &c}, - {&d, &e}, - } - - for i, x := range foreignersSplitByInsertion { - err = a.AddSkuServerSkuAuxDevices(ctx, tx, i != 0, x...) - if err != nil { - t.Fatal(err) - } - - first := x[0] - second := x[1] - - if a.ID != first.SkuID { - t.Error("foreign key was wrong value", a.ID, first.SkuID) - } - if a.ID != second.SkuID { - t.Error("foreign key was wrong value", a.ID, second.SkuID) - } - - if first.R.Sku != &a { - t.Error("relationship was not added properly to the foreign slice") - } - if second.R.Sku != &a { - t.Error("relationship was not added properly to the foreign slice") - } - - if a.R.SkuServerSkuAuxDevices[i*2] != first { - t.Error("relationship struct slice not set to correct value") - } - if a.R.SkuServerSkuAuxDevices[i*2+1] != second { - t.Error("relationship struct slice not set to correct value") - } - - count, err := a.SkuServerSkuAuxDevices().Count(ctx, tx) - if err != nil { - t.Fatal(err) - } - if want := int64((i + 1) * 2); count != want { - t.Error("want", want, "got", count) - } - } -} -func testServerSkuToManyAddOpSkuServerSkuDisks(t *testing.T) { - var err error - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var a ServerSku - var b, c, d, e ServerSkuDisk - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, &a, serverSkuDBTypes, false, strmangle.SetComplement(serverSkuPrimaryKeyColumns, serverSkuColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - foreigners := []*ServerSkuDisk{&b, &c, &d, &e} - for _, x := range foreigners { - if err = randomize.Struct(seed, x, serverSkuDiskDBTypes, false, strmangle.SetComplement(serverSkuDiskPrimaryKeyColumns, serverSkuDiskColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - } - - if err := a.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = b.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = c.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - foreignersSplitByInsertion := [][]*ServerSkuDisk{ - {&b, &c}, - {&d, &e}, - } - - for i, x := range foreignersSplitByInsertion { - err = a.AddSkuServerSkuDisks(ctx, tx, i != 0, x...) - if err != nil { - t.Fatal(err) - } - - first := x[0] - second := x[1] - - if a.ID != first.SkuID { - t.Error("foreign key was wrong value", a.ID, first.SkuID) - } - if a.ID != second.SkuID { - t.Error("foreign key was wrong value", a.ID, second.SkuID) - } - - if first.R.Sku != &a { - t.Error("relationship was not added properly to the foreign slice") - } - if second.R.Sku != &a { - t.Error("relationship was not added properly to the foreign slice") - } - - if a.R.SkuServerSkuDisks[i*2] != first { - t.Error("relationship struct slice not set to correct value") - } - if a.R.SkuServerSkuDisks[i*2+1] != second { - t.Error("relationship struct slice not set to correct value") - } - - count, err := a.SkuServerSkuDisks().Count(ctx, tx) - if err != nil { - t.Fatal(err) - } - if want := int64((i + 1) * 2); count != want { - t.Error("want", want, "got", count) - } - } -} -func testServerSkuToManyAddOpSkuServerSkuMemories(t *testing.T) { - var err error - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var a ServerSku - var b, c, d, e ServerSkuMemory - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, &a, serverSkuDBTypes, false, strmangle.SetComplement(serverSkuPrimaryKeyColumns, serverSkuColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - foreigners := []*ServerSkuMemory{&b, &c, &d, &e} - for _, x := range foreigners { - if err = randomize.Struct(seed, x, serverSkuMemoryDBTypes, false, strmangle.SetComplement(serverSkuMemoryPrimaryKeyColumns, serverSkuMemoryColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - } - - if err := a.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = b.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = c.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - foreignersSplitByInsertion := [][]*ServerSkuMemory{ - {&b, &c}, - {&d, &e}, - } - - for i, x := range foreignersSplitByInsertion { - err = a.AddSkuServerSkuMemories(ctx, tx, i != 0, x...) - if err != nil { - t.Fatal(err) - } - - first := x[0] - second := x[1] - - if a.ID != first.SkuID { - t.Error("foreign key was wrong value", a.ID, first.SkuID) - } - if a.ID != second.SkuID { - t.Error("foreign key was wrong value", a.ID, second.SkuID) - } - - if first.R.Sku != &a { - t.Error("relationship was not added properly to the foreign slice") - } - if second.R.Sku != &a { - t.Error("relationship was not added properly to the foreign slice") - } - - if a.R.SkuServerSkuMemories[i*2] != first { - t.Error("relationship struct slice not set to correct value") - } - if a.R.SkuServerSkuMemories[i*2+1] != second { - t.Error("relationship struct slice not set to correct value") - } - - count, err := a.SkuServerSkuMemories().Count(ctx, tx) - if err != nil { - t.Fatal(err) - } - if want := int64((i + 1) * 2); count != want { - t.Error("want", want, "got", count) - } - } -} -func testServerSkuToManyAddOpSkuServerSkuNics(t *testing.T) { - var err error - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - - var a ServerSku - var b, c, d, e ServerSkuNic - - seed := randomize.NewSeed() - if err = randomize.Struct(seed, &a, serverSkuDBTypes, false, strmangle.SetComplement(serverSkuPrimaryKeyColumns, serverSkuColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - foreigners := []*ServerSkuNic{&b, &c, &d, &e} - for _, x := range foreigners { - if err = randomize.Struct(seed, x, serverSkuNicDBTypes, false, strmangle.SetComplement(serverSkuNicPrimaryKeyColumns, serverSkuNicColumnsWithoutDefault)...); err != nil { - t.Fatal(err) - } - } - - if err := a.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = b.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - if err = c.Insert(ctx, tx, boil.Infer()); err != nil { - t.Fatal(err) - } - - foreignersSplitByInsertion := [][]*ServerSkuNic{ - {&b, &c}, - {&d, &e}, - } - - for i, x := range foreignersSplitByInsertion { - err = a.AddSkuServerSkuNics(ctx, tx, i != 0, x...) - if err != nil { - t.Fatal(err) - } - - first := x[0] - second := x[1] - - if a.ID != first.SkuID { - t.Error("foreign key was wrong value", a.ID, first.SkuID) - } - if a.ID != second.SkuID { - t.Error("foreign key was wrong value", a.ID, second.SkuID) - } - - if first.R.Sku != &a { - t.Error("relationship was not added properly to the foreign slice") - } - if second.R.Sku != &a { - t.Error("relationship was not added properly to the foreign slice") - } - - if a.R.SkuServerSkuNics[i*2] != first { - t.Error("relationship struct slice not set to correct value") - } - if a.R.SkuServerSkuNics[i*2+1] != second { - t.Error("relationship struct slice not set to correct value") - } - - count, err := a.SkuServerSkuNics().Count(ctx, tx) - if err != nil { - t.Fatal(err) - } - if want := int64((i + 1) * 2); count != want { - t.Error("want", want, "got", count) - } - } -} - -func testServerSkusReload(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSku{} - if err = randomize.Struct(seed, o, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - if err = o.Reload(ctx, tx); err != nil { - t.Error(err) - } -} - -func testServerSkusReloadAll(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSku{} - if err = randomize.Struct(seed, o, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice := ServerSkuSlice{o} - - if err = slice.ReloadAll(ctx, tx); err != nil { - t.Error(err) - } -} - -func testServerSkusSelect(t *testing.T) { - t.Parallel() - - seed := randomize.NewSeed() - var err error - o := &ServerSku{} - if err = randomize.Struct(seed, o, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - slice, err := ServerSkus().All(ctx, tx) - if err != nil { - t.Error(err) - } - - if len(slice) != 1 { - t.Error("want one record, got:", len(slice)) - } -} - -var ( - serverSkuDBTypes = map[string]string{`ID`: `uuid`, `Name`: `string`, `Version`: `string`, `Vendor`: `string`, `Chassis`: `string`, `BMCModel`: `string`, `MotherboardModel`: `string`, `CPUVendor`: `string`, `CPUModel`: `string`, `CPUCores`: `int8`, `CPUHertz`: `int8`, `CPUCount`: `int8`, `CreatedAt`: `timestamptz`, `UpdatedAt`: `timestamptz`} - _ = bytes.MinRead -) - -func testServerSkusUpdate(t *testing.T) { - t.Parallel() - - if 0 == len(serverSkuPrimaryKeyColumns) { - t.Skip("Skipping table with no primary key columns") - } - if len(serverSkuAllColumns) == len(serverSkuPrimaryKeyColumns) { - t.Skip("Skipping table with only primary key columns") - } - - seed := randomize.NewSeed() - var err error - o := &ServerSku{} - if err = randomize.Struct(seed, o, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkus().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } - - if err = randomize.Struct(seed, o, serverSkuDBTypes, true, serverSkuPrimaryKeyColumns...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - if rowsAff, err := o.Update(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("should only affect one row but affected", rowsAff) - } -} - -func testServerSkusSliceUpdateAll(t *testing.T) { - t.Parallel() - - if len(serverSkuAllColumns) == len(serverSkuPrimaryKeyColumns) { - t.Skip("Skipping table with only primary key columns") - } - - seed := randomize.NewSeed() - var err error - o := &ServerSku{} - if err = randomize.Struct(seed, o, serverSkuDBTypes, true, serverSkuColumnsWithDefault...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - ctx := context.Background() - tx := MustTx(boil.BeginTx(ctx, nil)) - defer func() { _ = tx.Rollback() }() - if err = o.Insert(ctx, tx, boil.Infer()); err != nil { - t.Error(err) - } - - count, err := ServerSkus().Count(ctx, tx) - if err != nil { - t.Error(err) - } - - if count != 1 { - t.Error("want one record, got:", count) - } - - if err = randomize.Struct(seed, o, serverSkuDBTypes, true, serverSkuPrimaryKeyColumns...); err != nil { - t.Errorf("Unable to randomize ServerSku struct: %s", err) - } - - // Remove Primary keys and unique columns from what we plan to update - var fields []string - if strmangle.StringSliceMatch(serverSkuAllColumns, serverSkuPrimaryKeyColumns) { - fields = serverSkuAllColumns - } else { - fields = strmangle.SetComplement( - serverSkuAllColumns, - serverSkuPrimaryKeyColumns, - ) - } - - value := reflect.Indirect(reflect.ValueOf(o)) - typ := reflect.TypeOf(o).Elem() - n := typ.NumField() - - updateMap := M{} - for _, col := range fields { - for i := 0; i < n; i++ { - f := typ.Field(i) - if f.Tag.Get("boil") == col { - updateMap[col] = value.Field(i).Interface() - } - } - } - - slice := ServerSkuSlice{o} - if rowsAff, err := slice.UpdateAll(ctx, tx, updateMap); err != nil { - t.Error(err) - } else if rowsAff != 1 { - t.Error("wanted one record updated but got", rowsAff) - } -} diff --git a/internal/models/versioned_attributes.go b/internal/models/versioned_attributes.go index a8b71df9..8517c2aa 100644 --- a/internal/models/versioned_attributes.go +++ b/internal/models/versioned_attributes.go @@ -80,6 +80,29 @@ var VersionedAttributeTableColumns = struct { // Generated where +type whereHelperint64 struct{ field string } + +func (w whereHelperint64) EQ(x int64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.EQ, x) } +func (w whereHelperint64) NEQ(x int64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.NEQ, x) } +func (w whereHelperint64) LT(x int64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.LT, x) } +func (w whereHelperint64) LTE(x int64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.LTE, x) } +func (w whereHelperint64) GT(x int64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.GT, x) } +func (w whereHelperint64) GTE(x int64) qm.QueryMod { return qmhelper.Where(w.field, qmhelper.GTE, x) } +func (w whereHelperint64) IN(slice []int64) qm.QueryMod { + values := make([]interface{}, 0, len(slice)) + for _, value := range slice { + values = append(values, value) + } + return qm.WhereIn(fmt.Sprintf("%s IN ?", w.field), values...) +} +func (w whereHelperint64) NIN(slice []int64) qm.QueryMod { + values := make([]interface{}, 0, len(slice)) + for _, value := range slice { + values = append(values, value) + } + return qm.WhereNotIn(fmt.Sprintf("%s NOT IN ?", w.field), values...) +} + var VersionedAttributeWhere = struct { ID whereHelperstring ServerID whereHelpernull_String diff --git a/pkg/api/v1/bios_config_component.go b/pkg/api/v1/bios_config_component.go index 81194de0..f8fb5332 100644 --- a/pkg/api/v1/bios_config_component.go +++ b/pkg/api/v1/bios_config_component.go @@ -17,7 +17,6 @@ type BiosConfigComponent struct { UpdatedAt time.Time `json:"updated_at"` } -// toDBModelBiosConfigComponent converts a BiosConfigComponent into a models.BiosConfigComponent func (cc *BiosConfigComponent) toDBModelBiosConfigComponent() *models.BiosConfigComponent { dbcc := &models.BiosConfigComponent{ Name: cc.Name, @@ -28,22 +27,6 @@ func (cc *BiosConfigComponent) toDBModelBiosConfigComponent() *models.BiosConfig return dbcc } -// toDBModelBiosConfigComponentDeep converts a BiosConfigComponent into a models.BiosConfigComponent. It also includes all relations, doing a deep copy -func (cc *BiosConfigComponent) toDBModelBiosConfigComponentDeep(set *models.BiosConfigSet) *models.BiosConfigComponent { - dbcc := cc.toDBModelBiosConfigComponent() - - if len(cc.Settings) > 0 { - dbcc.R = dbcc.R.NewStruct() - dbcc.R.FKBiosConfigSet = set - - for _, setting := range cc.Settings { - dbcc.R.FKBiosConfigComponentBiosConfigSettings = append(dbcc.R.FKBiosConfigComponentBiosConfigSettings, setting.toDBModelBiosConfigSettingDeep(dbcc)) - } - } - - return dbcc -} - // fromDBModelBiosConfigComponent converts a models.BiosConfigComponent (created by sqlboiler) into a BiosConfigComponent func (cc *BiosConfigComponent) fromDBModelBiosConfigComponent(component *models.BiosConfigComponent) { cc.ID = component.ID diff --git a/pkg/api/v1/bios_config_set.go b/pkg/api/v1/bios_config_set.go index f4306a09..8927343b 100644 --- a/pkg/api/v1/bios_config_set.go +++ b/pkg/api/v1/bios_config_set.go @@ -17,7 +17,7 @@ type BiosConfigSet struct { UpdatedAt time.Time `json:"updated_at"` } -// toDBModelBiosConfigSet converts a BiosConfigSet into a models.BiosConfigSet +// toDBModelBiosConfigSet converts a BiosConfigSet into a models.BiosConfigSet (created by sqlboiler) func (cs *BiosConfigSet) toDBModelBiosConfigSet() *models.BiosConfigSet { dbcs := &models.BiosConfigSet{ Name: cs.Name, @@ -28,23 +28,8 @@ func (cs *BiosConfigSet) toDBModelBiosConfigSet() *models.BiosConfigSet { return dbcs } -// toDBModelBiosConfigSetDeep converts a BiosConfigSet into a models.BiosConfigSet. It also includes all relations, doing a deep copy -func (cs *BiosConfigSet) toDBModelBiosConfigSetDeep() *models.BiosConfigSet { - dbcs := cs.toDBModelBiosConfigSet() - - if len(cs.Components) > 0 { - dbcs.R = dbcs.R.NewStruct() - - for _, component := range cs.Components { - dbcs.R.FKBiosConfigSetBiosConfigComponents = append(dbcs.R.FKBiosConfigSetBiosConfigComponents, component.toDBModelBiosConfigComponentDeep(dbcs)) - } - } - - return dbcs -} - -// fromDBModelBiosConfigSet converts a models.BiosConfigSet into a BiosConfigSet -func (cs *BiosConfigSet) fromDBModelBiosConfigSet(set *models.BiosConfigSet) { +// fromDBModelBiosConfigSet converts a models.BiosConfigSet (created by sqlboiler) into a BiosConfigSet +func (cs *BiosConfigSet) fromDBModelBiosConfigSet(set *models.BiosConfigSet) error { cs.ID = set.ID cs.Name = set.Name cs.Version = set.Version @@ -57,4 +42,6 @@ func (cs *BiosConfigSet) fromDBModelBiosConfigSet(set *models.BiosConfigSet) { cs.Components[i].fromDBModelBiosConfigComponent(dbComponent) } } + + return nil } diff --git a/pkg/api/v1/bios_config_set_params.go b/pkg/api/v1/bios_config_set_params.go index 7143a616..f41570cb 100644 --- a/pkg/api/v1/bios_config_set_params.go +++ b/pkg/api/v1/bios_config_set_params.go @@ -80,7 +80,7 @@ func parseBiosConfigSetListParams(c *gin.Context) (*BiosConfigSetListParams, err // queryMods converts the list params into sql conditions that can be added to sql queries func (p *BiosConfigSetListParams) queryMods() []qm.QueryMod { - mods := []qm.QueryMod{qm.Distinct(fmt.Sprintf("\"%s\".*", models.TableNames.BiosConfigSets))} + mods := []qm.QueryMod{} // Only INNER JOIN if we have query params for settings or components haveComponents := false diff --git a/pkg/api/v1/bios_config_set_params_test.go b/pkg/api/v1/bios_config_set_params_test.go index 6e7a52d2..5b10c7fe 100644 --- a/pkg/api/v1/bios_config_set_params_test.go +++ b/pkg/api/v1/bios_config_set_params_test.go @@ -116,7 +116,7 @@ func TestBiosConfigSetQueryMods(t *testing.T) { }, } - mods := []qm.QueryMod{qm.Distinct(fmt.Sprintf("\"%s\".*", models.TableNames.BiosConfigSets))} + mods := []qm.QueryMod{} whereMods := []qm.QueryMod{} whereMods = appendOperatorQueryMod(whereMods, OperatorComparitorLike, models.BiosConfigComponentTableColumns.Name, testBiosConfigSetQueryParams.Params[0].Set.Components[0].Name) whereMods = []qm.QueryMod{ diff --git a/pkg/api/v1/bios_config_setting.go b/pkg/api/v1/bios_config_setting.go index dcafb09e..164ca89f 100644 --- a/pkg/api/v1/bios_config_setting.go +++ b/pkg/api/v1/bios_config_setting.go @@ -18,7 +18,6 @@ type BiosConfigSetting struct { UpdatedAt time.Time `json:"updated_at"` } -// toDBModelBiosConfigSetting converts a BiosConfigSetting into a models.BiosConfigSetting func (ccs *BiosConfigSetting) toDBModelBiosConfigSetting() *models.BiosConfigSetting { dbccs := &models.BiosConfigSetting{ SettingsKey: ccs.Key, @@ -29,16 +28,6 @@ func (ccs *BiosConfigSetting) toDBModelBiosConfigSetting() *models.BiosConfigSet return dbccs } -// toDBModelBiosConfigSettingDeep converts a BiosConfigSetting into a models.BiosConfigSetting. It also includes all relations, doing a deep copy -func (ccs *BiosConfigSetting) toDBModelBiosConfigSettingDeep(cc *models.BiosConfigComponent) *models.BiosConfigSetting { - dbccs := ccs.toDBModelBiosConfigSetting() - dbccs.R = dbccs.R.NewStruct() - dbccs.R.FKBiosConfigComponent = cc - - return dbccs -} - -// fromDBModelBiosConfigSetting converts a models.BiosConfigSetting into a BiosConfigSetting func (ccs *BiosConfigSetting) fromDBModelBiosConfigSetting(setting *models.BiosConfigSetting) { ccs.ID = setting.ID ccs.Key = setting.SettingsKey diff --git a/pkg/api/v1/errors.go b/pkg/api/v1/errors.go index 563b532e..26daaa0b 100644 --- a/pkg/api/v1/errors.go +++ b/pkg/api/v1/errors.go @@ -16,11 +16,6 @@ var ( ErrNoNextPage = errors.New("no next page found") // ErrUUIDParse is returned when the UUID is invalid. ErrUUIDParse = errors.New("UUID parse error") - - // Route Errors - errRouteBase = "error fullfilling %s request" - ErrRouteServerSku = fmt.Errorf(errRouteBase, "server sku") - ErrRouteBiosConfigSet = fmt.Errorf(errRouteBase, "bios config set") ) // ClientError is returned when invalid arguments are provided to the client @@ -47,7 +42,7 @@ func (e ServerError) Error() string { func loggedRollback(r *Router, tx *sql.Tx) { err := tx.Rollback() - if err != nil && !errors.Is(err, sql.ErrTxDone) { + if err != nil { r.Logger.Error("Failed transaction, attempting rollback", zap.Error(err)) } } diff --git a/pkg/api/v1/firmware_list_params.go b/pkg/api/v1/firmware_list_params.go index 1a3a335d..afab2b88 100644 --- a/pkg/api/v1/firmware_list_params.go +++ b/pkg/api/v1/firmware_list_params.go @@ -20,7 +20,6 @@ type ComponentFirmwareVersionListParams struct { Pagination *PaginationParams } -// setQuery implements the queryParams interface func (p *ComponentFirmwareVersionListParams) setQuery(q url.Values) { if p == nil { return diff --git a/pkg/api/v1/firmware_set_list_params.go b/pkg/api/v1/firmware_set_list_params.go index 00a0d5e2..ff55e884 100644 --- a/pkg/api/v1/firmware_set_list_params.go +++ b/pkg/api/v1/firmware_set_list_params.go @@ -19,7 +19,6 @@ type ComponentFirmwareSetListParams struct { AttributeListParams []AttributeListParams } -// setQuery implements the queryParams interface func (p *ComponentFirmwareSetListParams) setQuery(q url.Values) { if p == nil { return diff --git a/pkg/api/v1/query_operators.go b/pkg/api/v1/query_operators.go index ecb540da..d647f060 100644 --- a/pkg/api/v1/query_operators.go +++ b/pkg/api/v1/query_operators.go @@ -3,7 +3,6 @@ package fleetdbapi import ( "fmt" "reflect" - "strconv" "strings" "github.com/volatiletech/sqlboiler/v4/queries/qm" @@ -38,20 +37,7 @@ const ( ) // appendOperatorQueryMod is a helper function to build qm.QueryMods. -func appendOperatorQueryMod[T []int64 | string](mods []qm.QueryMod, comparitor OperatorComparitorType, name string, v T) []qm.QueryMod { - var value string - if s, ok := any(v).(string); ok { - value = s - } else if i, ok := any(v).([]int64); ok { - // This is a work around so ints as params be ignored by default (empty list). Array with 1 item is something to use. With strings i can use empty string. I cant use -1 for ints, might be something in the future that uses negatives. - // I think we should also have strings be arrays. So we can query on empty strings, and it makes creating queries much simple when searching for multiple terms. - if len(i) > 0 { - value = strconv.FormatInt(i[0], 10) - } else { - value = "" - } - } - +func appendOperatorQueryMod(mods []qm.QueryMod, comparitor OperatorComparitorType, name, value string) []qm.QueryMod { if value != "" { switch comparitor { case OperatorComparitorLike: @@ -64,12 +50,6 @@ func appendOperatorQueryMod[T []int64 | string](mods []qm.QueryMod, comparitor O case OperatorComparitorNotEqual: mod := qm.Where(fmt.Sprintf("%s != ?", name), value) mods = append(mods, mod) - case OperatorComparitorGreaterThan: - mod := qm.Where(fmt.Sprintf("%s > ?", name), value) - mods = append(mods, mod) - case OperatorComparitorLessThan: - mod := qm.Where(fmt.Sprintf("%s < ?", name), value) - mods = append(mods, mod) case OperatorComparitorEqual: fallthrough default: diff --git a/pkg/api/v1/router.go b/pkg/api/v1/router.go index d52ffa98..d9e136dc 100644 --- a/pkg/api/v1/router.go +++ b/pkg/api/v1/router.go @@ -161,16 +161,6 @@ func (r *Router) Routes(rg *gin.RouterGroup) { srvCfgSets.PUT("/:uuid", amw.AuthRequired(readScopes("server-bios-config-sets")), r.serverBiosConfigSetUpdate) srvCfgSets.DELETE("/:uuid", amw.AuthRequired(readScopes("server-bios-config-sets")), r.serverBiosConfigSetDelete) } - - // /server-skus - srvServerSkus := rg.Group(fmt.Sprintf("/%s", serverSkuEndpoint)) - { - srvServerSkus.GET("", amw.AuthRequired(readScopes(serverSkuEndpoint)), r.serverSkuList) - srvServerSkus.POST("", amw.AuthRequired(readScopes(serverSkuEndpoint)), r.serverSkuCreate) - srvServerSkus.GET("/:uuid", amw.AuthRequired(readScopes(serverSkuEndpoint)), r.serverSkuGet) - srvServerSkus.PUT("/:uuid", amw.AuthRequired(readScopes(serverSkuEndpoint)), r.serverSkuUpdate) - srvServerSkus.DELETE("/:uuid", amw.AuthRequired(readScopes(serverSkuEndpoint)), r.serverSkuDelete) - } } func createScopes(items ...string) []string { diff --git a/pkg/api/v1/router_bios_config_set.go b/pkg/api/v1/router_bios_config_set.go index 842ae1c9..efcf49c1 100644 --- a/pkg/api/v1/router_bios_config_set.go +++ b/pkg/api/v1/router_bios_config_set.go @@ -14,6 +14,12 @@ import ( "github.com/metal-toolbox/fleetdb/internal/models" ) +var ( + errBiosConfigSetRoute = errors.New("error fullfilling config set request") + errConfigListRoute = errors.New("error fullfilling config set list request") + errNullRelation = errors.New("sqlboiler relation was unexpectedly null") +) + func (r *Router) serverBiosConfigSetCreate(c *gin.Context) { var payload BiosConfigSet @@ -37,9 +43,9 @@ func (r *Router) serverBiosConfigSetCreate(c *gin.Context) { func (r *Router) serverBiosConfigSetGet(c *gin.Context) { // Get Config Set id := c.Param("uuid") - _, err := uuid.Parse(id) - if err != nil { - badRequestResponse(c, "invalid UUID query param", ErrRouteBiosConfigSet) + if id == "" || id == uuid.Nil.String() { + badRequestResponse(c, "no UUID query param", errBiosConfigSetRoute) + return } mods := []qm.QueryMod{ @@ -54,16 +60,19 @@ func (r *Router) serverBiosConfigSetGet(c *gin.Context) { // Convert to Marshallable struct var set BiosConfigSet - set.fromDBModelBiosConfigSet(dbBiosConfigSet) + err = set.fromDBModelBiosConfigSet(dbBiosConfigSet) + if err != nil { + dbErrorResponse(c, err) + return + } itemResponse(c, set) } func (r *Router) serverBiosConfigSetDelete(c *gin.Context) { id := c.Param("uuid") - _, err := uuid.Parse(id) - if err != nil { - badRequestResponse(c, "invalid UUID query param", ErrRouteBiosConfigSet) + if id == "" || id == uuid.Nil.String() { + badRequestResponse(c, "no UUID query param", errBiosConfigSetRoute) } set := &models.BiosConfigSet{} @@ -82,7 +91,7 @@ func (r *Router) serverBiosConfigSetDelete(c *gin.Context) { func (r *Router) serverBiosConfigSetList(c *gin.Context) { params, err := parseBiosConfigSetListParams(c) if err != nil { - badRequestResponse(c, "invalid query params", ErrRouteBiosConfigSet) + badRequestResponse(c, "invalid query params", errConfigListRoute) return } @@ -103,7 +112,11 @@ func (r *Router) serverBiosConfigSetList(c *gin.Context) { sets := make([]BiosConfigSet, len(dbSets)) for i, dbSet := range dbSets { - sets[i].fromDBModelBiosConfigSet(dbSet) + err = sets[i].fromDBModelBiosConfigSet(dbSet) + if err != nil { + dbErrorResponse(c, err) + return + } } pd := paginationData{ @@ -120,13 +133,12 @@ func (r *Router) serverBiosConfigSetUpdate(c *gin.Context) { // Get ID id := c.Param("uuid") - _, err := uuid.Parse(id) - if err != nil { - badRequestResponse(c, "invalid UUID query param", ErrRouteBiosConfigSet) + if id == "" || id == uuid.Nil.String() { + badRequestResponse(c, "no UUID query param", errBiosConfigSetRoute) } // Unmarshal JSON payload - err = c.ShouldBindJSON(&payload) + err := c.ShouldBindJSON(&payload) if err != nil { badRequestResponse(c, "invalid payload: BiosConfigSetUpdate{}; failed to unmarshal config set", err) return @@ -160,11 +172,12 @@ func (r *Router) updateBiosConfigSet(ctx context.Context, set *BiosConfigSet, ol defer loggedRollback(r, tx) - dbSet := set.toDBModelBiosConfigSetDeep() + dbSet := set.toDBModelBiosConfigSet() + dbSet.ID = set.ID _, err = dbSet.Update(ctx, tx, boil.Infer()) if err != nil { - return "", errors.Wrap(err, fmt.Sprintf("ID: %s", dbSet.ID)) + return "", errors.Wrap(err, fmt.Sprintf("IDs: %s", dbSet.ID)) } var oldComponents []*models.BiosConfigComponent @@ -242,8 +255,8 @@ func updateBiosConfigSetDeleteHelper(ctx context.Context, tx *sql.Tx, components func updateBiosConfigSetInsertUpdateHelper(ctx context.Context, tx *sql.Tx, components []*models.BiosConfigComponent, componentsToUpdate []bool, settingsToUpdate [][]bool) error { for c, component := range components { - if component.R == nil || component.R.FKBiosConfigSet == nil { - return nil + if component.R == nil { + return errNullRelation } err := component.R.FKBiosConfigSet.AddFKBiosConfigSetBiosConfigComponents(ctx, tx, !componentsToUpdate[c], component) diff --git a/pkg/api/v1/router_bios_config_set_test.go b/pkg/api/v1/router_bios_config_set_test.go index ff1f112a..6372ef2b 100644 --- a/pkg/api/v1/router_bios_config_set_test.go +++ b/pkg/api/v1/router_bios_config_set_test.go @@ -1,7 +1,9 @@ package fleetdbapi_test import ( + "bytes" "context" + "encoding/json" "fmt" "testing" @@ -121,8 +123,6 @@ func TestIntegrationServerBiosConfigSetGet(t *testing.T) { return err } - require.NotNil(t, resp) - assertEntireBiosConfigSetEqual(t, dbtools.FixtureBiosConfigSet, dbtools.FixtureBiosConfigComponents, @@ -158,11 +158,12 @@ func TestIntegrationServerBiosConfigSetGet(t *testing.T) { for _, tc := range testCases { t.Run(tc.testName, func(t *testing.T) { id, err := uuid.Parse(tc.BiosConfigSetID) - require.NoError(t, err) + assert.NoError(t, err) resp, err := s.Client.GetServerBiosConfigSet(context.TODO(), id) if tc.expectedError { + assert.Nil(t, resp) assert.Nil(t, resp) assert.Error(t, err) assert.Contains(t, err.Error(), tc.msg) @@ -172,12 +173,14 @@ func TestIntegrationServerBiosConfigSetGet(t *testing.T) { assert.NotNil(t, resp) assert.Contains(t, resp.Message, tc.msg) + var set = resp.Record.(*fleetdbapi.BiosConfigSet) + // Fixtures are stored as models.BiosConfigSet, while the API returns fleetdbapi.BiosConfigSet, so we must manually compare the values assertEntireBiosConfigSetEqual(t, dbtools.FixtureBiosConfigSet, dbtools.FixtureBiosConfigComponents, dbtools.FixtureBiosConfigSettings, - resp.Record.(*fleetdbapi.BiosConfigSet)) + set) } }) } @@ -415,61 +418,21 @@ func TestIntegrationServerBiosConfigSetList(t *testing.T) { // Setup for queries BiosConfigSetSetup := BiosConfigSetTest - - // Item 1 BiosConfigSetSetup.ID = "" BiosConfigSetSetup.Name = "List Test 1" resp, err := s.Client.CreateServerBiosConfigSet(context.TODO(), BiosConfigSetSetup) require.NoError(t, err) require.NotNil(t, resp) - // Item 2 + BiosConfigSetSetup.ID = "" BiosConfigSetSetup.Name = "List Test 2" - var tempComponentsArray []fleetdbapi.BiosConfigComponent - for i := range BiosConfigSetSetup.Components { // Remove PCIE devices from components - if BiosConfigSetSetup.Components[i].Model != "PCIE" { - tempComponentsArray = append(tempComponentsArray, BiosConfigSetSetup.Components[i]) - } - } - backupComponents := BiosConfigSetSetup.Components - BiosConfigSetSetup.Components = tempComponentsArray - resp, err = s.Client.CreateServerBiosConfigSet(context.TODO(), BiosConfigSetSetup) require.NoError(t, err) require.NotNil(t, resp) - // Item 3 BiosConfigSetSetup.ID = "" BiosConfigSetSetup.Name = "List Test 3" - newComponent := fleetdbapi.BiosConfigComponent{ - Name: "TP-LinkNetwork Adapter", - Vendor: "TP-Link", - Model: "PCIE", - Settings: []fleetdbapi.BiosConfigSetting{ - { - Key: "PXEEnable", - Value: "true", - Raw: []byte(`{}`), - }, - { - Key: "SRIOVEnable", - Value: "false", - }, - { - Key: "position", - Value: "2", - Raw: []byte(`{ "lanes": 8 }`), - }, - }, - } - BiosConfigSetSetup.Components = append(backupComponents, newComponent) // Add Additional PCIE device for param test 5 - - for i := range BiosConfigSetSetup.Components { // Change SM Motherboard to Dell - if BiosConfigSetSetup.Components[i].Name == "SM Motherboard" { - BiosConfigSetSetup.Components[i].Name = "Dell Motherboard" - } - } - + BiosConfigSetSetup.Components[0].Name = "Dell Motherboard" resp, err = s.Client.CreateServerBiosConfigSet(context.TODO(), BiosConfigSetSetup) require.NoError(t, err) require.NotNil(t, resp) @@ -549,7 +512,6 @@ func TestIntegrationServerBiosConfigSetList(t *testing.T) { Preload: false, }, } - // Get all but the 3rd based on components "SM Motherboard" listTestParams4 := fleetdbapi.BiosConfigSetListParams{ Params: []fleetdbapi.BiosConfigSetQueryParams{ @@ -577,33 +539,6 @@ func TestIntegrationServerBiosConfigSetList(t *testing.T) { }, } - // Get all but second based on PCIE devices. This is to test "DISTINCT", since Item 3 has two PCIE components - listTestParams5 := fleetdbapi.BiosConfigSetListParams{ - Params: []fleetdbapi.BiosConfigSetQueryParams{ - { - Set: fleetdbapi.BiosConfigSetQuery{ - Name: "List Test", - }, - LogicalOperator: fleetdbapi.OperatorLogicalAND, - ComparitorOperator: fleetdbapi.OperatorComparitorLike, - }, - { - Set: fleetdbapi.BiosConfigSetQuery{ - Components: []fleetdbapi.BiosConfigComponentQuery{ - { - Model: "PCIE", - }, - }, - }, - LogicalOperator: fleetdbapi.OperatorLogicalAND, - ComparitorOperator: fleetdbapi.OperatorComparitorEqual, - }, - }, - Pagination: fleetdbapi.PaginationParams{ - Preload: true, - }, - } - var testCases = []struct { testName string params fleetdbapi.BiosConfigSetListParams @@ -611,41 +546,35 @@ func TestIntegrationServerBiosConfigSetList(t *testing.T) { expectedError bool }{ { - "config set router: config set list; find none", + "config set router: config set list; success 0", listTestParams0, 0, false, }, { - "config set router: config set list; find all", + "config set router: config set list; success 1", listTestParams1, 3, false, }, { - "config set router: config set list; NOT test", + "config set router: config set list; success 2", listTestParams2, 2, false, }, { - "config set router: config set list; wildcard test", + "config set router: config set list; success 3", listTestParams3, 3, false, }, { - "config set router: config set list; component query test", + "config set router: config set list; success 4", listTestParams4, 2, false, }, - { - "config set router: config set list; DISTINCT test", - listTestParams5, - 2, - false, - }, } for _, tc := range testCases { @@ -734,7 +663,15 @@ func assertBiosConfigSettingEqual(t *testing.T, expected *models.BiosConfigSetti if expected.Raw.IsZero() { assert.Nil(t, actual.Raw) - } else { - assert.JSONEq(t, string(expected.Raw.JSON), string(actual.Raw)) + } else { // JSON []byte can have excess namespace, so lets remove that when comparing + var expectedBuffer bytes.Buffer + err := json.Compact(&expectedBuffer, expected.Raw.JSON) + require.NoError(t, err) + + var actualBuffer bytes.Buffer + err = json.Compact(&actualBuffer, actual.Raw) + require.NoError(t, err) + + assert.Equal(t, expectedBuffer.Bytes(), actualBuffer.Bytes()) } } diff --git a/pkg/api/v1/router_server_sku.go b/pkg/api/v1/router_server_sku.go deleted file mode 100644 index 515e86f5..00000000 --- a/pkg/api/v1/router_server_sku.go +++ /dev/null @@ -1,492 +0,0 @@ -package fleetdbapi - -import ( - "context" - "database/sql" - "fmt" - - "github.com/gin-gonic/gin" - "github.com/google/uuid" - "github.com/pkg/errors" - "github.com/volatiletech/sqlboiler/v4/boil" - "github.com/volatiletech/sqlboiler/v4/queries/qm" - - "github.com/metal-toolbox/fleetdb/internal/models" -) - -func (r *Router) serverSkuCreate(c *gin.Context) { - var payload ServerSku - - // Unmarshal JSON payload - err := c.ShouldBindJSON(&payload) - if err != nil { - badRequestResponse(c, "invalid payload; failed to unmarshal sku", err) - } - - // Insert DBModel into DB - id, err := r.insertServerSku(c.Request.Context(), &payload) - if err != nil { - dbErrorResponse(c, err) - return - } - - createdResponse(c, id) -} - -func (r *Router) serverSkuGet(c *gin.Context) { - // Get ID - id := c.Param("uuid") - _, err := uuid.Parse(id) - if err != nil { - badRequestResponse(c, "invalid UUID query param", ErrRouteServerSku) - return - } - - // Setup query - mods := []qm.QueryMod{ - qm.Where(fmt.Sprintf("%s = ?", models.ServerSkuColumns.ID), id), - } - - // Get Server Sku - dbServerSku, err := r.eagerLoadServerSku(c.Request.Context(), mods) - if err != nil { - dbErrorResponse(c, err) - return - } - - // Convert to Marshallable struct - var sku ServerSku - sku.fromDBModelServerSku(dbServerSku) - - itemResponse(c, sku) -} - -func (r *Router) serverSkuUpdate(c *gin.Context) { - var payload ServerSku - - // Get ID - id := c.Param("uuid") - _, err := uuid.Parse(id) - if err != nil { - badRequestResponse(c, "invalid UUID query param", ErrRouteServerSku) - return - } - - // Unmarshal JSON payload - err = c.ShouldBindJSON(&payload) - if err != nil { - badRequestResponse(c, "invalid payload; failed to unmarshal sku", err) - return - } - - // Setup query - mods := []qm.QueryMod{ - qm.Where(fmt.Sprintf("%s = ?", models.ServerSkuColumns.ID), id), - } - - // Get Current Server Sku - oldDBServerSku, err := r.eagerLoadServerSku(c.Request.Context(), mods) - if err != nil { - dbErrorResponse(c, err) - return - } - - newDBServerSku := payload.toDBModelServerSkuDeep(oldDBServerSku.ID) - - // Insert DBModel into DB - id, err = r.updateServerSkuTransaction(c.Request.Context(), newDBServerSku, oldDBServerSku) - if err != nil { - dbErrorResponse2(c, "failed to update server sku", err) - return - } - - updatedResponse(c, id) -} - -func (r *Router) serverSkuDelete(c *gin.Context) { - // Get ID - id := c.Param("uuid") - _, err := uuid.Parse(id) - if err != nil { - badRequestResponse(c, "invalid UUID query param", ErrRouteServerSku) - return - } - - set := &models.ServerSku{} - set.ID = id - - // Delete Config Set - count, err := set.Delete(c.Request.Context(), r.DB) - if err != nil { - dbErrorResponse(c, err) - return - } - - deletedResponse2(c, count) -} - -func (r *Router) serverSkuList(c *gin.Context) { - params, err := parseServerSkuListParams(c) - if err != nil { - badRequestResponse(c, "invalid query params", ErrRouteBiosConfigSet) - return - } - - mods := params.queryMods() - - count, err := models.ServerSkus().Count(c.Request.Context(), r.DB) - if err != nil { - dbErrorResponse(c, err) - return - } - - dbSkus, err := r.eagerLoadAllServerSku(c.Request.Context(), mods, params.Pagination.Preload) - if err != nil { - dbErrorResponse(c, err) - return - } - - skus := make([]ServerSku, len(dbSkus)) - - for i, dbSku := range dbSkus { - skus[i].fromDBModelServerSku(dbSku) - if err != nil { - dbErrorResponse(c, err) - return - } - } - - pd := paginationData{ - pageCount: len(skus), - totalCount: count, - pager: params.Pagination, - } - - listResponse(c, skus, pd) -} - -func (r *Router) eagerLoadServerSku(ctx context.Context, mods []qm.QueryMod) (*models.ServerSku, error) { - // Include all relations - mods = append(mods, qm.Load(models.ServerSkuRels.SkuServerSkuAuxDevices)) - mods = append(mods, qm.Load(models.ServerSkuRels.SkuServerSkuDisks)) - mods = append(mods, qm.Load(models.ServerSkuRels.SkuServerSkuMemories)) - mods = append(mods, qm.Load(models.ServerSkuRels.SkuServerSkuNics)) - - // Execute query - dbSku, err := models.ServerSkus(mods...).One(ctx, r.DB) - if err != nil { - return nil, err - } - - return dbSku, nil -} - -func (r *Router) eagerLoadAllServerSku(ctx context.Context, mods []qm.QueryMod, preload bool) ([]*models.ServerSku, error) { - // Eager load relations - if preload { - mods = append(mods, qm.Load(models.ServerSkuRels.SkuServerSkuAuxDevices)) - mods = append(mods, qm.Load(models.ServerSkuRels.SkuServerSkuDisks)) - mods = append(mods, qm.Load(models.ServerSkuRels.SkuServerSkuMemories)) - mods = append(mods, qm.Load(models.ServerSkuRels.SkuServerSkuNics)) - } - - // Execute query - dbSku, err := models.ServerSkus(mods...).All(ctx, r.DB) - if err != nil { - return nil, err - } - - return dbSku, nil -} - -func (r *Router) insertServerSku(ctx context.Context, sku *ServerSku) (string, error) { - tx, err := r.DB.BeginTx(ctx, nil) - if err != nil { - return "", err - } - - defer loggedRollback(r, tx) - - dbSku := sku.toDBModelServerSku() - - err = dbSku.Insert(ctx, tx, boil.Infer()) - if err != nil { - return "", err - } - - // Aux Devices - dbAuxDevice := make([]*models.ServerSkuAuxDevice, len(sku.AuxDevices)) - for i, auxDevice := range sku.AuxDevices { - dbAuxDevice[i] = auxDevice.toDBModelServerSkuAuxDevice() - } - err = dbSku.AddSkuServerSkuAuxDevices(ctx, tx, true, dbAuxDevice...) - if err != nil { - return "", err - } - - // Disks - dbDisks := make([]*models.ServerSkuDisk, len(sku.Disks)) - for i, disk := range sku.Disks { - dbDisks[i] = disk.toDBModelServerSkuDisk() - } - err = dbSku.AddSkuServerSkuDisks(ctx, tx, true, dbDisks...) - if err != nil { - return "", err - } - - // Memory - dbMemory := make([]*models.ServerSkuMemory, len(sku.Memory)) - for i, memory := range sku.Memory { - dbMemory[i] = memory.toDBModelServerSkuMemory() - } - err = dbSku.AddSkuServerSkuMemories(ctx, tx, true, dbMemory...) - if err != nil { - return "", err - } - - // Nics - dbNics := make([]*models.ServerSkuNic, len(sku.Nics)) - for i, nic := range sku.Nics { - dbNics[i] = nic.toDBModelServerSkuNic() - } - err = dbSku.AddSkuServerSkuNics(ctx, tx, true, dbNics...) - if err != nil { - return "", err - } - - return dbSku.ID, tx.Commit() -} - -func (r *Router) updateServerSkuTransaction(ctx context.Context, sku *models.ServerSku, oldSku *models.ServerSku) (string, error) { - tx, err := r.DB.BeginTx(ctx, nil) - if err != nil { - return "", err - } - - defer loggedRollback(r, tx) - - sku.ID = oldSku.ID - - _, err = sku.Update(ctx, tx, boil.Infer()) - if err != nil { - return "", errors.Wrap(err, fmt.Sprintf("ID: %s", sku.ID)) - } - - err = r.updateServerSkuAuxDevices(ctx, tx, sku, oldSku) - if err != nil { - return "", err - } - - err = r.updateServerSkuDisks(ctx, tx, sku, oldSku) - if err != nil { - return "", err - } - - err = r.updateServerSkuMemories(ctx, tx, sku, oldSku) - if err != nil { - return "", err - } - - err = r.updateServerSkuNics(ctx, tx, sku, oldSku) - if err != nil { - return "", err - } - - return sku.ID, tx.Commit() -} - -func (r *Router) updateServerSkuAuxDevices(ctx context.Context, tx *sql.Tx, sku *models.ServerSku, oldSku *models.ServerSku) error { - var oldAuxDevices []*models.ServerSkuAuxDevice - var auxDevices []*models.ServerSkuAuxDevice - - if oldSku.R != nil { - oldAuxDevices = oldSku.R.SkuServerSkuAuxDevices - } - - if sku.R != nil { - auxDevices = sku.R.SkuServerSkuAuxDevices - } - - // Find aux devices no longer present and remove them - for _, oldAuxDevice := range oldAuxDevices { - auxDeviceFound := false - for i := range auxDevices { - if auxDevices[i].Vendor == oldAuxDevice.Vendor && - auxDevices[i].Model == oldAuxDevice.Model && - auxDevices[i].ID == "" { - auxDevices[i].ID = oldAuxDevice.ID - auxDeviceFound = true - break - } - } - - if !auxDeviceFound { - _, err := oldAuxDevice.Delete(ctx, tx) - if err != nil { - return err - } - } - } - - // Upsert aux devices - for _, auxDevice := range auxDevices { - var err error - if auxDevice.ID == "" { - err = auxDevice.Insert(ctx, tx, boil.Infer()) - } else { - _, err = auxDevice.Update(ctx, tx, boil.Infer()) - } - if err != nil { - return err - } - } - - return nil -} - -func (r *Router) updateServerSkuDisks(ctx context.Context, tx *sql.Tx, sku *models.ServerSku, oldSku *models.ServerSku) error { - var oldDisks []*models.ServerSkuDisk - var disks []*models.ServerSkuDisk - - if oldSku.R != nil { - oldDisks = oldSku.R.SkuServerSkuDisks - } - - if sku.R != nil { - disks = sku.R.SkuServerSkuDisks - } - - // Find disks no longer present and remove them - for _, oldDisk := range oldDisks { - diskFound := false - for i := range disks { - if disks[i].Vendor == oldDisk.Vendor && - disks[i].Model == oldDisk.Model && - disks[i].ID == "" { - disks[i].ID = oldDisk.ID - diskFound = true - break - } - } - - if !diskFound { - _, err := oldDisk.Delete(ctx, tx) - if err != nil { - return err - } - } - } - - // Upsert disks - for _, disk := range disks { - var err error - if disk.ID == "" { - err = disk.Insert(ctx, tx, boil.Infer()) - } else { - _, err = disk.Update(ctx, tx, boil.Infer()) - } - if err != nil { - return err - } - } - - return nil -} - -func (r *Router) updateServerSkuMemories(ctx context.Context, tx *sql.Tx, sku *models.ServerSku, oldSku *models.ServerSku) error { - var oldMemorys []*models.ServerSkuMemory - var memories []*models.ServerSkuMemory - - if oldSku.R != nil { - oldMemorys = oldSku.R.SkuServerSkuMemories - } - - if sku.R != nil { - memories = sku.R.SkuServerSkuMemories - } - - // Find memories no longer present and remove them - for _, oldMemory := range oldMemorys { - memoryFound := false - for i := range memories { - if memories[i].Vendor == oldMemory.Vendor && - memories[i].Model == oldMemory.Model && - memories[i].ID == "" { - memories[i].ID = oldMemory.ID - memoryFound = true - break - } - } - - if !memoryFound { - _, err := oldMemory.Delete(ctx, tx) - if err != nil { - return err - } - } - } - - // Upsert memories - for _, memory := range memories { - var err error - if memory.ID == "" { - err = memory.Insert(ctx, tx, boil.Infer()) - } else { - _, err = memory.Update(ctx, tx, boil.Infer()) - } - if err != nil { - return err - } - } - - return nil -} - -func (r *Router) updateServerSkuNics(ctx context.Context, tx *sql.Tx, sku *models.ServerSku, oldSku *models.ServerSku) error { - var oldNics []*models.ServerSkuNic - var nics []*models.ServerSkuNic - - if oldSku.R != nil { - oldNics = oldSku.R.SkuServerSkuNics - } - - if sku.R != nil { - nics = sku.R.SkuServerSkuNics - } - - // Find nics no longer present and remove them - for _, oldNic := range oldNics { - nicFound := false - for i := range nics { - if nics[i].Vendor == oldNic.Vendor && - nics[i].Model == oldNic.Model && - nics[i].ID == "" { - nics[i].ID = oldNic.ID - nicFound = true - break - } - } - - if !nicFound { - _, err := oldNic.Delete(ctx, tx) - if err != nil { - return err - } - } - } - - // Upsert nics - for _, nic := range nics { - var err error - if nic.ID == "" { - err = nic.Insert(ctx, tx, boil.Infer()) - } else { - _, err = nic.Update(ctx, tx, boil.Infer()) - } - if err != nil { - return err - } - } - - return nil -} diff --git a/pkg/api/v1/router_server_sku_test.go b/pkg/api/v1/router_server_sku_test.go deleted file mode 100644 index d2729960..00000000 --- a/pkg/api/v1/router_server_sku_test.go +++ /dev/null @@ -1,684 +0,0 @@ -package fleetdbapi_test - -import ( - "context" - "encoding/json" - "fmt" - "reflect" - "testing" - - "github.com/google/uuid" - "github.com/metal-toolbox/fleetdb/internal/dbtools" - "github.com/metal-toolbox/fleetdb/internal/models" - fleetdbapi "github.com/metal-toolbox/fleetdb/pkg/api/v1" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -func TestIntegrationServerSkuCreate(t *testing.T) { - s := serverTest(t) - - realClientTests(t, func(realClientTestCtx context.Context, authToken string, _ int, _ bool) error { - s.Client.SetToken(authToken) - - resp, err := s.Client.CreateServerSku(realClientTestCtx, ServerSkuTest) - if err != nil { - return err - } - - _, err = uuid.Parse(resp.Slug) - assert.NoError(t, err) - - return nil - }) - - var testCases = []struct { - testName string - Name string - Version string - expectedError bool - }{ - { - "server sku: create; success", - "DreamMachine2", - "Version 1 million", - false, - }, - { - "server sku: create; failure; invalide config", - "", - "", - true, - }, - { - "server sku: create; duplicate sku", - dbtools.FixtureServerSku.Name, - dbtools.FixtureServerSku.Version, - true, - }, - } - - for _, tc := range testCases { - t.Run(tc.testName, func(t *testing.T) { - ServerSkuTemp := ServerSkuTest - ServerSkuTemp.Name = tc.Name - ServerSkuTemp.Version = tc.Version - - resp, err := s.Client.CreateServerSku(context.TODO(), ServerSkuTemp) - - if tc.expectedError { - assert.Error(t, err) - assert.Nil(t, resp) - } else { - require.NoError(t, err) - require.NotNil(t, resp) - } - - }) - } -} - -func TestIntegrationServerSkuGet(t *testing.T) { - s := serverTest(t) - - realClientTests(t, func(realClientTestCtx context.Context, authToken string, _ int, _ bool) error { - s.Client.SetToken(authToken) - - parsedID, err := uuid.Parse(dbtools.FixtureServerSku.ID) - require.NoError(t, err) - - resp, err := s.Client.GetServerSku(realClientTestCtx, parsedID) - if err != nil { - return err - } - - require.NotNil(t, resp) - - assertEntireServerSkuModelEqual(t, - dbtools.FixtureServerSku, - dbtools.FixtureServerSkuAuxDevices, - dbtools.FixtureServerSkuDisks, - dbtools.FixtureServerSkuMemory, - dbtools.FixtureServerSkuNics, - resp.Record.(*fleetdbapi.ServerSku)) - - return nil - }) - - var testCases = []struct { - testName string - id string - expectedError bool - }{ - { - "server sku: get; success", - dbtools.FixtureServerSku.ID, - false, - }, - { - "server sku: get; unknown sku", - uuid.NewString(), - true, - }, - } - - for _, tc := range testCases { - t.Run(tc.testName, func(t *testing.T) { - id, err := uuid.Parse(tc.id) - require.NoError(t, err) - - resp, err := s.Client.GetServerSku(context.TODO(), id) - - if tc.expectedError { - assert.Error(t, err) - assert.Nil(t, resp) - } else { - assert.NoError(t, err) - assert.NotNil(t, resp) - - assertEntireServerSkuModelEqual(t, - dbtools.FixtureServerSku, - dbtools.FixtureServerSkuAuxDevices, - dbtools.FixtureServerSkuDisks, - dbtools.FixtureServerSkuMemory, - dbtools.FixtureServerSkuNics, - resp.Record.(*fleetdbapi.ServerSku)) - } - }) - } -} - -func TestIntegrationServerSkuUpdate(t *testing.T) { - s := serverTest(t) - - realClientTests(t, func(realClientTestCtx context.Context, authToken string, _ int, expectedError bool) error { - s.Client.SetToken(authToken) - - ServerSkuTemp := ServerSkuTest - var parsedID uuid.UUID - var err error - - if expectedError { - parsedID, err = uuid.NewUUID() - require.NoError(t, err) - } else { - ServerSkuTemp.Name = "Integration Test Server Sku Update" - ServerSkuTemp.Version = "Test Version" - resp, err := s.Client.CreateServerSku(realClientTestCtx, ServerSkuTemp) - require.NoError(t, err) - require.NotNil(t, resp) - - parsedID, err = uuid.Parse(resp.Slug) - require.NoError(t, err) - - resp, err = s.Client.GetServerSku(realClientTestCtx, parsedID) - require.NoError(t, err) - require.NotNil(t, resp) - - ServerSkuTemp = *resp.Record.(*fleetdbapi.ServerSku) - } - - ServerSkuTemp.Version = "Test Version 2" - ServerSkuTemp.AuxDevices[0].Vendor = "AMDX" - ServerSkuTemp.Disks[0].Bytes = 50 - ServerSkuTemp.Memory[0].Bytes = 50 - ServerSkuTemp.Nics[0].PortCount = 99 - _, err = s.Client.UpdateServerSku(realClientTestCtx, parsedID, ServerSkuTemp) - if err != nil { - return err - } - - if !expectedError { - resp, err := s.Client.GetServerSku(realClientTestCtx, parsedID) - require.NoError(t, err) - require.NotNil(t, resp) - - sku := *resp.Record.(*fleetdbapi.ServerSku) - - assertServerSkuEqual(t, &ServerSkuTemp, &sku) - } - - return nil - }) - - var testCases = []struct { - testName string - id string - expectedError bool - }{ - { - "server sku: update; success", - dbtools.FixtureServerSku.ID, - false, - }, - { - "server sku: update; invalid uuid", - uuid.NewString(), - true, - }, - } - - for _, tc := range testCases { - t.Run(tc.testName, func(t *testing.T) { - ServerSkuTemp := fleetdbapi.ServerSku{} - - parsedID, err := uuid.Parse(tc.id) - require.NoError(t, err) - - if !tc.expectedError { - resp, err := s.Client.GetServerSku(context.TODO(), parsedID) - require.NoError(t, err) - require.NotNil(t, resp) - - ServerSkuTemp = *resp.Record.(*fleetdbapi.ServerSku) - ServerSkuTemp.Version = "Test Version 2" - ServerSkuTemp.AuxDevices[0].Vendor = "AMDX" - ServerSkuTemp.Disks[0].Bytes = 50 - ServerSkuTemp.Memory[0].Bytes = 50 - ServerSkuTemp.Nics[0].PortCount = 99 - } - - resp, err := s.Client.UpdateServerSku(context.TODO(), parsedID, ServerSkuTemp) - - if tc.expectedError { - assert.Error(t, err) - assert.Nil(t, resp) - } else { - resp, err := s.Client.GetServerSku(context.TODO(), parsedID) - assert.NoError(t, err) - assert.NotNil(t, resp) - - sku := *resp.Record.(*fleetdbapi.ServerSku) - - assertServerSkuEqual(t, &ServerSkuTemp, &sku) - } - }) - } -} - -func TestIntegrationServerSkuDelete(t *testing.T) { - s := serverTest(t) - - realClientTests(t, func(realClientTestCtx context.Context, authToken string, _ int, expectedError bool) error { - s.Client.SetToken(authToken) - - ServerSkuTemp := ServerSkuTest - ServerSkuTemp.Name = "Integration Test Server Sku Delete" - ServerSkuTemp.Version = "Test Version" - resp, err := s.Client.CreateServerSku(realClientTestCtx, ServerSkuTemp) - if expectedError && err != nil { - return err - } - require.NoError(t, err) - require.NotNil(t, resp) - - parsedID, err := uuid.Parse(resp.Slug) - require.NoError(t, err) - - resp, err = s.Client.DeleteServerSku(realClientTestCtx, parsedID) - if err != nil { - return err - } - - assert.Equal(t, "1", resp.Slug) - - resp, err = s.Client.GetServerSku(realClientTestCtx, parsedID) - assert.Error(t, err) - assert.Nil(t, resp) - - return nil - }) - - var testCases = []struct { - testName string - expectedError bool - }{ - { - "server sku: delete; success", - false, - }, - { - "server sku: delete; invalide uuid", - true, - }, - } - - for _, tc := range testCases { - t.Run(tc.testName, func(t *testing.T) { - var parsedID uuid.UUID - var err error - - if tc.expectedError { - parsedID, err = uuid.NewUUID() - require.NoError(t, err) - } else { - ServerSkuTemp := ServerSkuTest - ServerSkuTemp.Name = "Integration Test Server Sku Delete" - ServerSkuTemp.Version = "Test Version" - resp, err := s.Client.CreateServerSku(context.TODO(), ServerSkuTemp) - require.NoError(t, err) - require.NotNil(t, resp) - - parsedID, err = uuid.Parse(resp.Slug) - require.NoError(t, err) - } - - resp, err := s.Client.DeleteServerSku(context.TODO(), parsedID) - if tc.expectedError { - assert.Error(t, err) - assert.Nil(t, resp) - } else { - assert.NoError(t, err) - assert.NotNil(t, resp) - - assert.Equal(t, "1", resp.Slug) - - resp, err = s.Client.GetServerSku(context.TODO(), parsedID) - assert.Error(t, err) - assert.Nil(t, resp) - } - }) - } -} - -func TestIntegrationServerSkuList(t *testing.T) { - s := serverTest(t) - - realClientTests(t, func(realClientTestCtx context.Context, authToken string, respCode int, expectedError bool) error { - s.Client.SetToken(authToken) - - params := fleetdbapi.ServerSkuListParams{ - Params: []fleetdbapi.ServerSkuQueryParams{ - { - Sku: fleetdbapi.ServerSkuQuery{ - Name: "DreamMachine", - }, - LogicalOperator: fleetdbapi.OperatorLogicalOR, - ComparitorOperator: fleetdbapi.OperatorComparitorEqual, - }, - }, - } - - _, err := s.Client.ListServerSku(realClientTestCtx, ¶ms) - if err != nil { - return err - } - - return nil - }) - - ServerSkuTempSetup := ServerSkuTest - - ServerSkuTempSetup.Name = "List Test 1" - resp, err := s.Client.CreateServerSku(context.TODO(), ServerSkuTempSetup) - require.NoError(t, err) - require.NotNil(t, resp) - - ServerSkuTempSetup.Name = "List Test 2" - resp, err = s.Client.CreateServerSku(context.TODO(), ServerSkuTempSetup) - require.NoError(t, err) - require.NotNil(t, resp) - - ServerSkuTempSetup.Name = "List Test 3" - for i := range ServerSkuTempSetup.Disks { // remove NVME - ServerSkuTempSetup.Disks[i].Protocol = "SATA" - ServerSkuTempSetup.Disks[i].Bytes = 10 - } - resp, err = s.Client.CreateServerSku(context.TODO(), ServerSkuTempSetup) - require.NoError(t, err) - require.NotNil(t, resp) - - // Get All 3 - paramTest0 := fleetdbapi.ServerSkuListParams{ - Params: []fleetdbapi.ServerSkuQueryParams{ - { - Sku: fleetdbapi.ServerSkuQuery{ - Name: "List Test", - }, - LogicalOperator: fleetdbapi.OperatorLogicalAND, - ComparitorOperator: fleetdbapi.OperatorComparitorLike, - }, - }, - } - - // Get all based on Disk Protocol - paramTest1 := fleetdbapi.ServerSkuListParams{ - Params: []fleetdbapi.ServerSkuQueryParams{ - { - Sku: fleetdbapi.ServerSkuQuery{ - Name: "List Test", - }, - LogicalOperator: fleetdbapi.OperatorLogicalAND, - ComparitorOperator: fleetdbapi.OperatorComparitorLike, - }, - { - Sku: fleetdbapi.ServerSkuQuery{ - Disks: []fleetdbapi.DiskQuery{ - { - Protocol: "NVME", - }, - }, - }, - LogicalOperator: fleetdbapi.OperatorLogicalAND, - ComparitorOperator: fleetdbapi.OperatorComparitorEqual, - }, - }, - } - - // Get all with a disk spaces less than 11 - paramTest2 := fleetdbapi.ServerSkuListParams{ - Params: []fleetdbapi.ServerSkuQueryParams{ - { - Sku: fleetdbapi.ServerSkuQuery{ - Name: "List Test", - }, - LogicalOperator: fleetdbapi.OperatorLogicalAND, - ComparitorOperator: fleetdbapi.OperatorComparitorLike, - }, - { - Sku: fleetdbapi.ServerSkuQuery{ - Disks: []fleetdbapi.DiskQuery{ - { - Bytes: []int64{11}, - }, - }, - }, - LogicalOperator: fleetdbapi.OperatorLogicalAND, - ComparitorOperator: fleetdbapi.OperatorComparitorLessThan, - }, - }, - } - - var testCases = []struct { - testName string - params fleetdbapi.ServerSkuListParams - expectedCount int - }{ - { - "server sku: list; get all three", - paramTest0, - 3, - }, - { - "server sku: list; get all based on disk protocol", - paramTest1, - 2, - }, - { - "server sku: list; get all based on disk space", - paramTest2, - 1, - }, - } - - for _, tc := range testCases { - t.Run(tc.testName, func(t *testing.T) { - resp, err := s.Client.ListServerSku(context.TODO(), &tc.params) - - require.NoError(t, err) - require.NotNil(t, resp) - - assert.Equal(t, tc.expectedCount, len(*resp.Records.(*[]fleetdbapi.ServerSku))) - }) - } -} - -func assertServerSkuEqual(t *testing.T, expected *fleetdbapi.ServerSku, actual *fleetdbapi.ServerSku) { - assert.Equal(t, expected.Name, actual.Name) - assert.Equal(t, expected.Version, actual.Version) - assert.Equal(t, expected.Vendor, actual.Vendor) - assert.Equal(t, expected.Chassis, actual.Chassis) - assert.Equal(t, expected.BMCModel, actual.BMCModel) - assert.Equal(t, expected.MotherboardModel, actual.MotherboardModel) - assert.Equal(t, expected.CPUVendor, actual.CPUVendor) - assert.Equal(t, expected.CPUModel, actual.CPUModel) - assert.Equal(t, expected.CPUCores, actual.CPUCores) - assert.Equal(t, expected.CPUHertz, actual.CPUHertz) - assert.Equal(t, expected.CPUCount, actual.CPUCount) - assert.ElementsMatch(t, expected.AuxDevices, actual.AuxDevices) - assert.ElementsMatch(t, expected.Disks, actual.Disks) - assert.ElementsMatch(t, expected.Memory, actual.Memory) - assert.ElementsMatch(t, expected.Nics, actual.Nics) -} - -func assertEntireServerSkuModelEqual(t *testing.T, - expectedServerSku *models.ServerSku, - expectedAuxDevices []*models.ServerSkuAuxDevice, - expectedDisks []*models.ServerSkuDisk, - expectedMemories []*models.ServerSkuMemory, - expectedNics []*models.ServerSkuNic, - actual *fleetdbapi.ServerSku, -) { - assertServerSkuModelEqual(t, expectedServerSku, actual) - - require.Equal(t, len(expectedAuxDevices), len(actual.AuxDevices)) - require.Equal(t, len(expectedDisks), len(actual.Disks)) - require.Equal(t, len(expectedMemories), len(actual.Memory)) - require.Equal(t, len(expectedNics), len(actual.Nics)) - - for _, expectedAuxDevice := range expectedAuxDevices { - foundAuxDevice := false - - for _, actualAuxDevice := range actual.AuxDevices { - if checkAuxDeviceModelEqual(t, expectedAuxDevice, &actualAuxDevice) { - assertServerSkuAuxDeviceModelEqual(t, expectedAuxDevice, &actualAuxDevice) - - foundAuxDevice = true - break - } - } - - if !foundAuxDevice { - assert.Fail(t, fmt.Sprintf("expected to find disk: `%+v` in list: %+v", expectedAuxDevice, actual.AuxDevices)) - } - } - - for _, expectedDisk := range expectedDisks { - foundDisk := false - - for _, actualDisk := range actual.Disks { - if checkDiskModelEqual(expectedDisk, &actualDisk) { - assertServerSkuDiskModelEqual(t, expectedDisk, &actualDisk) - - foundDisk = true - break - } - } - - if !foundDisk { - assert.Fail(t, fmt.Sprintf("expected to find disk: `%+v` in list: %+v", expectedDisk, actual.Disks)) - } - } - - for _, expectedMemory := range expectedMemories { - foundMemory := false - - for _, actualMemory := range actual.Memory { - if checkMemoryModelEqual(expectedMemory, &actualMemory) { - assertServerSkuMemoryModelEqual(t, expectedMemory, &actualMemory) - - foundMemory = true - break - } - } - - if !foundMemory { - assert.Fail(t, fmt.Sprintf("expected to find memory: `%+v` in list: %+v", expectedMemory, actual.Memory)) - } - } - - for _, expectedNic := range expectedNics { - foundNic := false - - for _, actualNic := range actual.Nics { - if checkNicModelEqual(expectedNic, &actualNic) { - assertServerSkuNicModelEqual(t, expectedNic, &actualNic) - - foundNic = true - break - } - } - - if !foundNic { - assert.Fail(t, fmt.Sprintf("expected to find nic: `%+v` in list: %+v", expectedNic, actual.Nics)) - } - } -} - -func assertServerSkuModelEqual(t *testing.T, - expected *models.ServerSku, - actual *fleetdbapi.ServerSku, -) { - assert.Equal(t, expected.Name, actual.Name) - assert.Equal(t, expected.Version, actual.Version) - assert.Equal(t, expected.Chassis, actual.Chassis) - assert.Equal(t, expected.BMCModel, actual.BMCModel) - assert.Equal(t, expected.MotherboardModel, actual.MotherboardModel) - assert.Equal(t, expected.CPUVendor, actual.CPUVendor) - assert.Equal(t, expected.CPUModel, actual.CPUModel) - assert.Equal(t, expected.CPUHertz, actual.CPUHertz) - assert.Equal(t, expected.CPUCount, actual.CPUCount) -} - -func assertServerSkuAuxDeviceModelEqual(t *testing.T, - expected *models.ServerSkuAuxDevice, - actual *fleetdbapi.AuxDevice, -) { - assert.Equal(t, expected.Vendor, actual.Vendor) - assert.Equal(t, expected.Model, actual.Model) - assert.Equal(t, expected.DeviceType, actual.DeviceType) - assert.JSONEq(t, string(expected.Details), string(actual.Details)) -} - -func assertServerSkuDiskModelEqual(t *testing.T, - expected *models.ServerSkuDisk, - actual *fleetdbapi.Disk, -) { - assert.Equal(t, expected.Vendor, actual.Vendor) - assert.Equal(t, expected.Model, actual.Model) - assert.Equal(t, expected.Bytes, actual.Bytes) - assert.Equal(t, expected.Protocol, actual.Protocol) - assert.Equal(t, expected.Count, actual.Count) -} - -func assertServerSkuMemoryModelEqual(t *testing.T, - expected *models.ServerSkuMemory, - actual *fleetdbapi.Memory, -) { - assert.Equal(t, expected.Vendor, actual.Vendor) - assert.Equal(t, expected.Model, actual.Model) - assert.Equal(t, expected.Bytes, actual.Bytes) - assert.Equal(t, expected.Count, actual.Count) -} - -func assertServerSkuNicModelEqual(t *testing.T, - expected *models.ServerSkuNic, - actual *fleetdbapi.Nic, -) { - assert.Equal(t, expected.Vendor, actual.Vendor) - assert.Equal(t, expected.Model, actual.Model) - assert.Equal(t, expected.PortBandwidth, actual.PortBandwidth) - assert.Equal(t, expected.PortCount, actual.PortCount) - assert.Equal(t, expected.Count, actual.Count) -} - -func checkAuxDeviceModelEqual(t *testing.T, expected *models.ServerSkuAuxDevice, actual *fleetdbapi.AuxDevice) bool { - j1, j2 := map[string]interface{}{}, map[string]interface{}{} - - err := json.Unmarshal(expected.Details, &j1) - require.NoError(t, err) - - err = json.Unmarshal(actual.Details, &j2) - require.NoError(t, err) - - if !reflect.DeepEqual(j2, j1) { - return false - } - - return expected.Vendor == actual.Vendor && - expected.Model == actual.Model && - expected.DeviceType == actual.DeviceType -} - -func checkDiskModelEqual(expected *models.ServerSkuDisk, actual *fleetdbapi.Disk) bool { - return expected.Vendor == actual.Vendor && - expected.Model == actual.Model && - expected.Bytes == actual.Bytes && - expected.Protocol == actual.Protocol && - expected.Count == actual.Count -} - -func checkMemoryModelEqual(expected *models.ServerSkuMemory, actual *fleetdbapi.Memory) bool { - return expected.Vendor == actual.Vendor && - expected.Model == actual.Model && - expected.Bytes == actual.Bytes && - expected.Count == actual.Count -} - -func checkNicModelEqual(expected *models.ServerSkuNic, actual *fleetdbapi.Nic) bool { - return expected.Vendor == actual.Vendor && - expected.Model == actual.Model && - expected.PortBandwidth == actual.PortBandwidth && - expected.PortCount == actual.PortCount && - expected.Count == actual.Count -} diff --git a/pkg/api/v1/server_list_params.go b/pkg/api/v1/server_list_params.go index c7d602f9..a8fc0e18 100644 --- a/pkg/api/v1/server_list_params.go +++ b/pkg/api/v1/server_list_params.go @@ -21,7 +21,6 @@ type ServerListParams struct { PaginationParams *PaginationParams } -// setQuery implements the queryParams interface func (p *ServerListParams) setQuery(q url.Values) { if p == nil { return diff --git a/pkg/api/v1/server_service.go b/pkg/api/v1/server_service.go index 0695981c..78ecf4db 100644 --- a/pkg/api/v1/server_service.go +++ b/pkg/api/v1/server_service.go @@ -20,7 +20,6 @@ const ( serverCredentialTypeEndpoint = "server-credential-types" serverComponentFirmwareSetsEndpoint = "server-component-firmware-sets" serverBiosConfigSetEndpoint = "server-bios-config-sets" - serverSkuEndpoint = "server-skus" bomInfoEndpoint = "bill-of-materials" uploadFileEndpoint = "batch-upload" bomByMacAOCAddressEndpoint = "aoc-mac-address" @@ -84,14 +83,8 @@ type ClientInterface interface { CreateServerBiosConfigSet(context.Context, BiosConfigSet) (*uuid.UUID, *ServerResponse, error) GetServerBiosConfigSet(context.Context, uuid.UUID) (*BiosConfigSet, *ServerResponse, error) DeleteServerBiosConfigSet(context.Context, uuid.UUID) (*ServerResponse, error) - ListServerBiosConfigSet(context.Context, *BiosConfigSetListParams) (*ServerResponse, error) + ListServerBiosConfigSet(context.Context) (*ServerResponse, error) UpdateServerBiosConfigSet(context.Context, uuid.UUID, BiosConfigSet) (*ServerResponse, error) - - CreateServerSku(context.Context, ServerSku) (*uuid.UUID, *ServerResponse, error) - GetServerSku(context.Context, uuid.UUID) (*ServerResponse, error) - UpdateServerSku(context.Context, uuid.UUID, ServerSku) (*ServerResponse, error) - DeleteServerSku(context.Context, uuid.UUID) (*ServerResponse, error) - ListServerSkus(context.Context, *ServerSkuListParams) (*ServerResponse, error) } // Create will attempt to create a server in Hollow and return the new server's UUID @@ -586,63 +579,3 @@ func (c *Client) UpdateServerBiosConfigSet(ctx context.Context, id uuid.UUID, se return resp, nil } - -// CreateServerSku will store the ServerSku, and return the generated UUID of the ServerSku -func (c *Client) CreateServerSku(ctx context.Context, sku ServerSku) (*ServerResponse, error) { - resp, err := c.post(ctx, serverSkuEndpoint, sku) - if err != nil { - return nil, err - } - - return resp, nil -} - -// GetServerSku will retrieve the ServerSku referred to by the given ID if found -func (c *Client) GetServerSku(ctx context.Context, id uuid.UUID) (*ServerResponse, error) { - path := fmt.Sprintf("%s/%s", serverSkuEndpoint, id) - cfg := &ServerSku{} - resp := ServerResponse{Record: cfg} - - if err := c.get(ctx, path, &resp); err != nil { - return nil, err - } - - return &resp, nil -} - -// UpdateServerSku will update a config set. -// Note: Empty IDs are assumed new items to add. Items not present are assumed to be deleted. -func (c *Client) UpdateServerSku(ctx context.Context, id uuid.UUID, set ServerSku) (*ServerResponse, error) { - path := fmt.Sprintf("%s/%s", serverSkuEndpoint, id) - resp, err := c.put(ctx, path, set) - if err != nil { - return nil, err - } - - return resp, nil -} - -// DeleteServerSku will delete the ServerSku referred to by the given ID if found -func (c *Client) DeleteServerSku(ctx context.Context, id uuid.UUID) (*ServerResponse, error) { - path := fmt.Sprintf("%s/%s", serverSkuEndpoint, id) - - resp, err := c.delete(ctx, path) - if err != nil { - return nil, err - } - - return resp, nil -} - -// ListServerSku will return a list of ServerSku referred to by the given More details about querying at the type definition of ServerSkuListParams. -func (c *Client) ListServerSku(ctx context.Context, params *ServerSkuListParams) (*ServerResponse, error) { - cfg := &[]ServerSku{} - resp := ServerResponse{Records: cfg} - - err := c.list(ctx, serverSkuEndpoint, params, &resp) - if err != nil { - return nil, err - } - - return &resp, nil -} diff --git a/pkg/api/v1/server_sku.go b/pkg/api/v1/server_sku.go deleted file mode 100644 index fa5b20e3..00000000 --- a/pkg/api/v1/server_sku.go +++ /dev/null @@ -1,123 +0,0 @@ -package fleetdbapi - -import ( - "github.com/metal-toolbox/fleetdb/internal/models" -) - -// ServerSku represents a SKU for a Server -type ServerSku struct { - Name string `json:"name" binding:"required"` - Version string `json:"version" binding:"required"` - Vendor string `json:"vendor" binding:"required"` - Chassis string `json:"chassis" binding:"required"` - BMCModel string `json:"bmc_model" binding:"required"` - MotherboardModel string `json:"motherboard_model" binding:"required"` - CPUVendor string `json:"cpu_vendor" binding:"required"` - CPUModel string `json:"cpu_model" binding:"required"` - CPUCores int64 `json:"cpu_cores" binding:"required"` - CPUHertz int64 `json:"cpu_hertz" binding:"required"` - CPUCount int64 `json:"cpu_count" binding:"required"` - AuxDevices []AuxDevice `json:"aux_devices" binding:"required"` - Disks []Disk `json:"disks" binding:"required"` - Memory []Memory `json:"memory" binding:"required"` - Nics []Nic `json:"nics" binding:"required"` -} - -// toDBModelServerSku converts a ServerSku into a models.ServerSku -func (sku *ServerSku) toDBModelServerSku() *models.ServerSku { - model := &models.ServerSku{ - Name: sku.Name, - Version: sku.Version, - Vendor: sku.Vendor, - Chassis: sku.Chassis, - BMCModel: sku.BMCModel, - MotherboardModel: sku.MotherboardModel, - CPUVendor: sku.CPUVendor, - CPUModel: sku.CPUModel, - CPUCores: sku.CPUCores, - CPUHertz: sku.CPUHertz, - CPUCount: sku.CPUCount, - } - - return model -} - -// toDBModelServerSkuDeep converts a ServerSku into a models.ServerSku. It also includes all relations, doing a deep copy -func (sku *ServerSku) toDBModelServerSkuDeep(id string) *models.ServerSku { - dbSku := sku.toDBModelServerSku() - - if len(sku.AuxDevices) > 0 || len(sku.Disks) > 0 || len(sku.Memory) > 0 || len(sku.Nics) > 0 { - dbSku.R = dbSku.R.NewStruct() - - for i := range sku.AuxDevices { - dbSku.R.SkuServerSkuAuxDevices = append(dbSku.R.SkuServerSkuAuxDevices, sku.AuxDevices[i].toDBModelServerSkuAuxDevice()) - dbSku.R.SkuServerSkuAuxDevices[i].SkuID = id - } - - for i := range sku.Disks { - dbSku.R.SkuServerSkuDisks = append(dbSku.R.SkuServerSkuDisks, sku.Disks[i].toDBModelServerSkuDisk()) - dbSku.R.SkuServerSkuDisks[i].SkuID = id - } - - for i := range sku.Memory { - dbSku.R.SkuServerSkuMemories = append(dbSku.R.SkuServerSkuMemories, sku.Memory[i].toDBModelServerSkuMemory()) - dbSku.R.SkuServerSkuMemories[i].SkuID = id - } - - for i := range sku.Nics { - dbSku.R.SkuServerSkuNics = append(dbSku.R.SkuServerSkuNics, sku.Nics[i].toDBModelServerSkuNic()) - dbSku.R.SkuServerSkuNics[i].SkuID = id - } - } - - return dbSku -} - -// fromDBModelServerSku converts a models.ServerSku into a ServerSku -func (sku *ServerSku) fromDBModelServerSku(model *models.ServerSku) { - sku.Name = model.Name - sku.Version = model.Version - sku.Vendor = model.Vendor - sku.Chassis = model.Chassis - sku.BMCModel = model.BMCModel - sku.MotherboardModel = model.MotherboardModel - sku.CPUVendor = model.CPUVendor - sku.CPUModel = model.CPUModel - sku.CPUCores = model.CPUCores - sku.CPUHertz = model.CPUHertz - sku.CPUCount = model.CPUCount - - if model.R != nil { - diskCount := len(model.R.SkuServerSkuDisks) - if diskCount > 0 { - sku.Disks = make([]Disk, diskCount) - for i, disk := range model.R.SkuServerSkuDisks { - sku.Disks[i].fromDBModelServerSkuDisk(disk) - } - } - - memoryCount := len(model.R.SkuServerSkuMemories) - if memoryCount > 0 { - sku.Memory = make([]Memory, memoryCount) - for i, memory := range model.R.SkuServerSkuMemories { - sku.Memory[i].fromDBModelServerSkuMemory(memory) - } - } - - nicCount := len(model.R.SkuServerSkuNics) - if nicCount > 0 { - sku.Nics = make([]Nic, nicCount) - for i, nic := range model.R.SkuServerSkuNics { - sku.Nics[i].fromDBModelServerSkuNic(nic) - } - } - - auxDeviceCount := len(model.R.SkuServerSkuAuxDevices) - if auxDeviceCount > 0 { - sku.AuxDevices = make([]AuxDevice, auxDeviceCount) - for i, auxDevice := range model.R.SkuServerSkuAuxDevices { - sku.AuxDevices[i].fromDBModelServerSkuAuxDevice(auxDevice) - } - } - } -} diff --git a/pkg/api/v1/server_sku_aux_device.go b/pkg/api/v1/server_sku_aux_device.go deleted file mode 100644 index 07fc9175..00000000 --- a/pkg/api/v1/server_sku_aux_device.go +++ /dev/null @@ -1,33 +0,0 @@ -package fleetdbapi - -import ( - "github.com/metal-toolbox/fleetdb/internal/models" -) - -// AuxDevice represents a Sku Aux Device Layout for a Server -type AuxDevice struct { - Vendor string `json:"vendor" binding:"required"` - Model string `json:"model" binding:"required"` - DeviceType string `json:"device_type" binding:"required"` - Details []byte `json:"details" binding:"required"` -} - -// toDBModelServerSkuAuxDevice converts a AuxDevice struct into a models.ServerSkuAuxDevice -func (aux *AuxDevice) toDBModelServerSkuAuxDevice() *models.ServerSkuAuxDevice { - model := &models.ServerSkuAuxDevice{ - Vendor: aux.Vendor, - Model: aux.Model, - DeviceType: aux.DeviceType, - Details: aux.Details, - } - - return model -} - -// fomDBModelServerSkuAuxDevice converts a models.ServerSkuAuxDevice into a AuxDevice struct -func (aux *AuxDevice) fromDBModelServerSkuAuxDevice(model *models.ServerSkuAuxDevice) { - aux.Vendor = model.Vendor - aux.Model = model.Model - aux.DeviceType = model.DeviceType - aux.Details = model.Details -} diff --git a/pkg/api/v1/server_sku_aux_device_params.go b/pkg/api/v1/server_sku_aux_device_params.go deleted file mode 100644 index 4740063c..00000000 --- a/pkg/api/v1/server_sku_aux_device_params.go +++ /dev/null @@ -1,25 +0,0 @@ -package fleetdbapi - -import ( - "github.com/volatiletech/sqlboiler/v4/queries/qm" - - "github.com/metal-toolbox/fleetdb/internal/models" -) - -// AuxDeviceQuery defines values you can query Aux Devices with. Empty strings are ignored. -type AuxDeviceQuery struct { - Vendor string `query:"vendor"` - Model string `query:"model"` - DeviceType string `query:"device_type"` -} - -// queryMods converts the list params into sql conditions that can be added to sql queries -func (ssku *AuxDeviceQuery) queryMods(comparitor OperatorComparitorType) []qm.QueryMod { - mods := []qm.QueryMod{} - - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuAuxDeviceTableColumns.Vendor, ssku.Vendor) - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuAuxDeviceTableColumns.Model, ssku.Model) - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuAuxDeviceTableColumns.DeviceType, ssku.DeviceType) - - return mods -} diff --git a/pkg/api/v1/server_sku_disk.go b/pkg/api/v1/server_sku_disk.go deleted file mode 100644 index c1a5d79c..00000000 --- a/pkg/api/v1/server_sku_disk.go +++ /dev/null @@ -1,36 +0,0 @@ -package fleetdbapi - -import ( - "github.com/metal-toolbox/fleetdb/internal/models" -) - -// Disk represents a Sku Disk Layout for a Server -type Disk struct { - Vendor string `json:"vendor" binding:"required"` - Model string `json:"model" binding:"required"` - Bytes int64 `json:"bytes" binding:"required"` - Protocol string `json:"protocol" binding:"required"` - Count int64 `json:"count" binding:"required"` -} - -// toDBModelServerSkuDisk converts a Disk struct into a models.ServerSkuDisk -func (disk *Disk) toDBModelServerSkuDisk() *models.ServerSkuDisk { - model := &models.ServerSkuDisk{ - Vendor: disk.Vendor, - Model: disk.Model, - Bytes: disk.Bytes, - Protocol: disk.Protocol, - Count: disk.Count, - } - - return model -} - -// fromDBModelServerSkuDisk converts a models.ServerSkuDisk into a Disk struct -func (disk *Disk) fromDBModelServerSkuDisk(model *models.ServerSkuDisk) { - disk.Vendor = model.Vendor - disk.Model = model.Model - disk.Bytes = model.Bytes - disk.Protocol = model.Protocol - disk.Count = model.Count -} diff --git a/pkg/api/v1/server_sku_disk_params.go b/pkg/api/v1/server_sku_disk_params.go deleted file mode 100644 index 7b4ee4f4..00000000 --- a/pkg/api/v1/server_sku_disk_params.go +++ /dev/null @@ -1,29 +0,0 @@ -package fleetdbapi - -import ( - "github.com/volatiletech/sqlboiler/v4/queries/qm" - - "github.com/metal-toolbox/fleetdb/internal/models" -) - -// DiskQuery defines values you can query Disks with. Empty strings are ignored. -type DiskQuery struct { - Vendor string `query:"vendor"` - Model string `query:"model"` - Bytes []int64 `query:"bytes"` - Protocol string `query:"protocol"` - Count []int64 `query:"count"` -} - -// queryMods converts the list params into sql conditions that can be added to sql queries -func (ssku *DiskQuery) queryMods(comparitor OperatorComparitorType) []qm.QueryMod { - mods := []qm.QueryMod{} - - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuDiskTableColumns.Vendor, ssku.Vendor) - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuDiskTableColumns.Model, ssku.Model) - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuDiskTableColumns.Bytes, ssku.Bytes) - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuDiskTableColumns.Protocol, ssku.Protocol) - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuDiskTableColumns.Count, ssku.Count) - - return mods -} diff --git a/pkg/api/v1/server_sku_memory.go b/pkg/api/v1/server_sku_memory.go deleted file mode 100644 index f75c2cb9..00000000 --- a/pkg/api/v1/server_sku_memory.go +++ /dev/null @@ -1,33 +0,0 @@ -package fleetdbapi - -import ( - "github.com/metal-toolbox/fleetdb/internal/models" -) - -// Memory represents a Sku Memory Layout for a Server -type Memory struct { - Vendor string `json:"vendor" binding:"required"` - Model string `json:"model" binding:"required"` - Bytes int64 `json:"bytes" binding:"required"` - Count int64 `json:"count" binding:"required"` -} - -// toDBModelServerSkuMemory converts a Memory struct into a models.ServerSkuMemory -func (mem *Memory) toDBModelServerSkuMemory() *models.ServerSkuMemory { - model := &models.ServerSkuMemory{ - Vendor: mem.Vendor, - Model: mem.Model, - Bytes: mem.Bytes, - Count: mem.Count, - } - - return model -} - -// fromDBModelServerSkuMemory converts a models.ServerSkuMemory into a Memory struct -func (mem *Memory) fromDBModelServerSkuMemory(model *models.ServerSkuMemory) { - mem.Vendor = model.Vendor - mem.Model = model.Model - mem.Bytes = model.Bytes - mem.Count = model.Count -} diff --git a/pkg/api/v1/server_sku_memory_params.go b/pkg/api/v1/server_sku_memory_params.go deleted file mode 100644 index 5932d146..00000000 --- a/pkg/api/v1/server_sku_memory_params.go +++ /dev/null @@ -1,27 +0,0 @@ -package fleetdbapi - -import ( - "github.com/volatiletech/sqlboiler/v4/queries/qm" - - "github.com/metal-toolbox/fleetdb/internal/models" -) - -// MemoryQuery defines values you can query Memories with. Empty strings are ignored. -type MemoryQuery struct { - Vendor string `query:"vendor"` - Model string `query:"model"` - Bytes []int64 `query:"bytes"` - Count []int64 `query:"count"` -} - -// queryMods converts the list params into sql conditions that can be added to sql queries -func (ssku *MemoryQuery) queryMods(comparitor OperatorComparitorType) []qm.QueryMod { - mods := []qm.QueryMod{} - - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuMemoryTableColumns.Vendor, ssku.Vendor) - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuMemoryTableColumns.Model, ssku.Model) - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuMemoryTableColumns.Bytes, ssku.Bytes) - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuMemoryTableColumns.Count, ssku.Count) - - return mods -} diff --git a/pkg/api/v1/server_sku_nic.go b/pkg/api/v1/server_sku_nic.go deleted file mode 100644 index bf5218d0..00000000 --- a/pkg/api/v1/server_sku_nic.go +++ /dev/null @@ -1,36 +0,0 @@ -package fleetdbapi - -import ( - "github.com/metal-toolbox/fleetdb/internal/models" -) - -// Nic represents a Sku Nic Layout for a Server -type Nic struct { - Vendor string `json:"vendor" binding:"required"` - Model string `json:"model" binding:"required"` - PortBandwidth int64 `json:"port_bandwidth" binding:"required"` - PortCount int64 `json:"port_count" binding:"required"` - Count int64 `json:"count" binding:"required"` -} - -// toDBModelServerSkuNic converts a Nic struct into a models.ServerSkuNic -func (nic *Nic) toDBModelServerSkuNic() *models.ServerSkuNic { - model := &models.ServerSkuNic{ - Vendor: nic.Vendor, - Model: nic.Model, - PortBandwidth: nic.PortBandwidth, - PortCount: nic.PortCount, - Count: nic.Count, - } - - return model -} - -// fromDBModelServerSkuNic converts a models.ServerSkuNic into a Nic struct -func (nic *Nic) fromDBModelServerSkuNic(model *models.ServerSkuNic) { - nic.Vendor = model.Vendor - nic.Model = model.Model - nic.PortBandwidth = model.PortBandwidth - nic.PortCount = model.PortCount - nic.Count = model.Count -} diff --git a/pkg/api/v1/server_sku_nic_params.go b/pkg/api/v1/server_sku_nic_params.go deleted file mode 100644 index 2dd83d44..00000000 --- a/pkg/api/v1/server_sku_nic_params.go +++ /dev/null @@ -1,29 +0,0 @@ -package fleetdbapi - -import ( - "github.com/volatiletech/sqlboiler/v4/queries/qm" - - "github.com/metal-toolbox/fleetdb/internal/models" -) - -// NicQuery defines values you can query Nic structs with. Empty strings are ignored. -type NicQuery struct { - Vendor string `query:"vendor"` - Model string `query:"model"` - PortBandwidth []int64 `query:"port_bandwidth"` - PortCount []int64 `query:"port_count"` - Count []int64 `query:"count"` -} - -// queryMods converts the list params into sql conditions that can be added to sql queries -func (ssku *NicQuery) queryMods(comparitor OperatorComparitorType) []qm.QueryMod { - mods := []qm.QueryMod{} - - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuNicTableColumns.Vendor, ssku.Vendor) - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuNicTableColumns.Model, ssku.Model) - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuNicTableColumns.PortBandwidth, ssku.PortBandwidth) - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuNicTableColumns.PortCount, ssku.PortCount) - mods = appendOperatorQueryMod(mods, comparitor, models.ServerSkuNicTableColumns.Count, ssku.Count) - - return mods -} diff --git a/pkg/api/v1/server_sku_params.go b/pkg/api/v1/server_sku_params.go deleted file mode 100644 index a138b6c7..00000000 --- a/pkg/api/v1/server_sku_params.go +++ /dev/null @@ -1,195 +0,0 @@ -package fleetdbapi - -import ( - "fmt" - "net/url" - "reflect" - - "github.com/gin-gonic/gin" - "github.com/hetiansu5/urlquery" - "github.com/volatiletech/sqlboiler/v4/queries/qm" - - "github.com/metal-toolbox/fleetdb/internal/models" -) - -// ServerSkuQuery defines values you can query ServerSkus with. Empty strings are ignored. Empty Arrays are ignored. -type ServerSkuQuery struct { - Name string `query:"name"` - Version string `query:"version"` - Vendor string `query:"vendor"` - Chassis string `query:"chassis"` - BMCModel string `query:"bmc_model"` - MotherboardModel string `query:"motherboard_model"` - CPUVendor string `query:"cpu_vendor"` - CPUModel string `query:"cpu_model"` - CPUCores []int64 `query:"cpu_cores"` - CPUHertz []int64 `query:"cpu_hertz"` - CPUCount []int64 `query:"cpu_count"` - AuxDevices []AuxDeviceQuery `query:"aux_devices"` - Disks []DiskQuery `query:"disks"` - Memory []MemoryQuery `query:"memory"` - Nics []NicQuery `query:"nics"` -} - -// ServerSkuQueryParams defines a ServerSkuQuery struct and operators you can use to query ServerSkus with. If LogicalOperator is an empty string, it will default to OperatorLogicalAND. If ComparitorOperator is an empty string, it will default to OperatorComparitorEqual -type ServerSkuQueryParams struct { - Sku ServerSkuQuery `query:"sku"` - LogicalOperator OperatorLogicalType `query:"logical"` - ComparitorOperator OperatorComparitorType `query:"comparitor"` -} - -// ServerSkuListParams params is an array of potential expressions when querying. -// Each one will have a Sku. This Sku will define values you want to search on, empty strings will be ignored, empty arrays will be ignored. -// The ComparitorOperator will define how you want to compare those values. -// All values within a single ServerSkuQueryParams item will be grouped together and "AND"'ed. -// The LogicalOperator will define how that ServerSkuQueryParams item will be grouped with other ServerSkuQueryParams items. -// Note: You must set PaginationParams.Preload to load AuxDevices, Disks, Memory, and Nics. -type ServerSkuListParams struct { - Params []ServerSkuQueryParams `query:"params"` - Pagination PaginationParams `query:"page"` -} - -// setQuery implements the queryParams interface -func (p *ServerSkuListParams) setQuery(q url.Values) { - if p == nil { - return - } - - encoder := urlquery.NewEncoder() - encoder.RegisterEncodeFunc(reflect.String, OperatorURLQueryEncoder) - - bytes, err := encoder.Marshal(p) - if err != nil { - q.Set("error", err.Error()) - } else { - newValues, err := url.ParseQuery(string(bytes)) - if err != nil { - q.Set("error", err.Error()) - } else { - for key, values := range newValues { - for _, value := range values { - q.Add(key, value) - } - } - } - } -} - -// parseServerSkuListParams converts the queryURL to a ServerSkuListParams object -func parseServerSkuListParams(c *gin.Context) (*ServerSkuListParams, error) { - params := ServerSkuListParams{} - bytes := c.Request.URL.RawQuery - - parser := urlquery.NewParser() - parser.RegisterDecodeFunc(reflect.String, OperatorURLQueryDecoder) - - err := parser.Unmarshal([]byte(bytes), ¶ms) - if err != nil { - return nil, err - } - - return ¶ms, nil -} - -// queryMods converts the list params into sql conditions that can be added to sql queries -func (p *ServerSkuListParams) queryMods() []qm.QueryMod { - mods := []qm.QueryMod{qm.Distinct(fmt.Sprintf("\"%s\".*", models.TableNames.ServerSku))} - - // Only INNER JOIN if we have query params for it - haveAuxDevice := false - haveDisk := false - haveMemory := false - haveNic := false - - for i := range p.Params { - whereMods := []qm.QueryMod{} - - whereMods = appendOperatorQueryMod(whereMods, p.Params[i].ComparitorOperator, models.ServerSkuTableColumns.Name, p.Params[i].Sku.Name) - whereMods = appendOperatorQueryMod(whereMods, p.Params[i].ComparitorOperator, models.ServerSkuTableColumns.Version, p.Params[i].Sku.Version) - whereMods = appendOperatorQueryMod(whereMods, p.Params[i].ComparitorOperator, models.ServerSkuTableColumns.Vendor, p.Params[i].Sku.Vendor) - whereMods = appendOperatorQueryMod(whereMods, p.Params[i].ComparitorOperator, models.ServerSkuTableColumns.Chassis, p.Params[i].Sku.Chassis) - whereMods = appendOperatorQueryMod(whereMods, p.Params[i].ComparitorOperator, models.ServerSkuTableColumns.BMCModel, p.Params[i].Sku.BMCModel) - whereMods = appendOperatorQueryMod(whereMods, p.Params[i].ComparitorOperator, models.ServerSkuTableColumns.MotherboardModel, p.Params[i].Sku.MotherboardModel) - whereMods = appendOperatorQueryMod(whereMods, p.Params[i].ComparitorOperator, models.ServerSkuTableColumns.CPUVendor, p.Params[i].Sku.CPUVendor) - whereMods = appendOperatorQueryMod(whereMods, p.Params[i].ComparitorOperator, models.ServerSkuTableColumns.CPUModel, p.Params[i].Sku.CPUModel) - whereMods = appendOperatorQueryMod(whereMods, p.Params[i].ComparitorOperator, models.ServerSkuTableColumns.CPUCores, p.Params[i].Sku.CPUCores) - whereMods = appendOperatorQueryMod(whereMods, p.Params[i].ComparitorOperator, models.ServerSkuTableColumns.CPUHertz, p.Params[i].Sku.CPUHertz) - whereMods = appendOperatorQueryMod(whereMods, p.Params[i].ComparitorOperator, models.ServerSkuTableColumns.CPUCount, p.Params[i].Sku.CPUCount) - - for j := range p.Params[i].Sku.AuxDevices { - haveAuxDevice = true - - whereMods = append(whereMods, p.Params[i].Sku.AuxDevices[j].queryMods(p.Params[i].ComparitorOperator)...) - } - - for j := range p.Params[i].Sku.Disks { - haveDisk = true - - whereMods = append(whereMods, p.Params[i].Sku.Disks[j].queryMods(p.Params[i].ComparitorOperator)...) - } - - for j := range p.Params[i].Sku.Memory { - haveMemory = true - - whereMods = append(whereMods, p.Params[i].Sku.Memory[j].queryMods(p.Params[i].ComparitorOperator)...) - } - - for j := range p.Params[i].Sku.Nics { - haveNic = true - - whereMods = append(whereMods, p.Params[i].Sku.Nics[j].queryMods(p.Params[i].ComparitorOperator)...) - } - - if len(whereMods) > 0 { - if p.Params[i].LogicalOperator == OperatorLogicalOR { - whereMods = []qm.QueryMod{ - qm.Or2(qm.Expr(whereMods...)), - } - } else { - whereMods = []qm.QueryMod{ - qm.Expr(whereMods...), - } - } - - // We do these in separate chunks since qm.Expr() can only be run on qm.WhereQueryMod{}. - // And each loop will then be a bunch of groups of qm.exprMod{} and not qm.WhereQueryMod{}. - mods = append(mods, whereMods...) - } - } - - // Join AuxDevice table - if haveAuxDevice { - mods = append(mods, qm.InnerJoin(fmt.Sprintf("%s on %s = %s", - models.TableNames.ServerSkuAuxDevice, - models.ServerSkuTableColumns.ID, - models.ServerSkuAuxDeviceTableColumns.SkuID))) - } - - // Join Disk table - if haveDisk { - mods = append(mods, qm.InnerJoin(fmt.Sprintf("%s on %s = %s", - models.TableNames.ServerSkuDisk, - models.ServerSkuTableColumns.ID, - models.ServerSkuDiskTableColumns.SkuID))) - } - - // Join Memory table - if haveMemory { - mods = append(mods, qm.InnerJoin(fmt.Sprintf("%s on %s = %s", - models.TableNames.ServerSkuMemory, - models.ServerSkuTableColumns.ID, - models.ServerSkuMemoryTableColumns.SkuID))) - } - - // Join Nic table - if haveNic { - mods = append(mods, qm.InnerJoin(fmt.Sprintf("%s on %s = %s", - models.TableNames.ServerSkuNic, - models.ServerSkuTableColumns.ID, - models.ServerSkuNicTableColumns.SkuID))) - } - - mods = append(mods, p.Pagination.queryMods()...) - - return mods -} diff --git a/pkg/api/v1/server_sku_test.go b/pkg/api/v1/server_sku_test.go deleted file mode 100644 index a0d22c1a..00000000 --- a/pkg/api/v1/server_sku_test.go +++ /dev/null @@ -1,191 +0,0 @@ -package fleetdbapi_test - -import ( - "context" - "encoding/json" - "testing" - - "github.com/google/uuid" - fleetdbapi "github.com/metal-toolbox/fleetdb/pkg/api/v1" - "github.com/stretchr/testify/assert" - "github.com/stretchr/testify/require" -) - -var ServerSkuTest = fleetdbapi.ServerSku{ - Name: "DreamMachine", - Version: "version", - Vendor: "AMD", - Chassis: "4U", - BMCModel: "1", - MotherboardModel: "ATX", - CPUVendor: "AMD", - CPUModel: "7995WX", - CPUCores: 96, - CPUHertz: 2500000000, - CPUCount: 1, - AuxDevices: []fleetdbapi.AuxDevice{ - { - Vendor: "AMD", - Model: "W7900", - DeviceType: "Dedicated GPU", - Details: []byte(`{"slot": 2,"stream-processors": 6144,"compute-units": 96,"tflops": 122.64,"memory-type": "GDDR6","memory-bytes": 48000000000,"TBP": 299}`), - }, - { - Vendor: "AMD", - Model: "W7900", - DeviceType: "Dedicated GPU", - Details: []byte(`{"slot": 3,"stream-processors": 6144,"compute-units": 96,"tflops": 122.64,"memory-type": "GDDR6","memory-bytes": 48000000000,"TBP": 299}`), - }, - }, - Disks: []fleetdbapi.Disk{ - { - Bytes: 8000000000000, - Protocol: "SATA", - Count: 1, - }, - { - Bytes: 4000000000000, - Protocol: "NVME", - Count: 1, - }, - }, - Memory: []fleetdbapi.Memory{ - { - Bytes: 8000000000, - Count: 2, - }, - { - Bytes: 8000000000, - Count: 2, - }, - }, - Nics: []fleetdbapi.Nic{ - { - PortBandwidth: 1000000000, - PortCount: 2, - }, - { - PortBandwidth: 10000000000, - PortCount: 1, - }, - }, -} - -func TestServerSkuCreate(t *testing.T) { - mockClientTests(t, func(ctx context.Context, respCode int, expectError bool) error { - id := uuid.NewString() - jsonResponse, err := json.Marshal(fleetdbapi.ServerResponse{Message: "resource created", Slug: id}) - require.NoError(t, err) - - c := mockClient(string(jsonResponse), respCode) - resp, err := c.CreateServerSku(ctx, ServerSkuTest) - - if expectError { - assert.Error(t, err) - - return err - } - - require.NotNil(t, resp) // stop testing if resp is nil - assert.Equal(t, id, resp.Slug) - - return err - }) -} - -func TestServerSkuDelete(t *testing.T) { - mockClientTests(t, func(ctx context.Context, respCode int, _ bool) error { - jsonResponse := json.RawMessage([]byte(`{"message": "resource deleted"}`)) - c := mockClient(string(jsonResponse), respCode) - _, err := c.DeleteServerSku(ctx, uuid.New()) - - return err - }) -} - -func TestServerSkuGet(t *testing.T) { - mockClientTests(t, func(ctx context.Context, respCode int, expectError bool) error { - jsonResponse, err := json.Marshal(fleetdbapi.ServerResponse{Record: &ServerSkuTest}) - assert.NoError(t, err) - - c := mockClient(string(jsonResponse), respCode) - - resp, err := c.GetServerSku(ctx, uuid.New()) - if expectError { - assert.Error(t, err) - - return err - } - - assert.NoError(t, err) - require.NotNil(t, resp) // stop testing if set is nil - assert.Equal(t, ServerSkuTest, *resp.Record.(*fleetdbapi.ServerSku)) - - return err - }) -} - -func TestServerSkuList(t *testing.T) { - mockClientTests(t, func(ctx context.Context, respCode int, expectError bool) error { - jsonResponse, err := json.Marshal(fleetdbapi.ServerResponse{Records: &[]fleetdbapi.ServerSku{ServerSkuTest}}) - assert.NoError(t, err) - - c := mockClient(string(jsonResponse), respCode) - - testServerSkuQueryParams := fleetdbapi.ServerSkuListParams{ - Params: []fleetdbapi.ServerSkuQueryParams{ - { - Sku: fleetdbapi.ServerSkuQuery{ - Name: "DreamMachine", - }, - LogicalOperator: fleetdbapi.OperatorLogicalOR, - ComparitorOperator: fleetdbapi.OperatorComparitorLike, - }, - }, - Pagination: fleetdbapi.PaginationParams{ - Limit: 50, - Page: 4, - Cursor: "cursor", - Preload: true, - OrderBy: "nothing", - }, - } - - resp, err := c.ListServerSku(ctx, &testServerSkuQueryParams) - if expectError { - assert.Error(t, err) - - return err - } - - assert.NoError(t, err) - require.NotNil(t, resp) - assert.Equal(t, []fleetdbapi.ServerSku{ServerSkuTest}, *resp.Records.(*[]fleetdbapi.ServerSku)) - - return err - }) -} - -func TestServerSkuUpdate(t *testing.T) { - mockClientTests(t, func(ctx context.Context, respCode int, expectError bool) error { - idStr := uuid.NewString() - jsonResponse, err := json.Marshal(fleetdbapi.ServerResponse{Message: "resource updated", Slug: idStr}) - require.NoError(t, err) - - id, _ := uuid.Parse(idStr) - - c := mockClient(string(jsonResponse), respCode) - resp, err := c.UpdateServerSku(ctx, id, ServerSkuTest) - - if expectError { - assert.Error(t, err) - - return err - } - - require.NotNil(t, resp) // stop testing if resp is nil - assert.Equal(t, idStr, resp.Slug) - - return err - }) -}