MaxCompute:Manage tables

Defina colunas e partições explicitamente

Importe Schema, Column e Partition de odps.models, depois passe as listas de colunas e partições ao construtor de Schema. Essa abordagem aceita o parâmetro comment em cada coluna e partição.

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)

Após crie um schema, inspecione seu conteúdo com as seguintes propriedades:

• Todas as colunas (incluindo colunas de chave de partição): Saída:

    print(schema.columns)

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

• Somente colunas de chave de partição: Saída:

    print(schema.partitions)

    [<partition pt, type string>]

• Nomes de colunas não particionadas: Saída:

    print(schema.names)

    ['num', 'num2']

• Tipos de dados de colunas não particionadas: Saída:

    print(schema.types)

    [bigint, double]

Use Schema.from_lists()

Schema.from_lists() é uma forma abreviada que aceita listas de nomes e tipos. Esse método é mais simples, mas não oferece suporte a comentários de coluna ou partição diretamente.

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

Saída:

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

Crie uma tabela a partir de um schema

Crie um Schema primeiro e, em seguida, passe-o para 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)

Verifique se a tabela foi criada:

print(o.exist_table('my_new_table'))

Se True for retornado, a tabela foi criada com sucesso.

Crie uma tabela a partir de definições de colunas

Passe os nomes e tipos de dados das colunas como uma string ou tupla para 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)

Verifique se a tabela foi criada:

print(o.exist_table('my_new_table'))

Se True for retornado, a tabela foi criada com sucesso.

Ative os tipos de dados estendidos do MaxCompute V2.0

Por padrão, create_table() oferece suporte apenas aos tipos de dados BIGINT, DOUBLE, DECIMAL, STRING, DATETIME, BOOLEAN, MAP e ARRAY. Para usar tipos adicionais, como TINYINT e STRUCT, defina options.sql.use_odps2_extension como 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>')

Verificar se uma tabela é particionada

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

Iterar sobre partições

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.

Verificar se uma partição existe

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

Obter informações de uma partição

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

Criar uma partição

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.

Exclua uma partição

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.

Ler os primeiros N registros com head()

O método head() recupera até os primeiros 10.000 registros de uma tabela.

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

Ler com open_reader() usando uma instrução 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.

Ler com open_reader() sem uma instrução 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.

Ler diretamente em um pandas DataFrame

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

Gravar com open_writer() usando uma instrução 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)

Passe listas simples ou objetos Record (criados com t.new_record()) para writer.write().

Criar uma partição automaticamente ao gravar

Defina create_partition=True para criar a partição automaticamente caso ela não exista.

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.

Gravar com write_table()

O método write_table() no objeto de entrada do MaxCompute oferece uma interface mais simples para gravar dados.

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)