MaxCompute:Manage tables

Définir explicitement les colonnes et les partitions

Importez les classes Schema, Column et Partition depuis le module odps.models, puis transmettez les listes de colonnes et de partitions au constructeur Schema. Cette approche prend en charge le paramètre comment pour chaque colonne et partition.

from odps.models import Schema, Column, Partition
columns = [
    Column(name='num', type='bigint', comment='the column'),
    Column(name='num2', type='double', comment='the column2'),
]
partitions = [Partition(name='pt', type='string', comment='the partition')]
schema = Schema(columns=columns, partitions=partitions)

Après avoir créé un schéma, inspectez son contenu à l'aide des propriétés suivantes :

• Toutes les colonnes (y compris les clés de partition) : Sortie :

    print(schema.columns)

    [<column num, type bigint>,
     <column num2, type double>,
     <partition pt, type string>]

• Uniquement les clés de partition : Sortie :

    print(schema.partitions)

    [<partition pt, type string>]

• Noms des colonnes non partitionnées : Sortie :

    print(schema.names)

    ['num', 'num2']

• Types de données des colonnes non partitionnées : Sortie :

    print(schema.types)

    [bigint, double]

Utiliser Schema.from_lists()

La méthode Schema.from_lists() constitue une syntaxe abrégée qui accepte des listes de noms et de types. Bien que plus simple, cette méthode ne permet pas de définir directement des commentaires pour les colonnes ou les partitions.

from odps.models import Schema
schema = Schema.from_lists(['num', 'num2'], ['bigint', 'double'], ['pt'], ['string'])
print(schema.columns)

Sortie :

[<column num, type bigint>,
 <column num2, type double>,
 <partition pt, type string>]

Créer une table à partir d'un schéma

Commencez par construire un objet Schema, puis transmettez-le à la méthode create_table().

# Create a table schema.
from odps.models import Schema
schema = Schema.from_lists(['num', 'num2'], ['bigint', 'double'], ['pt'], ['string'])

# Create a table by using the schema that you created.
table = o.create_table('my_new_table', schema)

# Create a table only if no table with the same name exists.
table = o.create_table('my_new_table', schema, if_not_exists=True)

# Configure the lifecycle of the table.
table = o.create_table('my_new_table', schema, lifecycle=7)

Vérifiez que la table a bien été créée :

print(o.exist_table('my_new_table'))

Si la valeur True est renvoyée, la table a été créée avec succès.

Créer une table à partir de définitions de colonnes

Transmettez les noms et types de données des colonnes sous forme de chaîne ou de tuple à la méthode create_table().

# Create a partitioned table named my_new_table with specified common columns and partition key columns.
table = o.create_table('my_new_table', ('num bigint, num2 double', 'pt string'), if_not_exists=True)

# Create a non-partitioned table named my_new_table02.
table = o.create_table('my_new_table02', 'num bigint, num2 double', if_not_exists=True)

Vérifiez que la table a bien été créée :

print(o.exist_table('my_new_table'))

Si la valeur True est renvoyée, la table a été créée avec succès.

Activer les types de données étendus MaxCompute V2.0

Par défaut, la méthode create_table() prend uniquement en charge les types de données BIGINT, DOUBLE, DECIMAL, STRING, DATETIME, BOOLEAN, MAP et ARRAY. Pour utiliser des types de données supplémentaires tels que TINYINT et STRUCT, définissez l'option options.sql.use_odps2_extension sur True.

from odps import options
options.sql.use_odps2_extension = True
table = o.create_table('my_new_table', 'cat smallint, content struct<title:varchar(100), body:string>')

Vérifier si une table est partitionnée

table = o.get_table('my_new_table')
if table.schema.partitions:
    print('Table %s is partitioned.' % table.name)

Parcourir les partitions

table = o.get_table('my_new_table')
for partition in table.partitions:  # Iterate over all partitions.
    print(partition.name)  # An iteration step. In this step, the partition name is displayed.
for partition in table.iterate_partitions(spec='pt=test'):  # Iterate over level-2 partitions in the partition named test.
    print(partition.name)  # An iteration step. In this step, the partition name is displayed.
for partition in table.iterate_partitions(spec='dt>20230119'):  # Iterate over level-2 partitions in the partitions that meet the dt>20230119 condition.
    print(partition.name)  # An iteration step. In this step, the partition name is displayed.

Vérifier l'existence d'une partition

table = o.get_table('my_new_table')
table.exist_partition('pt=test,sub=2015')

Obtenir des informations sur une partition

table = o.get_table('my_new_table')
partition = table.get_partition('pt=test')
print(partition.creation_time)
partition.size

Créer une partition

t = o.get_table('my_new_table')
t.create_partition('pt=test', if_not_exists=True)  # Create a partition only if no partition with the same name exists.

Supprimer une partition

t = o.get_table('my_new_table')
t.delete_partition('pt=test', if_exists=True)  # Set the if_exists parameter to True. This ensures that a partition is deleted only if the partition exists.
partition.drop()  # Call the drop() method to drop a partition if the partition exists.

Lire les N premiers enregistrements avec head()

La méthode head() permet de récupérer les 10 000 premiers enregistrements (ou moins) d'une table.

from odps import ODPS
t = o.get_table('dual')
for record in t.head(3):
    # Process each record.

Lire avec open_reader() en utilisant une instruction with

with t.open_reader(partition='pt=test') as reader:
count = reader.count
for record in reader[5:10]  # You can execute the statement multiple times until all records are read. The number of records is specified by count. You can change the code to parallel-operation code.
    # Process one record.

Lire avec open_reader() sans instruction with

reader = t.open_reader(partition='pt=test')
count = reader.count
for record in reader[5:10]  # You can execute the statement multiple times until all records are read. The number of records is specified by count. You can change the code to parallel-operation code.
    # Process one record.

Lire directement dans un DataFrame pandas

with t.open_reader(partition='pt=test') as reader:
pd_df = reader.to_pandas()

Écrire avec open_writer() en utilisant une instruction with

with t.open_writer(partition='pt=test') as writer:
	  records = [[111, 'aaa', True],                 # A list can be used.
	             [222, 'bbb', False],
	             [333, 'ccc', True],
	             [444, 'Chinese', False]]
    writer.write(records)  # Records can be iterable objects.

records = [t.new_record([111, 'aaa', True]),   # Record objects can be used.
           t.new_record([222, 'bbb', False]),
           t.new_record([333, 'ccc', True]),
           t.new_record([444, 'Chinese', False])]
writer.write(records)

Transmettez soit des listes simples, soit des objets Record (créés avec t.new_record()) à la méthode writer.write().

Créer automatiquement une partition lors de l'écriture

Définissez create_partition=True pour créer automatiquement la partition si elle n'existe pas.

with t.open_writer(partition='pt=test', create_partition=True) as writer:
    records = [[111, 'aaa', True],                 # A list can be used.
               [222, 'bbb', False],
               [333, 'ccc', True],
               [444, 'Chinese', False]]
    writer.write(records)  # Records can be iterable objects.

Écrire avec write_table()

La méthode write_table() de l'objet d'entrée MaxCompute offre une interface simplifiée pour l'écriture de données.

records = [[111, 'aaa', True],                 # A list can be used.
           [222, 'bbb', False],
           [333, 'ccc', True],
           [444, 'Chinese', False]]
o.write_table('test_table', records, partition='pt=test', create_partition=True)