Vous trouverez dans ce document la procédure à suivre pour créer et utiliser des tables partitionnées par date d'ingestion dans BigQuery. Pour plus d'informations sur les tables partitionnées par date basées sur des colonnes, consultez la section Créer et utiliser des tables partitionnées par date basées sur des colonnes. Pour plus d'informations sur les tables partitionnées par plages d'entiers, consultez la page Créer et utiliser des tables partitionnées par plages d'entiers.
Après avoir créé une table partitionnée par date d'ingestion, vous pouvez effectuer les opérations suivantes :
- Contrôler l'accès aux données de votre table
- obtenir des informations sur vos tables partitionnées ;
- répertorier les tables partitionnées dans un ensemble de données ;
- obtenir des métadonnées de tables partitionnées à l'aide de métatables.
Pour en savoir plus sur la gestion des tables partitionnées, telle que la mise à jour de leurs propriétés, leur copie et leur suppression, consultez la page Gérer des tables partitionnées.
Créer des tables partitionnées par date d'ingestion
Vous pouvez créer une table partitionnée par date d'ingestion dans BigQuery :
- à l'aide d'une instruction LDD
CREATE TABLE
avec une clausepartition_expression
; - manuellement, en utilisant Cloud Console ;
- En utilisant la commande
bq mk
de l'outil de ligne de commandebq
- De façon automatisée, en appelant la méthode API
tables.insert
- en utilisant les bibliothèques clientes ;
- à partir des résultats de la requête ;
- lorsque vous chargez des données ;
- en convertissant les tables segmentées par date en tables partitionnées.
Dénomination des tables
Lorsque vous créez une table dans BigQuery, le nom de la table doit être unique pour chaque ensemble de données. Le nom de la table peut :
- contenir jusqu'à 1 024 caractères ;
- contenir des caractères Unicode des catégories L (lettre), M (marque), N (nombre), Pc (ponctuation de type connecteur, y compris trait de soulignement), Pd (ponctuation de type tiret), Zs (espace). Pour en savoir plus, consultez la section décrivant les catégories générales.
Par exemple, tous les noms de table suivants sont valides : table-01
, ग्राहक
, 00_お客様
, étudiant
.
Autorisations requises
Pour créer une table, vous devez disposer au minimum des autorisations suivantes :
- Autorisations
bigquery.tables.create
pour créer la table - Autorisations
bigquery.tables.updateData
pour écrire des données dans la table à l'aide d'une tâche de chargement, de requête ou de copie - Autorisations
bigquery.jobs.create
pour exécuter une tâche de requête, de chargement ou de copie qui écrit des données dans la table
Des autorisations supplémentaires, par exemple bigquery.tables.getData
, peuvent être nécessaires pour accéder aux données que vous écrivez dans la table.
Les rôles IAM prédéfinis suivants incluent les autorisations bigquery.tables.create
et bigquery.tables.updateData
:
bigquery.dataEditor
bigquery.dataOwner
bigquery.admin
Les rôles IAM prédéfinis suivants incluent les autorisations bigquery.jobs.create
:
bigquery.user
bigquery.jobUser
bigquery.admin
En outre, si un utilisateur possède les autorisations bigquery.datasets.create
, il obtient également un accès bigquery.dataOwner
à l'ensemble de données qu'il crée.
L'accès correspondant au rôle bigquery.dataOwner
donne à l'utilisateur la possibilité de créer et de mettre à jour des tables dans l'ensemble de données.
Pour en savoir plus sur les rôles et les autorisations IAM dans BigQuery, consultez la page Rôles prédéfinis et autorisations.
Créer une table partitionnée par temps d'ingestion vide avec une définition de schéma
Lorsque vous créez une table partitionnée par date vide avec une définition de schéma, vous pouvez :
- saisir le schéma à l'aide de Cloud Console ;
- fournir le schéma en ligne avec l'outil de ligne de commande
bq
; - envoyer un fichier de schéma JSON à l'aide de l'outil de ligne de commande
bq
; - fournir le schéma dans une ressource de table lorsque vous appelez la méthode API
tables.insert
.
Pour en savoir plus sur la spécification d'un schéma de table, consultez la page Spécifier un schéma.
Après avoir créé la table partitionnée par date, vous pouvez y effectuer les opérations suivantes :
- Charger des données
- écrire les résultats de requêtes ;
- Copier des données
Pour créer une table partitionnée par date vide avec une définition de schéma, procédez comme suit :
Console
Dans le panneau Explorateur, développez votre projet et sélectionnez un ensemble de données.
Sélectionnez l'option Créer une table vide dans la section Source de la page Créer une table :
Dans la section Destination (Destination) de la page Create Table (Créer une table) :
Sous Dataset name (Nom de l'ensemble de données), sélectionnez l'ensemble de données approprié.
Dans le champ Nom de la table, saisissez le nom de la table que vous créez dans BigQuery.
Vérifiez que le champ Table type (Type de table) est défini sur Native table (Table native).
Dans la section Schema (Schéma), saisissez la définition du schéma. Pour saisir les informations de schéma manuellement, effectuez l'une des opérations suivantes :
Activez Edit as text (Modifier sous forme de texte) et saisissez le schéma de la table sous forme de tableau JSON.
Cliquez sur Ajouter un champ et saisissez les informations sur le schéma.
Dans la section Partition and cluster settings (Paramètres de la partition et du cluster) :
- Pour le paramètre Partitioning (Partitionnement), cliquez sur No partitioning (Aucun partitionnement) et sélectionnez Partition by ingestion time (Partitionner par date d'ingestion).
- Pour le paramètre Partitioning (Partitionnement), cliquez sur No partitioning (Aucun partitionnement) et sélectionnez Partition by ingestion time (Partitionner par date d'ingestion).
(Facultatif) Pour le champ Filtre de partitionnement, cochez la case Demander un filtre de partitionnement pour obliger les utilisateurs à inclure une clause
WHERE
spécifiant les partitions à interroger. Ce type de filtre peut contribuer à réduire les coûts et à améliorer les performances. Pour en savoir plus, consultez la section Interroger des tables partitionnées.(Facultatif) Cliquez sur Options avancées et, pour le champ Chiffrement, cliquez sur Clé gérée par le client pour utiliser une clé Cloud Key Management Service. Si vous conservez le paramètre Clé gérée par Google, BigQuery chiffre les données au repos.
Cliquez sur Create table.
Une fois la table créée, vous pouvez mettre à jour son délai d'expiration, sa description et ses libellés, mais vous ne pouvez pas ajouter de délai d'expiration de la partition après la création d'une table à l'aide de Cloud Console.
bq
Exécutez la commande mk
avec l'option --table
(ou le raccourci -t
) et l'option --
time_partitioning_type
, définis sur DAY
, HOUR
, MONTH
ou YEAR
en fonction de votre type de partitionnement. Vous pouvez fournir la définition du schéma de table intégrée ou un fichier de schéma JSON. Les paramètres facultatifs incluent --expiration
, --description
, --time_partitioning_expiration
, --destination_kms_key
et --label
. Si vous créez une table dans un projet autre que votre projet par défaut, ajoutez l'ID du projet au nom de l'ensemble de données, en respectant le format suivant : project_id:dataset
.
--destination_kms_key
n'est pas présenté ici. Pour plus d'informations sur l'utilisation de cette option, consultez la section Protéger des données avec des clés Cloud KMS.
Saisissez la commande suivante pour créer une table partitionnée par temps d'ingestion vide avec une définition de schéma :
bq mk --table \ --expiration integer1 \ --time_partitioning_type=unit_time \ --time_partitioning_expiration integer2 \ --description "description" \ -label key:value,key:value \ project_id:dataset.table \ schema
Où :
- integer1 est la durée de vie par défaut (en secondes) de la table. La valeur minimale est de 3 600 secondes (une heure). Le délai d'expiration correspond à l'heure actuelle plus la valeur entière. Si vous définissez le délai d'expiration de la table lorsque vous créez une table partitionnée, le paramètre d'expiration de la table par défaut de l'ensemble de données est ignoré. La définition de cette valeur supprime la table et toutes les partitions après le délai indiqué.
- unit_time est soit
DAY
,HOUR
,MONTH
ouYEAR
selon votre type de partitionnement. La valeur par défaut estDAY
sitime_partitioning_type
n'est pas spécifié. - integer2 est la durée de vie par défaut (en secondes) des partitions de la table. Il n'y a pas de valeur minimale. Le délai d'expiration correspond à la date de la partition plus la valeur entière. Le délai d'expiration de la partition est indépendant du délai d'expiration de la table, mais il ne l'ignore pas. Si vous définissez un délai d'expiration de partition plus long que celui de la table, le délai d'expiration de la table est prioritaire.
- description est la description de la table entre guillemets.
- key:value est la paire clé-valeur qui représente un libellé. Vous pouvez entrer plusieurs libellés en utilisant une liste séparée par des virgules.
- project_id est l'ID de votre projet.
- dataset est un ensemble de données dans votre projet.
- table est le nom de la table partitionnée par date que vous créez.
- schema est une définition de schéma intégrée au format column:data_type,column:data_type ou le chemin d'accès au fichier de schéma JSON sur votre machine locale.
Lorsque vous spécifiez le schéma sur la ligne de commande, vous ne pouvez pas inclure de type RECORD
(STRUCT
), ni de description de colonne. Vous ne pouvez pas non plus spécifier le mode de la colonne. Tous les modes par défaut sont définis sur NULLABLE
. Pour inclure des descriptions, des modes et des types RECORD
, fournissez un fichier de schéma JSON à la place.
Exemples :
Saisissez la commande suivante pour créer une table partitionnée par date d'ingestion nommée mytable
dans mydataset
dans votre projet par défaut. Le type de partitionnement est défini sur DAY
, le délai d'expiration du partitionnement sur 259 200 secondes (trois jours), le délai d'expiration de la table sur 2 592 000 secondes (un mois de 30 jours), la description sur This is my time partitioned table
et le libellé sur organization:development
. La commande utilise le raccourci -t
au lieu de --table
. Le schéma est spécifié de manière intégrée comme suit : qtr:STRING,sales:FLOAT,year:STRING
.
bq mk -t \
--expiration 2592000 \
--time_partitioning_type=DAY \
--time_partitioning_expiration 259200 \
--description "This is my time partitioned table" \
--label organization:development \
mydataset.mytable \
qtr:STRING,sales:FLOAT,year:STRING
Saisissez la commande suivante pour créer une table partitionnée par date nommée mytable
dans myotherproject
, et non dans votre projet par défaut. Le type de partitionnement est défini sur DAY
, le délai d'expiration du partitionnement sur 259 200 secondes (trois jours), la description sur This is my time partitioned table
et le libellé sur organization:development
. La commande utilise le raccourci -t
au lieu de --table
. Cette commande ne spécifie pas de délai d'expiration de table. Si l'ensemble de données possède un délai d'expiration de table par défaut, celui-ci est appliqué. Si l'ensemble de données n'a pas de délai d'expiration de table par défaut, la table n'expirera jamais, mais les partitions expireront dans trois jours. Le chemin d'accès au fichier de schéma est le suivant : /tmp/myschema.json
.
bq mk -t \
--time_partitioning_type=DAY \
--time_partitioning_expiration 259200 \
--description "This is my time partitioned table" \
--label organization:development \
myotherproject:mydataset.mytable \
/tmp/myschema.json
Une fois la table créée, vous pouvez mettre à jour sa date et son heure d'expiration, sa description, ses libellés, ainsi que la date et l'heure d'expiration de la partition.
API
Appelez la méthode tables.insert
avec une ressource de table définie qui spécifie les propriétés timePartitioning
et schema
.
Créer une table partitionnée par date d'ingestion à partir d'un résultat de requête
Pour créer une table partitionnée à partir d'un résultat de requête, écrivez les résultats dans une nouvelle table de destination. Vous pouvez créer une table partitionnée en interrogeant une table partitionnée ou une table non partitionnée. En revanche, il n'est pas possible de modifier une table existante en table partitionnée avec des résultats de requêtes.
Pour en savoir plus sur l'interrogation des tables partitionnées par date, consultez la page Interroger des tables partitionnées.
Console
Vous ne pouvez pas spécifier d'options de partitionnement pour une table de destination lorsque vous interrogez des données à l'aide de Cloud Console.
bq
Saisissez la commande bq query
, spécifiez l'option --destination_table
pour créer une table permanente basée sur les résultats de la requête et spécifiez l'option --time_partitioning_type
pour créer une table de destination partitionnée par date d'ingestion. DAY
, HOUR
, MONTH
et YEAR
sont les valeurs acceptées pour --time_partitioning_type
, en fonction de la granularité de votre partition.
Spécifiez l'option use_legacy_sql=false
pour utiliser la syntaxe SQL standard.
Pour écrire les résultats de la requête dans une table qui ne se trouve pas dans votre projet par défaut, ajoutez l'ID du projet au nom de l'ensemble de données, en respectant le format suivant : project_id:dataset.
(Facultatif) Spécifiez l'option --location
et définissez la valeur correspondant à votre emplacement.
Saisissez la commande suivante pour créer une table de destination partitionnée par date d'ingestion à partir d'un résultat de requête :
bq --location=location query \ --destination_table project_id:dataset.table \ --time_partitioning_type=unit_time \ --use_legacy_sql=false \ 'query'
Où :
- location est le nom du site. L'option
--location
est facultative. Par exemple, si vous utilisez BigQuery dans la région de Tokyo, vous pouvez définir la valeur de l'option surasia-northeast1
. Vous pouvez définir une valeur par défaut pour l'emplacement à l'aide du fichier .bigqueryrc. - project_id est l'ID de votre projet.
- dataset est le nom de l'ensemble de données qui contiendra la nouvelle table partitionnée par date.
- table est le nom de la table partitionnée par date que vous créez à l'aide des résultats de la requête.
- unit_time est soit
DAY
,HOUR
,MONTH
ouYEAR
, selon votre type de partitionnement. La valeur par défaut estDAY
lorsquetime_partitioning_type
n'est pas spécifié.
- unit_time est soit
- query est une requête en syntaxe SQL standard.
Exemples :
Saisissez la commande suivante pour écrire les résultats de la requête dans une table de destination partitionnée par jour d'ingestion, nommée mytable
dans mydataset
. L'ensemble de données se trouve dans votre projet par défaut. La requête extrait les données d'une table non partitionnée, l'ensemble de données public USA Name Data.
bq query \
--destination_table mydataset.mytable \
--time_partitioning_type=DAY \
--use_legacy_sql=false \
'SELECT
name,
number
FROM
`bigquery-public-data`.usa_names.usa_1910_current
WHERE
gender = "M"
ORDER BY
number DESC'
Saisissez la commande suivante pour écrire les résultats de la requête dans une table de destination partitionnée par date d'ingestion, nommée mytable
dans mydataset
, partitionnée par la date d'ingestion des données. L'ensemble de données se trouve dans myotherproject
, et non dans votre projet par défaut. La requête extrait les données d'une table non partitionnée, l'ensemble de données public USA Name Data.
bq query \
--destination_table myotherproject:mydataset.mytable \
--time_partitioning_type=DAY \
--use_legacy_sql=false \
'SELECT
name,
number
FROM
`bigquery-public-data`.usa_names.usa_1910_current
WHERE
gender = "M"
ORDER BY
number DESC'
API
Pour enregistrer les résultats de requête dans une table partitionnée par date d'ingestion, appelez la méthode jobs.insert
, configurez une tâche query
et ajoutez une valeur pour les propriétés destinationTable
et timePartitioning
.
Créer une table partitionnée par date d'ingestion lors du chargement des données
Vous pouvez créer une table partitionnée par date d'ingestion en spécifiant les options de partitionnement lorsque vous chargez des données dans une nouvelle table. Vous n'avez pas besoin de créer une table partitionnée vide avant de charger des données. Vous pouvez créer la table partitionnée et charger vos données en même temps.
Lorsque vous chargez des données dans BigQuery, vous pouvez fournir le schéma de la table ou utiliser la détection automatique de schéma pour les formats de données compatibles.
Les décorateurs de partition vous permettent de charger des données dans une partition spécifique. Pour ajuster les fuseaux horaires, utilisez un décorateur de partition pour charger les données dans une partition en fonction de votre fuseau horaire préféré. Par exemple, si vous êtes à l'heure normale du Pacifique (PST), chargez toutes les données générées le 1er mai 2016 PST dans la partition pour cette date, avec le décorateur de partition correspondant :
table_name$20160501
Pour en savoir plus sur le chargement des données, consultez la page intitulée Présentation du chargement de données dans BigQuery.
Convertir des tables segmentées par date en tables partitionnées par date d'ingestion
Si vous avez déjà créé des tables segmentées par date, vous pouvez convertir l'ensemble des tables associées en une seule table partitionnée par date d'ingestion en exécutant la commande partition
de l'outil de ligne de commande bq
. Les tables segmentées par date doivent respecter la convention d'attribution de noms suivante : table_YYYYMMDD
.
Par exemple : mytable_20160101
, … , mytable_20160331
.
Les paramètres facultatifs sont --time_partitioning_expiration
, --location
et --time_partitioning_type
. Si aucune valeur n'est spécifiée, --time_partitioning_type
est défini par défaut sur DAY
. Si vos tables sources ou votre table de destination se trouvent dans un projet autre que votre projet par défaut, ajoutez l'ID du projet au nom de l'ensemble de données au format suivant : project_id:dataset.
Saisissez la commande suivante pour convertir une série de tables segmentées par date en une seule table partitionnée par date d'ingestion, partitionnée par date :
bq --location=location partition \ --time_partitioning_type=DAY \ --time_partitioning_expiration integer \ project_id:dataset.source_table_ \ project_id:dataset.destination_table
Où :
- location est le nom du site. L'option
--location
est facultative. Par exemple, si vous utilisez BigQuery dans la région de Tokyo, vous pouvez définir la valeur de l'option surasia-northeast1
. Vous pouvez définir une valeur par défaut correspondant à l'emplacement en utilisant le fichier .bigqueryrc. - integer est la durée de vie par défaut (en secondes) des partitions de la table. Il n'y a pas de valeur minimale. Le délai d'expiration correspond à la date de la partition plus la valeur entière. Le délai d'expiration de la partition est indépendant du délai d'expiration de la table, mais il ne l'ignore pas. Si vous définissez un délai d'expiration de partition plus long que celui de la table, le délai d'expiration de la table est prioritaire.
- project_id est l'ID de votre projet.
- dataset est un ensemble de données dans votre projet.
- sourcetable est le préfixe de votre table segmentée par date.
- destination_table est le nom de la table partitionnée que vous créez.
Exemples :
Saisissez la commande suivante pour créer une table partitionnée par date d'ingestion nommée mytable_partitioned
dans mydataset
dans votre projet par défaut. La table sera partitionnée par date, avec un délai d'expiration de partitionnement défini sur 259 200 secondes (trois jours). Le nom des tables sources segmentées par date commence par sourcetable_
. Les tables sources se trouvent également dans votre projet par défaut.
bq partition \
--time_partitioning_type=DAY \
--time_partitioning_expiration 259200 \
mydataset.sourcetable_ \
mydataset.mytable_partitioned
Lorsque vous exécutez la commande, une tâche de copie est créée pour générer des partitions à partir des tables segmentées. Par exemple, si les tables segmentées par date sont sourcetable_20180126
et sourcetable_20180127
, la tâche de copie crée les partitions suivantes : mydataset.mytable_partitioned$20180126
et mydataset.mytable_partitioned$20180127
.
Entrez la commande suivante pour créer une table partitionnée par date d'ingestion nommée mytable_partitioned
dans mydataset
. mydataset
se trouve dans myotherproject
, et non dans votre projet par défaut. La table sera partitionnée par date, avec un délai d'expiration de partitionnement défini sur 86 400 secondes (un jour). Le nom des tables sources segmentées par date commence par sourcetable_
. Les tables sources se trouvent dans votre projet par défaut.
bq partition \
--time_partitioning_type=DAY \
--time_partitioning_expiration 86400 \
mydataset.sourcetable_ \
myotherproject:mydataset.mytable_partitioned
Saisissez la commande suivante pour créer une table partitionnée par date d'ingestion nommée mytable_partitioned
dans mydataset
dans votre projet par défaut. mydataset
a été créé dans la région asia-northeast1
. La table sera partitionnée par date, avec un délai d'expiration de partitionnement défini sur 259 200 secondes (trois jours). Le nom des tables sources segmentées par date commence par sourcetable_
. Les tables sources se trouvent également dans votre projet par défaut.
bq --location=asia-northeast1 partition \
--time_partitioning_type=DAY \
--time_partitioning_expiration 259200 \
mydataset.sourcetable_ \
mydataset.mytable_partitioned
Contrôler l'accès aux tables partitionnées par date
Pour configurer l'accès aux tables et aux vues, vous pouvez attribuer un rôle IAM à une entité située aux niveaux suivants, classés par ordre de ressources autorisées (de la plus grande à la plus petite) :
- À un niveau élevé dans la hiérarchie des ressources Google Cloud, tel qu'au niveau du projet, du dossier ou de l'organisation
- Au niveau de l'ensemble de données
- Au niveau de la table ou de la vue
L'accès avec n'importe quelle ressource protégée par IAM est cumulatif. Par exemple, si une entité n'a pas accès au niveau supérieur (un projet, par exemple), vous pouvez lui accorder l'accès au niveau de l'ensemble de données afin qu'elle ait accès aux tables et aux vues de l'ensemble de données. De même, si l'entité n'a pas accès au niveau supérieur ou au niveau de l'ensemble de données, vous pouvez lui accorder l'accès au niveau de la table de vue.
L'attribution de rôles IAM à un niveau supérieur dans la hiérarchie des ressources Google Cloud (au niveau du projet, du dossier ou de l'organisation) permet à l'entité d'accéder à un vaste ensemble de ressources. Par exemple, si vous attribuez un rôle à une entité au niveau du projet, elle obtient des autorisations qui s'appliquent à tous les ensembles de données du projet.
L'attribution d'un rôle au niveau de l'ensemble de données spécifie les opérations qu'une entité est autorisée à effectuer sur les tables et les vues de cet ensemble de données spécifique, même si cette entité n'a pas accès à un niveau supérieur. Pour en savoir plus sur la configuration des contrôles d'accès aux ensembles de données, consultez la page Contrôler l'accès aux ensembles de données.
L'attribution d'un rôle au niveau de la table ou de la vue spécifie les opérations qu'une entité est autorisée à effectuer sur des tables et des vues spécifiques, même si cette entité n'a pas accès à un niveau supérieur. Pour en savoir plus sur la configuration des contrôles d'accès au niveau des tables, consultez la page Contrôler l'accès aux tables et aux vues.
Vous pouvez également créer des rôles personnalisés IAM. Si vous créez un rôle personnalisé, les autorisations que vous accordez dépendent des opérations spécifiques que vous souhaitez autoriser l'entité à effectuer.
Vous ne pouvez pas définir une autorisation "deny" sur une ressource protégée par IAM.
Pour en savoir plus sur les rôles et les autorisations, consultez les pages suivantes :
- Comprendre les rôles dans la documentation IAM
- Rôles et autorisations BigQuery prédéfinis
- Contrôler l'accès aux ensembles de données
- Contrôler l'accès aux tables et aux vues
- Restreindre l'accès avec la sécurité au niveau des colonnes de BigQuery
Utiliser des tables partitionnées par date d'ingestion
Obtenir des informations sur les tables partitionnées par date d'ingestion
Vous pouvez obtenir des informations sur les tables à l'aide des opérations suivantes :
- Utiliser Cloud Console
- En utilisant la commande
bq show
de l'outil de ligne de commandebq
- En appelant la méthode API
tables.get
- En utilisant les bibliothèques clientes
Autorisations requises
Pour obtenir des informations sur les tables, vous devez au minimum disposer des autorisations bigquery.tables.get
. Les rôles IAM prédéfinis suivants incluent les autorisations bigquery.tables.get
:
bigquery.metadataViewer
bigquery.dataViewer
bigquery.dataOwner
bigquery.dataEditor
bigquery.admin
En outre, si un utilisateur possède les autorisations bigquery.datasets.create
, il obtient également un accès bigquery.dataOwner
à l'ensemble de données qu'il crée.
L'accès bigquery.dataOwner
permet à l'utilisateur d'obtenir des informations sur les tables d'un ensemble de données.
Pour en savoir plus sur les rôles et les autorisations IAM dans BigQuery, consultez la page Rôles prédéfinis et autorisations.
Obtenir des informations sur les tables partitionnées par temps d'ingestion
Pour afficher des informations sur une table partitionnée par temps d'ingestion, procédez comme suit :
Console
Ouvrez la page "BigQuery" dans Cloud Console.
Dans le panneau Explorateur, développez votre projet et votre ensemble de données, puis sélectionnez la table.
Cliquez sur le nom de la table.
Cliquez sur Détails. Cet onglet affiche la description de la table et ses informations.
Cliquez sur l'onglet Schéma pour afficher la définition du schéma de la table. Vous remarquerez que la pseudo-colonne supplémentaire
_PARTITIONTIME
contient l'horodatage basé sur la date pour les données chargées dans la table.
bq
Exécutez la commande bq show
pour afficher toutes les informations sur la table. L'option --schema
permet de n'afficher que les informations de schéma de table. L'option --format
peut être utilisée pour contrôler le résultat.
Si vous souhaitez obtenir des informations sur une table se trouvant dans un projet autre que celui par défaut, ajoutez l'ID du projet au nom de l'ensemble de données, en respectant le format suivant : project_id:dataset.
bq show --schema --format=prettyjson <var>project_id:dataset.table</var>
Où :
- project_id est l'ID de votre projet.
- dataset est le nom de l'ensemble de données.
- table est le nom de la table.
Exemples :
Saisissez la commande suivante pour afficher toutes les informations sur la table mytable
dans mydataset
. mydataset
se trouve dans votre projet par défaut.
bq show --format=prettyjson mydataset.mytable
Saisissez la commande suivante pour afficher toutes les informations sur la table mytable
dans mydataset
. mydataset
se trouve dans le projet myotherproject
, et non dans votre projet par défaut.
bq show --format=prettyjson myotherproject:mydataset.mytable
Saisissez la commande suivante pour n'afficher que les informations de schéma sur mytable
dans mydataset
. mydataset
se trouve dans myotherproject
, et non dans votre projet par défaut.
Lorsque vous affichez les informations de schéma d'une table partitionnée par date, la pseudo-colonne _PARTITIONTIME
n'est pas visible.
bq show --schema --format=prettyjson myotherproject:mydataset.mytable
API
Appelez la méthode bigquery.tables.get
et définissez tous les paramètres pertinents.
Répertorier les tables partitionnées par date d'ingestion dans un ensemble de données
Vous pouvez répertorier des tables dans des ensembles de données (y compris des tables partitionnées) à l'aide de Cloud Console ou de la commande bq ls
de l'outil de ligne de commande bq
, ou en appelant la méthode API tables.list
.
Autorisations requises
Pour répertorier les tables d'un ensemble de données, vous devez au minimum disposer des autorisations bigquery.tables.list
. Les rôles IAM prédéfinis suivants incluent les autorisations bigquery.tables.list
:
bigquery.user
bigquery.metadataViewer
bigquery.dataViewer
bigquery.dataOwner
bigquery.dataEditor
bigquery.admin
Pour en savoir plus sur les rôles et les autorisations IAM dans BigQuery, consultez la page Rôles et autorisations prédéfinis.
Répertorier des tables partitionnées
Pour répertorier les tables d'un ensemble de données (y compris les tables partitionnées) :
Console
Ouvrez la page "BigQuery" dans Cloud Console.
Dans le panneau Explorateur, développez votre projet et votre ensemble de données, puis sélectionnez la table.
Faites défiler la liste pour voir les tables de l'ensemble de données. Les tables, les tables partitionnées, les modèles et les vues sont identifiés par des icônes différentes.
bq
Exécutez la commande bq ls
. L'option --format
peut être utilisée pour contrôler le résultat. Si vous répertoriez des tables dans un projet autre que votre projet par défaut, ajoutez l'ID du projet à l'ensemble de données, en respectant le format suivant : project_id:dataset.
bq ls --format=pretty project_id:dataset
Où :
- project_id est l'ID de votre projet.
- dataset est le nom de l'ensemble de données.
Lorsque vous exécutez la commande, le champ Type
affiche TABLE
ou VIEW
. Pour les tables partitionnées par date d'ingestion, le champ Time Partitioning
affiche DAY
et le délai d'expiration de la partition est exprimé en millisecondes, si l'expiration de la partition est spécifiée.
Exemple :
+-------------------------+-------+----------------------+--------------------------------+ | tableId | Type | Labels | Time Partitioning | +-------------------------+-------+----------------------+--------------------------------+ | mytable | TABLE | department:shipping | DAY (expirationMs: 259200000) | | myview | VIEW | | | +-------------------------+-------+----------------------+--------------------------------+
Exemples :
Saisissez la commande suivante pour répertorier les tables de l'ensemble de données mydataset
dans votre projet par défaut.
bq ls --format=pretty mydataset
Saisissez la commande suivante pour répertorier les tables de l'ensemble de données mydataset
dans myotherproject
.
bq ls --format=pretty myotherproject:mydataset
API
Pour répertorier les tables à l'aide de l'API, appelez la méthode tables.list
.
Répertorier des partitions dans des tables partitionnées par date d'ingestion
Pour répertorier les partitions dans une table partitionnée par date d'ingestion, vous pouvez interroger la pseudo-colonne _PARTITIONTIME
en SQL standard ou la métatable __PARTITIONS_SUMMARY__
en ancien SQL.
Vous pouvez exécuter la requête à l'aide de Cloud Console, en exécutant la commande bq query
de l'outil de ligne de commande bq
, ou en appelant la méthode jobs.insert
et en configurant une tâche de requête (query
).
Autorisations requises
Pour exécuter une tâche de requête qui utilise la métatable __PARTITIONS_SUMMARY__
ou la pseudo-colonne _PARTITIONTIME
, vous devez disposer des autorisations bigquery.jobs.create
. Les rôles IAM prédéfinis suivants incluent les autorisations bigquery.jobs.create
:
bigquery.user
bigquery.jobUser
bigquery.admin
Vous devez également disposer des autorisations bigquery.tables.getData
. Les rôles IAM prédéfinis suivants incluent les autorisations bigquery.tables.getData
:
bigquery.admin
bigquery.dataEditor
bigquery.dataOwner
bigquery.dataViewer
Pour en savoir plus sur les rôles et les autorisations IAM dans BigQuery, consultez la page Rôles prédéfinis et autorisations.
Répertorier des partitions dans une table partitionnée par temps d'ingestion
Vous pouvez répertorier des partitions dans une table partitionnée par date d'ingestion en langage SQL standard (méthode recommandée) ou en ancien SQL. Pour répertorier des partitions, procédez comme suit :
Langage SQL standard :
Console
Ouvrez la page "BigQuery" dans Cloud Console.
Cliquez sur le bouton Saisir une nouvelle requête.
Saisissez le texte suivant dans la zone Éditeur de requête pour interroger la pseudo-colonne
_PARTITIONTIME
:SELECT _PARTITIONTIME as pt FROM `dataset.table` GROUP BY 1
Où :
- dataset est l'ensemble de données qui contient la table.
- table est le nom de la table.
(Facultatif) Cliquez sur More (Plus) et sélectionnez Query settings (Paramètres de requête).
Cliquez sur Run (Exécuter).
bq
Saisissez la requête suivante à l'aide de la commande bq query
:
bq --location=location query --use_legacy_sql=false ' SELECT _PARTITIONTIME as pt FROM `dataset.table` GROUP BY 1'
Où :
- location est le nom du site. L'option
--location
est facultative. Par exemple, si vous utilisez BigQuery dans la région de Tokyo, vous pouvez définir la valeur de l'option surasia-northeast1
. Vous pouvez définir une valeur par défaut correspondant à l'emplacement en utilisant le fichier .bigqueryrc. - dataset est l'ensemble de données qui contient la table.
- table est le nom de la table.
API
Appelez la méthode jobs.insert
et configurez une tâche query
qui interroge la pseudo-colonne _PARTITIONTIME
du tableau.
Spécifiez votre emplacement dans la propriété location
de la section jobReference
de la ressource de tâche.
Ancien SQL :
Console
Ouvrez la page "BigQuery" dans Cloud Console.
Cliquez sur le bouton Saisir une nouvelle requête.
Saisissez le texte suivant dans la zone Éditeur de requête pour interroger la métatable
__PARTITIONS_SUMMARY__
:#legacySQL SELECT partition_id FROM [dataset.table$__PARTITIONS_SUMMARY__]
Où :
- dataset est l'ensemble de données qui contient la table.
- table est le nom de la table.
Cliquez sur More (Plus) et sélectionnez Query settings (Paramètres de requête).
Dans le champ Zone de traitement, cliquez sur Sélection automatique et choisissez l'emplacement de vos données. Si vos données se trouvent dans l'emplacement multirégional
US
ouEU
, vous pouvez conserver la sélection automatique de la zone de traitement. Lorsque vos données se trouvent dans l'emplacementUS
ouEU
, la zone de traitement est automatiquement détectée.Cliquez sur Run (Exécuter).
bq
Saisissez la requête suivante à l'aide de la commande bq query
:
bq --location=location query --use_legacy_sql=true ' SELECT partition_id FROM [dataset.table$__PARTITIONS_SUMMARY__]'
Où :
- location est le nom du site. L'option
--location
est facultative. Par exemple, si vous utilisez BigQuery dans la région de Tokyo, vous pouvez définir la valeur de l'option surasia-northeast1
. Vous pouvez définir une valeur par défaut correspondant à l'emplacement en utilisant le fichier .bigqueryrc. - dataset est l'ensemble de données qui contient la table.
- table est le nom de la table.
API
Appelez la méthode jobs.insert
et configurez une tâche query
qui interroge la métatable __PARTITIONS_SUMMARY__
.
Spécifiez votre emplacement dans la propriété location
de la section jobReference
de la ressource de tâche.
Obtenir des métadonnées de tables avec des métatables
Vous pouvez obtenir des informations concernant les tables partitionnées en utilisant des tables spéciales appelées métatables. Les métatables contiennent des métadonnées telles que la liste des tables et des vues d'un ensemble de données. Les métatables sont en lecture seule.
Obtenir des métadonnées de partitions avec des métatables
La métatable __PARTITIONS_SUMMARY__
est une table spéciale dont le contenu représente des métadonnées relatives aux partitions d'une table partitionnée par date. La métatable __PARTITIONS_SUMMARY__
est en lecture seule.
Pour accéder aux métadonnées contenues dans les partitions d'une table partitionnée par date, utilisez la métatable __PARTITIONS_SUMMARY__
dans une instruction de requête SELECT
. Vous pouvez exécuter la requête à l'aide de l'une des méthodes suivantes :
- En utilisant Cloud Console
- En exécutant la commande
bq query
de l'outil de ligne de commandebq
- En appelant la méthode API
jobs.insert
et en configurant une tâche de requête (query
) - En utilisant les bibliothèques clientes
Actuellement, le SQL standard n'est pas compatible avec le séparateur de décorateur de partition ($
). Vous ne pouvez donc pas interroger __PARTITIONS_SUMMARY__
en SQL standard. Une requête en ancien SQL utilisant la métatable __PARTITIONS_SUMMARY__
ressemble à ce qui suit :
#legacySQL SELECT column FROM [dataset.table$__PARTITIONS_SUMMARY__]
Où :
- dataset est le nom de votre ensemble de données.
- table est le nom de la table partitionnée par date.
- column est l'un des éléments suivants :
Valeur | Description |
---|---|
project_id |
Nom du projet. |
dataset_id |
Nom de l'ensemble de données. |
table_id |
Nom de la table partitionnée par date. |
partition_id |
Nom (date) de la partition. |
creation_time |
Heure à laquelle la partition a été créée, exprimée en millisecondes depuis le 1er janvier 1970 UTC. |
last_modified_time |
Heure à laquelle la partition a été modifiée pour la dernière fois, exprimée en millisecondes depuis le 1er janvier 1970 UTC. |
Autorisations de partitionnement de métatables
Pour exécuter une tâche de requête qui utilise la métatable __PARTITIONS_SUMMARY__
, vous devez au minimum disposer des autorisations bigquery.jobs.create
. Les rôles IAM prédéfinis suivants incluent les autorisations bigquery.jobs.create
:
bigquery.user
bigquery.jobUser
bigquery.admin
Vous devez également disposer des autorisations bigquery.tables.getData
. Les rôles IAM prédéfinis suivants incluent les autorisations bigquery.tables.getData
:
bigquery.dataViewer
bigquery.dataEditor
bigquery.dataOwner
bigquery.admin
Pour en savoir plus sur les rôles IAM dans BigQuery, consultez la page Contrôle des accès.
Exemples de partitionnement de métatables
La requête suivante récupère toutes les métadonnées de partition pour une table partitionnée par date d'ingestion nommée mydataset.mytable
.
Console
#legacySQL SELECT * FROM [mydataset.mytable$__PARTITIONS_SUMMARY__]
bq
bq query --use_legacy_sql=true ' SELECT * FROM [mydataset.mytable$__PARTITIONS_SUMMARY__]'
La sortie ressemble à ceci :
+----------------+------------+----------------+--------------+---------------+--------------------+ | project_id | dataset_id | table_id | partition_id | creation_time | last_modified_time | +----------------+------------+----------------+--------------+---------------+--------------------+ | myproject | mydataset | mytable | 20160314 | 1517190224120 | 1517190224997 | | myproject | mydataset | mytable | 20160315 | 1517190224120 | 1517190224997 | +----------------+------------+----------------+--------------+---------------+--------------------+
La requête suivante répertorie les heures auxquelles les partitions de mydataset.mytable
ont été modifiées pour la dernière fois.
Console
#legacySQL SELECT partition_id, last_modified_time FROM [mydataset.mytable$__PARTITIONS_SUMMARY__]
bq
bq query --use_legacy_sql=true ' SELECT partition_id, last_modified_time FROM [mydataset.mytable$__PARTITIONS_SUMMARY__]'
La sortie ressemble à ceci :
+--------------+--------------------+ | partition_id | last_modified_time | +--------------+--------------------+ | 20160102 | 1471632556179 | | 20160101 | 1471632538142 | | 20160103 | 1471632570463 | +--------------+--------------------+
Pour afficher le champ last_modified_time
dans un format plus lisible, utilisez la fonction FORMAT_UTC_USEC
. Exemple :
Console
#legacySQL SELECT partition_id, FORMAT_UTC_USEC(last_modified_time*1000) AS last_modified FROM [mydataset.table1$__PARTITIONS_SUMMARY__]
bq
bq query --use_legacy_sql=true ' SELECT partition_id, FORMAT_UTC_USEC(last_modified_time*1000) AS last_modified FROM [mydataset.mytable$__PARTITIONS_SUMMARY__]'
La sortie ressemble à ceci :
+--------------+----------------------------+ | partition_id | last_modified | +--------------+----------------------------+ | 20160103 | 2016-08-19 18:49:30.463000 | | 20160102 | 2016-08-19 18:49:16.179000 | | 20160101 | 2016-08-19 18:48:58.142000 | +--------------+----------------------------+
Exemple : Créer une table partitionnée par date d'ingestion à l'aide des résultats de requête
Dans cet exemple, vous créez une table partitionnée par date d'ingestion avec l'outil de ligne de commande bq
et vous ajoutez des données à trois partitions à l'aide des résultats de requête. La table va contenir des données météorologiques, partitionnées par date, pour les trois premiers jours de 2016.
Cet exemple interroge l'ensemble de données météorologiques "Global Surface Summary of the Day" de l'Agence américaine d'observation océanique et atmosphérique (NOAA) pour connaître les températures des trois premiers jours de 2016 et écrire les résultats dans une table partitionnée.
Étape 1. Créez une table partitionnée par date d'ingestion vide, partitionnée par date, nommée temps
dans un ensemble de données nommé mydataset
. Vous n'avez pas à spécifier un schéma de table. Le schéma obtenu à partir des résultats de requête est utilisé comme définition de schéma de la table.
bq mk --time_partitioning_type=DAY mydataset.temps
Pour afficher les paramètres de configuration, exécutez la commande bq show
:
bq show --format=prettyjson mydataset.temps
Recherchez l'entrée timePartitioning
dans la sortie de la commande bq show
:
{ ... "timePartitioning": { "type": "DAY" }, "type": "TABLE" }
Étape 2 : Interrogez l'ensemble de données météorologiques "Global Surface Summary of the Day" de l'Agence américaine d'observation océanique et atmosphérique (NOAA) pour connaître les températures des trois premiers jours de 2016 et écrire les résultats dans les partitions correspondantes de la table temps
. Les requêtes suivantes écrivent 100 lignes de résultats de requête dans une partition à l'aide de l'option --destination_table
et de la syntaxe SQL standard.
Exécutez maintenant la requête suivante pour écrire les températures du 1er janvier 2016 dans la partition
mydataset.temps$20160101
:bq query --use_legacy_sql=false \ --destination_table 'mydataset.temps$20160101' \ 'SELECT stn, temp FROM `bigquery-public-data`.noaa_gsod.gsod2016 WHERE mo="01" AND da="01" LIMIT 100'
Exécutez maintenant la requête suivante pour écrire les températures du 2 janvier 2016 dans la partition
mydataset.temps$20160102
:bq --location=US query --use_legacy_sql=false \ --destination_table 'mydataset.temps$20160102' \ 'SELECT stn, temp FROM `bigquery-public-data`.noaa_gsod.gsod2016 WHERE mo="01" AND da="02" LIMIT 100'
Exécutez maintenant la requête suivante pour écrire les températures du 3 janvier 2016 dans la partition
mydataset.temps$20160103
:bq --location=US query --use_legacy_sql=false \ --destination_table 'mydataset.temps$20160103' \ 'SELECT stn, temp FROM `bigquery-public-data`.noaa_gsod.gsod2016 WHERE mo="01" AND da="03" LIMIT 100'
Étape 3 : À l'aide de la commande bq show
, confirmez que votre table possède 300 lignes.
bq show mydataset.temps
Les résultats affichent les colonnes "Schema" (Schéma) et "Total Rows" (Nombre total de lignes).
Last modified Schema Total Rows Total Bytes Expiration Time Partitioning Labels kmsKeyName ----------------- ---------------- ------------ ------------- ----------------- ------------------- -------- ------------ 28 Jan 15:03:45 |- stn: string 300 4800 29 Jan 15:00:32 DAY |- temp: float
Étapes suivantes
- Pour une présentation de la compatibilité des tables partitionnées dans BigQuery, consultez la page Présentation des tables partitionnées.
- Pour savoir comment gérer et mettre à jour des tables partitionnées, consultez la page Gérer des tables partitionnées.
- Pour en savoir plus sur l'interrogation des tables partitionnées, consultez la page Interroger des tables partitionnées.
- Pour plus d'informations sur les tables partitionnées basées sur des colonnes, consultez la page Créer et utiliser des tables partitionnées par date basées sur des colonnes.
- Pour plus d'informations sur les tables partitionnées par plages d'entiers, consultez la page Créer et utiliser des tables partitionnées par plages d'entiers.