From 76a3e977baf1b805c90dccb0913a5062a02b4f27 Mon Sep 17 00:00:00 2001 From: nite Date: Sat, 5 Apr 2025 03:30:18 +1100 Subject: [PATCH] u --- age_rating_categories.go | 9 +++++++++ age_rating_content_descriptions.go | 9 +++++++++ age_rating_content_descriptions_v2.go | 9 +++++++++ age_rating_organizations.go | 9 +++++++++ age_ratings.go | 9 +++++++++ alternative_names.go | 9 +++++++++ artworks.go | 9 +++++++++ character_genders.go | 9 +++++++++ character_mug_shots.go | 9 +++++++++ character_species.go | 9 +++++++++ characters.go | 9 +++++++++ collection_membership_types.go | 9 +++++++++ collection_memberships.go | 9 +++++++++ collection_relation_types.go | 9 +++++++++ collection_relations.go | 9 +++++++++ collection_types.go | 9 +++++++++ collections.go | 9 +++++++++ companies.go | 9 +++++++++ company_logos.go | 9 +++++++++ company_statuses.go | 9 +++++++++ company_websites.go | 9 +++++++++ covers.go | 9 +++++++++ date_formats.go | 9 +++++++++ event_logos.go | 9 +++++++++ event_networks.go | 9 +++++++++ events.go | 9 +++++++++ external_game_sources.go | 9 +++++++++ external_games.go | 9 +++++++++ franchises.go | 9 +++++++++ game_engine_logos.go | 9 +++++++++ game_engines.go | 9 +++++++++ game_localizations.go | 9 +++++++++ game_modes.go | 9 +++++++++ game_release_formats.go | 9 +++++++++ game_statuses.go | 9 +++++++++ game_time_to_beats.go | 25 +++++++++++++++++++++++++ game_types.go | 9 +++++++++ game_version_feature_values.go | 9 +++++++++ game_version_features.go | 9 +++++++++ game_versions.go | 9 +++++++++ game_videos.go | 9 +++++++++ games.go | 9 +++++++++ genres.go | 9 +++++++++ involved_companies.go | 9 +++++++++ keywords.go | 9 +++++++++ language_support_types.go | 9 +++++++++ language_supports.go | 9 +++++++++ languages.go | 9 +++++++++ multiplayer_modes.go | 9 +++++++++ network_types.go | 9 +++++++++ platform_families.go | 9 +++++++++ platform_logos.go | 9 +++++++++ platform_types.go | 9 +++++++++ platform_version_companies.go | 9 +++++++++ platform_version_release_dates.go | 9 +++++++++ platform_versions.go | 9 +++++++++ platform_websites.go | 9 +++++++++ platforms.go | 9 +++++++++ player_perspectives.go | 9 +++++++++ popularity_primitives.go | 9 +++++++++ popularity_types.go | 9 +++++++++ regions.go | 9 +++++++++ release_date_regions.go | 9 +++++++++ release_date_statuses.go | 9 +++++++++ release_dates.go | 9 +++++++++ screenshots.go | 9 +++++++++ themes.go | 9 +++++++++ website_types.go | 9 +++++++++ websites.go | 9 +++++++++ 69 files changed, 637 insertions(+) diff --git a/age_rating_categories.go b/age_rating_categories.go index ebc4847..ebb6643 100644 --- a/age_rating_categories.go +++ b/age_rating_categories.go @@ -61,3 +61,12 @@ func (g *igdb) GetAgeRatingCategoriesByOrganizationIDs(ids []uint64) ([]*pb.AgeR return g.GetAgeRatingCategories(idStr) } + +func (g *igdb) GetAgeRatingCategoriesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + ageRatingCategories, err := g.GetAgeRatingCategories(query) + if err != nil { + return 0, err + } + return int(ageRatingCategories[0].Id), nil +} diff --git a/age_rating_content_descriptions.go b/age_rating_content_descriptions.go index 3ddb9b9..9ad5cc9 100644 --- a/age_rating_content_descriptions.go +++ b/age_rating_content_descriptions.go @@ -45,3 +45,12 @@ func (g *igdb) GetAgeRatingContentDescriptionsByIDs(ids []uint64) ([]*pb.AgeRati return g.GetAgeRatingContentDescriptions(idStr) } + +func (g *igdb) GetAgeRatingContentDescriptionsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + ageRatingContentDescriptions, err := g.GetAgeRatingContentDescriptions(query) + if err != nil { + return 0, err + } + return int(ageRatingContentDescriptions[0].Id), nil +} diff --git a/age_rating_content_descriptions_v2.go b/age_rating_content_descriptions_v2.go index 7d84ee8..f45c6cb 100644 --- a/age_rating_content_descriptions_v2.go +++ b/age_rating_content_descriptions_v2.go @@ -61,3 +61,12 @@ func (g *igdb) GetAgeRatingContentDescriptionsV2ByOrganizationIDs(ids []uint64) return g.GetAgeRatingContentDescriptionsV2(idStr) } + +func (g *igdb) GetAgeRatingContentDescriptionsV2Length() (int, error) { + query := `fields *; sort id desc; limit 1;` + ageRatingContentDescriptions, err := g.GetAgeRatingContentDescriptionsV2(query) + if err != nil { + return 0, err + } + return int(ageRatingContentDescriptions[0].Id), nil +} diff --git a/age_rating_organizations.go b/age_rating_organizations.go index 2943132..83e134f 100644 --- a/age_rating_organizations.go +++ b/age_rating_organizations.go @@ -45,3 +45,12 @@ func (g *igdb) GetAgeRatingOrganizationsByIDs(ids []uint64) ([]*pb.AgeRatingOrga return g.GetAgeRatingOrganizations(idStr) } + +func (g *igdb) GetAgeRatingOrganizationsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + ageRatingOrganizations, err := g.GetAgeRatingOrganizations(query) + if err != nil { + return 0, err + } + return int(ageRatingOrganizations[0].Id), nil +} diff --git a/age_ratings.go b/age_ratings.go index 76abef9..a36b142 100644 --- a/age_ratings.go +++ b/age_ratings.go @@ -77,3 +77,12 @@ func (g *igdb) GetAgeRatingsByAgeRatingCategoryIDs(ids []uint64) ([]*pb.AgeRatin return g.GetAgeRatings(idStr) } + +func (g *igdb) GetAgeRatingsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + ageRatings, err := g.GetAgeRatings(query) + if err != nil { + return 0, err + } + return int(ageRatings[0].Id), nil +} diff --git a/alternative_names.go b/alternative_names.go index 6f7e27d..dfe57dd 100644 --- a/alternative_names.go +++ b/alternative_names.go @@ -61,3 +61,12 @@ func (g *igdb) GetAlternativeNamesByGameIDs(ids []uint64) ([]*pb.AlternativeName return g.GetAlternativeNames(idStr) } + +func (g *igdb) GetAlternativeNamesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + alternativeNames, err := g.GetAlternativeNames(query) + if err != nil { + return 0, err + } + return int(alternativeNames[0].Id), nil +} diff --git a/artworks.go b/artworks.go index 26c0d42..a1b11c4 100644 --- a/artworks.go +++ b/artworks.go @@ -62,3 +62,12 @@ func (g *igdb) GetArtworksByGameIDs(ids []uint64) ([]*pb.Artwork, error) { return g.GetArtworks(idStr) } + +func (g *igdb) GetArtworksLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + artworks, err := g.GetArtworks(query) + if err != nil { + return 0, err + } + return int(artworks[0].Id), nil +} diff --git a/character_genders.go b/character_genders.go index 09f19c0..fe21ef8 100644 --- a/character_genders.go +++ b/character_genders.go @@ -45,3 +45,12 @@ func (g *igdb) GetCharacterGendersByIDs(ids []uint64) ([]*pb.CharacterGender, er return g.GetCharacterGenders(idStr) } + +func (g *igdb) GetCharacterGendersLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + characterGenders, err := g.GetCharacterGenders(query) + if err != nil { + return 0, err + } + return int(characterGenders[0].Id), nil +} diff --git a/character_mug_shots.go b/character_mug_shots.go index dc4adcb..e96ad8f 100644 --- a/character_mug_shots.go +++ b/character_mug_shots.go @@ -45,3 +45,12 @@ func (g *igdb) GetCharacterMugShotsByIDs(ids []uint64) ([]*pb.CharacterMugShot, return g.GetCharacterMugShots(idStr) } + +func (g *igdb) GetCharacterMugShotsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + characterMugShots, err := g.GetCharacterMugShots(query) + if err != nil { + return 0, err + } + return int(characterMugShots[0].Id), nil +} diff --git a/character_species.go b/character_species.go index 4a30ccb..b599a96 100644 --- a/character_species.go +++ b/character_species.go @@ -45,3 +45,12 @@ func (g *igdb) GetCharacterSpeciesByIDs(ids []uint64) ([]*pb.CharacterSpecie, er return g.GetCharacterSpecies(idStr) } + +func (g *igdb) GetCharacterSpeciesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + characterSpecies, err := g.GetCharacterSpecies(query) + if err != nil { + return 0, err + } + return int(characterSpecies[0].Id), nil +} diff --git a/characters.go b/characters.go index eb30248..9272b7d 100644 --- a/characters.go +++ b/characters.go @@ -94,3 +94,12 @@ func (g *igdb) GetCharactersByMugShotIDs(ids []uint64) ([]*pb.Character, error) return g.GetCharacters(idStr) } + +func (g *igdb) GetCharactersLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + characters, err := g.GetCharacters(query) + if err != nil { + return 0, err + } + return int(characters[0].Id), nil +} diff --git a/collection_membership_types.go b/collection_membership_types.go index 35ad910..f5d8e79 100644 --- a/collection_membership_types.go +++ b/collection_membership_types.go @@ -61,3 +61,12 @@ func (g *igdb) GetCollectionMembershipTypesByAllowedCollectionTypeIDs(ids []uint return g.GetCollectionMembershipTypes(idStr) } + +func (g *igdb) GetCollectionMembershipTypesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + collectionMembershipTypes, err := g.GetCollectionMembershipTypes(query) + if err != nil { + return 0, err + } + return int(collectionMembershipTypes[0].Id), nil +} diff --git a/collection_memberships.go b/collection_memberships.go index f57421e..275b957 100644 --- a/collection_memberships.go +++ b/collection_memberships.go @@ -82,3 +82,12 @@ func (g *igdb) GetCollectionMembershipsByCollectionMembershipTypeIDs(ids []uint6 return g.GetCollectionMemberships(idStr) } + +func (g *igdb) GetCollectionMembershipsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + collectionMemberships, err := g.GetCollectionMemberships(query) + if err != nil { + return 0, err + } + return int(collectionMemberships[0].Id), nil +} diff --git a/collection_relation_types.go b/collection_relation_types.go index bf69cfc..08e09c2 100644 --- a/collection_relation_types.go +++ b/collection_relation_types.go @@ -77,3 +77,12 @@ func (g *igdb) GetCollectionRelationTypesByAllowedParentTypeIDs(ids []uint64) ([ return g.GetCollectionRelationTypes(idStr) } + +func (g *igdb) GetCollectionRelationTypesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + collectionRelationTypes, err := g.GetCollectionRelationTypes(query) + if err != nil { + return 0, err + } + return int(collectionRelationTypes[0].Id), nil +} diff --git a/collection_relations.go b/collection_relations.go index 3cd89fc..9b96d45 100644 --- a/collection_relations.go +++ b/collection_relations.go @@ -93,3 +93,12 @@ func (g *igdb) GetCollectionRelationsByCollectionRelationTypeIDs(ids []uint64) ( return g.GetCollectionRelations(idStr) } + +func (g *igdb) GetCollectionRelationsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + collectionRelations, err := g.GetCollectionRelations(query) + if err != nil { + return 0, err + } + return int(collectionRelations[0].Id), nil +} diff --git a/collection_types.go b/collection_types.go index b85606d..122753b 100644 --- a/collection_types.go +++ b/collection_types.go @@ -45,3 +45,12 @@ func (g *igdb) GetCollectionTypesByIDs(ids []uint64) ([]*pb.CollectionType, erro return g.GetCollectionTypes(idStr) } + +func (g *igdb) GetCollectionTypesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + collectionTypes, err := g.GetCollectionTypes(query) + if err != nil { + return 0, err + } + return int(collectionTypes[0].Id), nil +} diff --git a/collections.go b/collections.go index bb15133..f120c9b 100644 --- a/collections.go +++ b/collections.go @@ -62,3 +62,12 @@ func (g *igdb) GetCollectionsByCollectionTypeIDs(ids []uint64) ([]*pb.Collection return g.GetCollections(idStr) } + +func (g *igdb) GetCollectionsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + collections, err := g.GetCollections(query) + if err != nil { + return 0, err + } + return int(collections[0].Id), nil +} diff --git a/companies.go b/companies.go index b2db1e0..f8c1f41 100644 --- a/companies.go +++ b/companies.go @@ -143,3 +143,12 @@ func (g *igdb) GetCompanyByStatusIDs(ids []uint64) ([]*pb.Company, error) { return g.GetCompanies(idStr) } + +func (g *igdb) GetCompaniesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + companies, err := g.GetCompanies(query) + if err != nil { + return 0, err + } + return int(companies[0].Id), nil +} diff --git a/company_logos.go b/company_logos.go index 159df29..5416d7c 100644 --- a/company_logos.go +++ b/company_logos.go @@ -45,3 +45,12 @@ func (g *igdb) GetCompanyLogosByIDs(ids []uint64) ([]*pb.CompanyLogo, error) { return g.GetCompanyLogos(idStr) } + +func (g *igdb) GetCompanyLogosLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + companyLogos, err := g.GetCompanyLogos(query) + if err != nil { + return 0, err + } + return int(companyLogos[0].Id), nil +} diff --git a/company_statuses.go b/company_statuses.go index 526b908..45d9c8c 100644 --- a/company_statuses.go +++ b/company_statuses.go @@ -45,3 +45,12 @@ func (g *igdb) GetCompanyStatusesByIDs(ids []uint64) ([]*pb.CompanyStatus, error return g.GetCompanyStatuses(idStr) } + +func (g *igdb) GetCompanyStatusesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + companyStatuses, err := g.GetCompanyStatuses(query) + if err != nil { + return 0, err + } + return int(companyStatuses[0].Id), nil +} diff --git a/company_websites.go b/company_websites.go index 6e5152b..6ef1e4a 100644 --- a/company_websites.go +++ b/company_websites.go @@ -61,3 +61,12 @@ func (g *igdb) GetCompanyWebsitesByTypeIDs(ids []uint64) ([]*pb.CompanyWebsite, return g.GetCompanyWebsites(idStr) } + +func (g *igdb) GetCompanyWebsitesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + companyWebsites, err := g.GetCompanyWebsites(query) + if err != nil { + return 0, err + } + return int(companyWebsites[0].Id), nil +} diff --git a/covers.go b/covers.go index ae83b41..815c240 100644 --- a/covers.go +++ b/covers.go @@ -77,3 +77,12 @@ func (g *igdb) GetCoversByGameLocalizationIDs(ids []uint64) ([]*pb.Cover, error) return g.GetCovers(idStr) } + +func (g *igdb) GetCoversLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + covers, err := g.GetCovers(query) + if err != nil { + return 0, err + } + return int(covers[0].Id), nil +} diff --git a/date_formats.go b/date_formats.go index 8dd2f87..8b1049f 100644 --- a/date_formats.go +++ b/date_formats.go @@ -45,3 +45,12 @@ func (g *igdb) GetDateFormatsByIDs(ids []uint64) ([]*pb.DateFormat, error) { return g.GetDateFormats(idStr) } + +func (g *igdb) GetDateFormatsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + dateFormats, err := g.GetDateFormats(query) + if err != nil { + return 0, err + } + return int(dateFormats[0].Id), nil +} diff --git a/event_logos.go b/event_logos.go index 3ccfcee..2ad4813 100644 --- a/event_logos.go +++ b/event_logos.go @@ -61,3 +61,12 @@ func (g *igdb) GetEventLogosByEventIDs(ids []uint64) ([]*pb.EventLogo, error) { return g.GetEventLogos(idStr) } + +func (g *igdb) GetEventLogosLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + eventLogos, err := g.GetEventLogos(query) + if err != nil { + return 0, err + } + return int(eventLogos[0].Id), nil +} diff --git a/event_networks.go b/event_networks.go index 74828f4..86c0ca6 100644 --- a/event_networks.go +++ b/event_networks.go @@ -77,3 +77,12 @@ func (g *igdb) GetEventNetworksByNetworkTypeIDs(ids []uint64) ([]*pb.EventNetwor return g.GetEventNetworks(idStr) } + +func (g *igdb) GetEventNetworksLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + eventNetworks, err := g.GetEventNetworks(query) + if err != nil { + return 0, err + } + return int(eventNetworks[0].Id), nil +} diff --git a/events.go b/events.go index 4ac096e..d4f51ac 100644 --- a/events.go +++ b/events.go @@ -62,3 +62,12 @@ func (g *igdb) GetEventsByEventLogoIDs(ids []uint64) ([]*pb.Event, error) { return g.GetEvents(idStr) } + +func (g *igdb) GetEventsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + events, err := g.GetEvents(query) + if err != nil { + return 0, err + } + return int(events[0].Id), nil +} diff --git a/external_game_sources.go b/external_game_sources.go index 15a75eb..6f40151 100644 --- a/external_game_sources.go +++ b/external_game_sources.go @@ -45,3 +45,12 @@ func (g *igdb) GetExternalGameSourcesByIDs(ids []uint64) ([]*pb.ExternalGameSour return g.GetExternalGameSources(idStr) } + +func (g *igdb) GetExternalGameSourcesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + externalGameSources, err := g.GetExternalGameSources(query) + if err != nil { + return 0, err + } + return int(externalGameSources[0].Id), nil +} diff --git a/external_games.go b/external_games.go index d1ea5b9..9142fd4 100644 --- a/external_games.go +++ b/external_games.go @@ -117,3 +117,12 @@ func (g *igdb) GetExternalGamesByPlatformVersionIDs(ids []uint64) ([]*pb.Externa return g.GetExternalGames(idStr) } + +func (g *igdb) GetExternalGamesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + externalGames, err := g.GetExternalGames(query) + if err != nil { + return 0, err + } + return int(externalGames[0].Id), nil +} diff --git a/franchises.go b/franchises.go index 4dbee87..b6f07b5 100644 --- a/franchises.go +++ b/franchises.go @@ -46,3 +46,12 @@ func (g *igdb) GetFranchisesByIDs(ids []uint64) ([]*pb.Franchise, error) { return g.GetFranchises(idStr) } + +func (g *igdb) GetFranchisesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + franchises, err := g.GetFranchises(query) + if err != nil { + return 0, err + } + return int(franchises[0].Id), nil +} diff --git a/game_engine_logos.go b/game_engine_logos.go index 176f035..145e699 100644 --- a/game_engine_logos.go +++ b/game_engine_logos.go @@ -45,3 +45,12 @@ func (g *igdb) GetGameEngineLogosByIDs(ids []uint64) ([]*pb.GameEngineLogo, erro return g.GetGameEngineLogos(idStr) } + +func (g *igdb) GetGameEngineLogosLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + gameEngineLogos, err := g.GetGameEngineLogos(query) + if err != nil { + return 0, err + } + return int(gameEngineLogos[0].Id), nil +} diff --git a/game_engines.go b/game_engines.go index a643382..5a183c6 100644 --- a/game_engines.go +++ b/game_engines.go @@ -78,3 +78,12 @@ func (g *igdb) GetGameEnginesByLogoIDs(ids []uint64) ([]*pb.GameEngine, error) { return g.GetGameEngines(idStr) } + +func (g *igdb) GetGameEnginesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + gameEngines, err := g.GetGameEngines(query) + if err != nil { + return 0, err + } + return int(gameEngines[0].Id), nil +} diff --git a/game_localizations.go b/game_localizations.go index 6a97ae6..ec97e08 100644 --- a/game_localizations.go +++ b/game_localizations.go @@ -93,3 +93,12 @@ func (g *igdb) GetGameLocalizationsByRegionIDs(ids []uint64) ([]*pb.GameLocaliza return g.GetGameLocalizations(idStr) } + +func (g *igdb) GetGameLocalizationsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + gameLocalizations, err := g.GetGameLocalizations(query) + if err != nil { + return 0, err + } + return int(gameLocalizations[0].Id), nil +} diff --git a/game_modes.go b/game_modes.go index 1468438..e21b696 100644 --- a/game_modes.go +++ b/game_modes.go @@ -45,3 +45,12 @@ func (g *igdb) GetGameModesByIDs(ids []uint64) ([]*pb.GameMode, error) { return g.GetGameModes(idStr) } + +func (g *igdb) GetGameModesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + gameModes, err := g.GetGameModes(query) + if err != nil { + return 0, err + } + return int(gameModes[0].Id), nil +} diff --git a/game_release_formats.go b/game_release_formats.go index 3b27152..63b0f67 100644 --- a/game_release_formats.go +++ b/game_release_formats.go @@ -45,3 +45,12 @@ func (g *igdb) GetGameReleaseFormatsByIDs(ids []uint64) ([]*pb.GameReleaseFormat return g.GetGameReleaseFormats(idStr) } + +func (g *igdb) GetGameReleaseFormatsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + gameReleaseFormats, err := g.GetGameReleaseFormats(query) + if err != nil { + return 0, err + } + return int(gameReleaseFormats[0].Id), nil +} diff --git a/game_statuses.go b/game_statuses.go index 4592f6e..cf94c61 100644 --- a/game_statuses.go +++ b/game_statuses.go @@ -45,3 +45,12 @@ func (g *igdb) GetGameStatusesByIDs(ids []uint64) ([]*pb.GameStatus, error) { return g.GetGameStatuses(idStr) } + +func (g *igdb) GetGameStatusesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + gameStatuses, err := g.GetGameStatuses(query) + if err != nil { + return 0, err + } + return int(gameStatuses[0].Id), nil +} diff --git a/game_time_to_beats.go b/game_time_to_beats.go index 1463dd7..e4f4550 100644 --- a/game_time_to_beats.go +++ b/game_time_to_beats.go @@ -45,3 +45,28 @@ func (g *igdb) GetGameTimeToBeatsByIDs(ids []uint64) ([]*pb.GameTimeToBeat, erro return g.GetGameTimeToBeats(idStr) } + +func (g *igdb) GetGameTimeToBeatsByGameID(id uint64) ([]*pb.GameTimeToBeat, error) { + query := fmt.Sprintf(`where game = %d; fields *;`, id) + return g.GetGameTimeToBeats(query) +} + +func (g *igdb) GetGameTimeToBeatsByGameIDs(ids []uint64) ([]*pb.GameTimeToBeat, error) { + idStrSlice := make([]string, len(ids)) + for i, id := range ids { + idStrSlice[i] = fmt.Sprintf("%d", id) + } + + idStr := fmt.Sprintf(`where game = (%s); fields *;`, strings.Join(idStrSlice, ",")) + + return g.GetGameTimeToBeats(idStr) +} + +func (g *igdb) GetGameTimeToBeatsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + gameTimeToBeats, err := g.GetGameTimeToBeats(query) + if err != nil { + return 0, err + } + return int(gameTimeToBeats[0].Id), nil +} diff --git a/game_types.go b/game_types.go index 53b64e7..a974faf 100644 --- a/game_types.go +++ b/game_types.go @@ -45,3 +45,12 @@ func (g *igdb) GetGameTypesByIDs(ids []uint64) ([]*pb.GameType, error) { return g.GetGameTypes(idStr) } + +func (g *igdb) GetGameTypesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + gameTypes, err := g.GetGameTypes(query) + if err != nil { + return 0, err + } + return int(gameTypes[0].Id), nil +} diff --git a/game_version_feature_values.go b/game_version_feature_values.go index b9af0ef..4dcb4eb 100644 --- a/game_version_feature_values.go +++ b/game_version_feature_values.go @@ -77,3 +77,12 @@ func (g *igdb) GetGameVersionFeatureValuesByGameVersionFeatureIDs(ids []uint64) return g.GetGameVersionFeatureValues(idStr) } + +func (g *igdb) GetGameVersionFeatureValuesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + gameVersionFeatureValues, err := g.GetGameVersionFeatureValues(query) + if err != nil { + return 0, err + } + return int(gameVersionFeatureValues[0].Id), nil +} diff --git a/game_version_features.go b/game_version_features.go index 6ba0c6c..c07a710 100644 --- a/game_version_features.go +++ b/game_version_features.go @@ -45,3 +45,12 @@ func (g *igdb) GetGameVersionFeaturesByIDs(ids []uint64) ([]*pb.GameVersionFeatu return g.GetGameVersionFeatures(idStr) } + +func (g *igdb) GetGameVersionFeaturesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + gameVersionFeatures, err := g.GetGameVersionFeatures(query) + if err != nil { + return 0, err + } + return int(gameVersionFeatures[0].Id), nil +} diff --git a/game_versions.go b/game_versions.go index 68f20e3..de27afc 100644 --- a/game_versions.go +++ b/game_versions.go @@ -61,3 +61,12 @@ func (g *igdb) GetGameVersionsByGameIDs(ids []uint64) ([]*pb.GameVersion, error) return g.GetGameVersions(idStr) } + +func (g *igdb) GetGameVersionsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + gameVersions, err := g.GetGameVersions(query) + if err != nil { + return 0, err + } + return int(gameVersions[0].Id), nil +} diff --git a/game_videos.go b/game_videos.go index a1d5c38..9f2949a 100644 --- a/game_videos.go +++ b/game_videos.go @@ -61,3 +61,12 @@ func (g *igdb) GetGameVideosByGameIDs(ids []uint64) ([]*pb.GameVideo, error) { return g.GetGameVideos(idStr) } + +func (g *igdb) GetGameVideosLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + gameVideos, err := g.GetGameVideos(query) + if err != nil { + return 0, err + } + return int(gameVideos[0].Id), nil +} diff --git a/games.go b/games.go index 4d92108..387711b 100644 --- a/games.go +++ b/games.go @@ -158,3 +158,12 @@ func (g *igdb) GetGamesByVersionParentGameIDs(ids []uint64) ([]*pb.Game, error) return g.GetGames(idStr) } + +func (g *igdb) GetGamesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + games, err := g.GetGames(query) + if err != nil { + return 0, err + } + return int(games[0].Id), nil +} diff --git a/genres.go b/genres.go index 930cca5..1195267 100644 --- a/genres.go +++ b/genres.go @@ -45,3 +45,12 @@ func (g *igdb) GetGenresByIDs(ids []uint64) ([]*pb.Genre, error) { return g.GetGenres(idStr) } + +func (g *igdb) GetGenresLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + genres, err := g.GetGenres(query) + if err != nil { + return 0, err + } + return int(genres[0].Id), nil +} diff --git a/involved_companies.go b/involved_companies.go index 85e815a..d597b58 100644 --- a/involved_companies.go +++ b/involved_companies.go @@ -77,3 +77,12 @@ func (g *igdb) GetInvolvedCompaniesByCompanyIDs(ids []uint64) ([]*pb.InvolvedCom return g.GetInvolvedCompanies(idStr) } + +func (g *igdb) GetInvolvedCompaniesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + involvedCompanies, err := g.GetInvolvedCompanies(query) + if err != nil { + return 0, err + } + return int(involvedCompanies[0].Id), nil +} diff --git a/keywords.go b/keywords.go index 140d861..7d0a323 100644 --- a/keywords.go +++ b/keywords.go @@ -45,3 +45,12 @@ func (g *igdb) GetKeywordsByIDs(ids []uint64) ([]*pb.Keyword, error) { return g.GetKeywords(idStr) } + +func (g *igdb) GetKeywordsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + keywords, err := g.GetKeywords(query) + if err != nil { + return 0, err + } + return int(keywords[0].Id), nil +} diff --git a/language_support_types.go b/language_support_types.go index d40a79f..ec681f5 100644 --- a/language_support_types.go +++ b/language_support_types.go @@ -45,3 +45,12 @@ func (g *igdb) GetLanguageSupportTypesByIDs(ids []uint64) ([]*pb.LanguageSupport return g.GetLanguageSupportTypes(idStr) } + +func (g *igdb) GetLanguageSupportTypesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + languageSupportTypes, err := g.GetLanguageSupportTypes(query) + if err != nil { + return 0, err + } + return int(languageSupportTypes[0].Id), nil +} diff --git a/language_supports.go b/language_supports.go index c6cc34f..e313bd6 100644 --- a/language_supports.go +++ b/language_supports.go @@ -93,3 +93,12 @@ func (g *igdb) GetLanguageSupportsByLanguageSupportTypeIDs(ids []uint64) ([]*pb. return g.GetLanguageSupports(idStr) } + +func (g *igdb) GetLanguageSupportsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + languageSupports, err := g.GetLanguageSupports(query) + if err != nil { + return 0, err + } + return int(languageSupports[0].Id), nil +} diff --git a/languages.go b/languages.go index eb68616..caa85f8 100644 --- a/languages.go +++ b/languages.go @@ -45,3 +45,12 @@ func (g *igdb) GetLanguagesByIDs(ids []uint64) ([]*pb.Language, error) { return g.GetLanguages(idStr) } + +func (g *igdb) GetLanguagesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + languages, err := g.GetLanguages(query) + if err != nil { + return 0, err + } + return int(languages[0].Id), nil +} diff --git a/multiplayer_modes.go b/multiplayer_modes.go index 8e16b6f..cfbf4cc 100644 --- a/multiplayer_modes.go +++ b/multiplayer_modes.go @@ -77,3 +77,12 @@ func (g *igdb) GetMultiplayerModesByPlatformIDs(ids []uint64) ([]*pb.Multiplayer return g.GetMultiplayerModes(idStr) } + +func (g *igdb) GetMultiplayerModesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + multiplayerModes, err := g.GetMultiplayerModes(query) + if err != nil { + return 0, err + } + return int(multiplayerModes[0].Id), nil +} diff --git a/network_types.go b/network_types.go index 03525e8..ed6845c 100644 --- a/network_types.go +++ b/network_types.go @@ -45,3 +45,12 @@ func (g *igdb) GetNetworkTypesByIDs(ids []uint64) ([]*pb.NetworkType, error) { return g.GetNetworkTypes(idStr) } + +func (g *igdb) GetNetworkTypesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + networkTypes, err := g.GetNetworkTypes(query) + if err != nil { + return 0, err + } + return int(networkTypes[0].Id), nil +} diff --git a/platform_families.go b/platform_families.go index 1e7ddc1..9ff21e7 100644 --- a/platform_families.go +++ b/platform_families.go @@ -45,3 +45,12 @@ func (g *igdb) GetPlatformFamiliesByIDs(ids []uint64) ([]*pb.PlatformFamily, err return g.GetPlatformFamilies(idStr) } + +func (g *igdb) GetPlatformFamiliesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + platformFamilies, err := g.GetPlatformFamilies(query) + if err != nil { + return 0, err + } + return int(platformFamilies[0].Id), nil +} diff --git a/platform_logos.go b/platform_logos.go index a96db6c..2e1f6d2 100644 --- a/platform_logos.go +++ b/platform_logos.go @@ -45,3 +45,12 @@ func (g *igdb) GetPlatformLogosByIDs(ids []uint64) ([]*pb.PlatformLogo, error) { return g.GetPlatformLogos(idStr) } + +func (g *igdb) GetPlatformLogosLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + platformLogos, err := g.GetPlatformLogos(query) + if err != nil { + return 0, err + } + return int(platformLogos[0].Id), nil +} diff --git a/platform_types.go b/platform_types.go index c609d49..144fab6 100644 --- a/platform_types.go +++ b/platform_types.go @@ -46,3 +46,12 @@ func (g *igdb) GetPlatformTypesByIDs(ids []uint64) ([]*pb.PlatformType, error) { return g.GetPlatformTypes(idStr) } + +func (g *igdb) GetPlatformTypesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + platformTypes, err := g.GetPlatformTypes(query) + if err != nil { + return 0, err + } + return int(platformTypes[0].Id), nil +} diff --git a/platform_version_companies.go b/platform_version_companies.go index 34d2a3a..3730382 100644 --- a/platform_version_companies.go +++ b/platform_version_companies.go @@ -61,3 +61,12 @@ func (g *igdb) GetPlatformVersionCompaniesByCompanyIDs(ids []uint64) ([]*pb.Plat return g.GetPlatformVersionCompanies(idStr) } + +func (g *igdb) GetPlatformVersionCompaniesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + platformVersionCompanies, err := g.GetPlatformVersionCompanies(query) + if err != nil { + return 0, err + } + return int(platformVersionCompanies[0].Id), nil +} diff --git a/platform_version_release_dates.go b/platform_version_release_dates.go index 5021d60..b1318b9 100644 --- a/platform_version_release_dates.go +++ b/platform_version_release_dates.go @@ -93,3 +93,12 @@ func (g *igdb) GetPlatformVersionReleaseDatesByDateFormatIDs(ids []uint64) ([]*p return g.GetPlatformVersionReleaseDates(idStr) } + +func (g *igdb) GetPlatformVersionReleaseDatesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + platformVersionReleaseDates, err := g.GetPlatformVersionReleaseDates(query) + if err != nil { + return 0, err + } + return int(platformVersionReleaseDates[0].Id), nil +} diff --git a/platform_versions.go b/platform_versions.go index 7510cd7..58c6b4f 100644 --- a/platform_versions.go +++ b/platform_versions.go @@ -77,3 +77,12 @@ func (g *igdb) GetPlatformVersionsByPlatformLogoIDs(ids []uint64) ([]*pb.Platfor return g.GetPlatformVersions(idStr) } + +func (g *igdb) GetPlatformVersionsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + platformVersions, err := g.GetPlatformVersions(query) + if err != nil { + return 0, err + } + return int(platformVersions[0].Id), nil +} diff --git a/platform_websites.go b/platform_websites.go index 9aff95f..e65a6fc 100644 --- a/platform_websites.go +++ b/platform_websites.go @@ -45,3 +45,12 @@ func (g *igdb) GetPlatformWebsitesByIDs(ids []uint64) ([]*pb.PlatformWebsite, er return g.GetPlatformWebsites(idStr) } + +func (g *igdb) GetPlatformWebsitesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + platformWebsites, err := g.GetPlatformWebsites(query) + if err != nil { + return 0, err + } + return int(platformWebsites[0].Id), nil +} diff --git a/platforms.go b/platforms.go index 20533de..046eb70 100644 --- a/platforms.go +++ b/platforms.go @@ -92,3 +92,12 @@ func (g *igdb) GetPlatformsByPlatformTypeIDs(ids []uint64) ([]*pb.Platform, erro return g.GetPlatforms(idStr) } + +func (g *igdb) GetPlatformsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + platforms, err := g.GetPlatforms(query) + if err != nil { + return 0, err + } + return int(platforms[0].Id), nil +} diff --git a/player_perspectives.go b/player_perspectives.go index c0a1ce4..88c6fc4 100644 --- a/player_perspectives.go +++ b/player_perspectives.go @@ -45,3 +45,12 @@ func (g *igdb) GetPlayerPerspectivesByIDs(ids []uint64) ([]*pb.PlayerPerspective return g.GetPlayerPerspectives(idStr) } + +func (g *igdb) GetPlayerPerspectivesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + playerPerspectives, err := g.GetPlayerPerspectives(query) + if err != nil { + return 0, err + } + return int(playerPerspectives[0].Id), nil +} diff --git a/popularity_primitives.go b/popularity_primitives.go index 665818c..80b673c 100644 --- a/popularity_primitives.go +++ b/popularity_primitives.go @@ -71,3 +71,12 @@ func (g *igdb) GetPopularityPrimitivesByExternalPopularitySourceIDs(ids []uint64 return g.GetPopularityPrimitives(idStr) } + +func (g *igdb) GetPopularityPrimitivesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + popularityPrimitives, err := g.GetPopularityPrimitives(query) + if err != nil { + return 0, err + } + return int(popularityPrimitives[0].Id), nil +} diff --git a/popularity_types.go b/popularity_types.go index f23627d..6146120 100644 --- a/popularity_types.go +++ b/popularity_types.go @@ -61,3 +61,12 @@ func (g *igdb) GetPopularityTypesByExternalPopularitySourceIDs(ids []uint64) ([] return g.GetPopularityTypes(idStr) } + +func (g *igdb) GetPopularityTypesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + popularityTypes, err := g.GetPopularityTypes(query) + if err != nil { + return 0, err + } + return int(popularityTypes[0].Id), nil +} diff --git a/regions.go b/regions.go index 48694ca..279d063 100644 --- a/regions.go +++ b/regions.go @@ -45,3 +45,12 @@ func (g *igdb) GetRegionsByIDs(ids []uint64) ([]*pb.Region, error) { return g.GetRegions(idStr) } + +func (g *igdb) GetRegionsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + regions, err := g.GetRegions(query) + if err != nil { + return 0, err + } + return int(regions[0].Id), nil +} diff --git a/release_date_regions.go b/release_date_regions.go index 6d15a40..339ac2f 100644 --- a/release_date_regions.go +++ b/release_date_regions.go @@ -45,3 +45,12 @@ func (g *igdb) GetReleaseDateRegionsByIDs(ids []uint64) ([]*pb.ReleaseDateRegion return g.GetReleaseDateRegions(idStr) } + +func (g *igdb) GetReleaseDateRegionsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + releaseDateRegions, err := g.GetReleaseDateRegions(query) + if err != nil { + return 0, err + } + return int(releaseDateRegions[0].Id), nil +} diff --git a/release_date_statuses.go b/release_date_statuses.go index 2cfc579..7876a1d 100644 --- a/release_date_statuses.go +++ b/release_date_statuses.go @@ -45,3 +45,12 @@ func (g *igdb) GetReleaseDateStatusesByIDs(ids []uint64) ([]*pb.ReleaseDateStatu return g.GetReleaseDateStatuses(idStr) } + +func (g *igdb) GetReleaseDateStatusesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + releaseDateStatuses, err := g.GetReleaseDateStatuses(query) + if err != nil { + return 0, err + } + return int(releaseDateStatuses[0].Id), nil +} diff --git a/release_dates.go b/release_dates.go index 5ca5334..529eb25 100644 --- a/release_dates.go +++ b/release_dates.go @@ -109,3 +109,12 @@ func (g *igdb) GetReleaseDatesByStatusIDs(ids []uint64) ([]*pb.ReleaseDate, erro return g.GetReleaseDates(idStr) } + +func (g *igdb) GetReleaseDatesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + releaseDates, err := g.GetReleaseDates(query) + if err != nil { + return 0, err + } + return int(releaseDates[0].Id), nil +} diff --git a/screenshots.go b/screenshots.go index ab7f306..b08cdec 100644 --- a/screenshots.go +++ b/screenshots.go @@ -61,3 +61,12 @@ func (g *igdb) GetScreenshotsByGameIDs(ids []uint64) ([]*pb.Screenshot, error) { return g.GetScreenshots(idStr) } + +func (g *igdb) GetScreenshotsLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + screenshots, err := g.GetScreenshots(query) + if err != nil { + return 0, err + } + return int(screenshots[0].Id), nil +} diff --git a/themes.go b/themes.go index edeb213..da83ba9 100644 --- a/themes.go +++ b/themes.go @@ -45,3 +45,12 @@ func (g *igdb) GetThemesByIDs(ids []uint64) ([]*pb.Theme, error) { return g.GetThemes(idStr) } + +func (g *igdb) GetThemesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + themes, err := g.GetThemes(query) + if err != nil { + return 0, err + } + return int(themes[0].Id), nil +} diff --git a/website_types.go b/website_types.go index 7bf9e1a..dd7c259 100644 --- a/website_types.go +++ b/website_types.go @@ -45,3 +45,12 @@ func (g *igdb) GetWebsiteTypesByIDs(ids []uint64) ([]*pb.WebsiteType, error) { return g.GetWebsiteTypes(idStr) } + +func (g *igdb) GetWebsiteTypesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + websiteTypes, err := g.GetWebsiteTypes(query) + if err != nil { + return 0, err + } + return int(websiteTypes[0].Id), nil +} diff --git a/websites.go b/websites.go index ac13150..609fcc9 100644 --- a/websites.go +++ b/websites.go @@ -77,3 +77,12 @@ func (g *igdb) GetWebsitesByTypeIDs(ids []uint64) ([]*pb.Website, error) { return g.GetWebsites(idStr) } + +func (g *igdb) GetWebsitesLength() (int, error) { + query := `fields *; sort id desc; limit 1;` + websites, err := g.GetWebsites(query) + if err != nil { + return 0, err + } + return int(websites[0].Id), nil +}