MaxCompute:Open Storage SDK examples - Java SDK

SplitOptions

• Definição de parâmetros

  Os parâmetros do objeto SplitOptions são definidos da seguinte forma:

  public class SplitOptions {
  
      public static SplitOptions.Builder newBuilder() {
          return new Builder();
      }
  
      public static class Builder {
  
        public SplitOptions.Builder SplitByByteSize(long splitByteSize);
    
        public SplitOptions.Builder SplitByRowOffset();
    
        public SplitOptions.Builder withCrossPartition(boolean crossPartition);
    
        public SplitOptions.Builder withMaxFileNum(int splitMaxFileNum);
    
        public SplitOptions build();
      }
  }

• Descrição dos parâmetros

  • SplitByByteSize(long splitByteSize)

    Divide os dados com base no parâmetro splitByteSize especificado. O tamanho de cada partição de dados retornada pelo servidor não excede splitByteSize (em bytes).

    • O tamanho personalizado da divisão deve ser de pelo menos 10 × 1024 × 1024 (10 MB).

    • Se SplitByByteSize(long splitByteSize) não for usado para personalizar o tamanho da divisão, o sistema utilizará o valor padrão de 256 × 1024 × 1024 (256 MB).

  • SplitByRowOffset()

    Divide os dados por linha, permitindo que o cliente leia dados a partir de um índice específico.

  • withCrossPartition(boolean crossPartition)

    Defina se um único shard de dados pode incluir múltiplas partições de dados. O parâmetro crossPartition aceita os seguintes valores:

    • true (padrão): permite que um único shard de dados contenha múltiplas partições de dados.

    • false: não permite essa configuração.

  • withMaxFileNum(int splitMaxFileNum)

    Quando uma tabela possui muitos arquivos, especifique o número máximo de arquivos físicos em uma única partição de dados para gerar mais partições.

    Por padrão, não há limite para o número de arquivos físicos em uma única partição de dados.

  • build(): Crie um objeto SplitOptions.

• Exemplos

  // 1. Split data by size, set SplitSize to 256 MB
  
  SplitOptions splitOptionsByteSize = 
        SplitOptions.newBuilder().SplitByByteSize(256 * 1024L * 1024L).build()
  
  // 2. Split data by RowOffset
  
  SplitOptions splitOptionsCount = 
        SplitOptions.newBuilder().SplitByRowOffset().build()
  
  // 3. Set the maximum number of files in a single split to 1
  
  SplitOptions splitOptionsCount = 
        SplitOptions.newBuilder().SplitByRowOffset().withMaxFileNum(1).build()

ArrowOptions

• Definição de parâmetros

  Os parâmetros do objeto ArrowOptions são definidos conforme abaixo:

  public class ArrowOptions {
      
      public static Builder newBuilder() {
          return new Builder();
      }
  
      public static class Builder {
  
          public Builder withTimestampUnit(TimestampUnit unit);
  
          public Builder withDatetimeUnit(TimestampUnit unit);
  
          public ArrowOptions build();
      }
  
      public enum TimestampUnit {
          SECOND,
          MILLI,
          MICRO,
          NANO;
      }
  }

• Descrição dos parâmetros

  • TimestampUnit

    Especifique a unidade para os tipos de dados Timestamp e Datetime. Valores válidos:

    • SECOND: segundos (s)

    • MILLI: milissegundos (ms)

    • MICRO: microssegundos (μs)

    • NANO: nanossegundos (ns)

  • withTimestampUnit(TimestampUnit unit)

    Defina a unidade para o tipo de dado Timestamp. Padrão: NANO.

  • withDatetimeUnit(TimestampUnit unit)

    Defina a unidade para o tipo de dado Datetime. Padrão: MILLI.

  • Exemplos

    ArrowOptions options = ArrowOptions.newBuilder()
              .withDatetimeUnit(ArrowOptions.TimestampUnit.MILLI)
              .withTimestampUnit(ArrowOptions.TimestampUnit.NANO)
              .build()

  Predicate

  Predicate

  • Definição de parâmetros

    Os parâmetros do objeto Predicate são definidos da seguinte forma:

    // 1. Binary operations
    
    public class BinaryPredicate extends Predicate {
    
      public enum Operator {
        /**
         * Binary operation operators
         */
        EQUALS("="),
        NOT_EQUALS("!="),
        GREATER_THAN(">"),
        LESS_THAN("<"),
        GREATER_THAN_OR_EQUAL(">="),
        LESS_THAN_OR_EQUAL("<=");
       
      }
    
      public BinaryPredicate(Operator operator, Serializable leftOperand, Serializable rightOperand);
    
      public static BinaryPredicate equals(Serializable leftOperand, Serializable rightOperand);
    
      public static BinaryPredicate notEquals(Serializable leftOperand, Serializable rightOperand);
    
      public static BinaryPredicate greaterThan(Serializable leftOperand, Serializable rightOperand);
    
      public static BinaryPredicate lessThan(Serializable leftOperand, Serializable rightOperand);
    
      public static BinaryPredicate greaterThanOrEqual(Serializable leftOperand,
                                                       Serializable rightOperand);
    
      public static BinaryPredicate lessThanOrEqual(Serializable leftOperand,
                                                    Serializable rightOperand);
    }
    
    // 2. Unary operations
    public class UnaryPredicate extends Predicate {
    
      public enum Operator {
        /**
         * Unary operation operators
         */
        IS_NULL("is null"),
        NOT_NULL("is not null");
      }
    
      public static UnaryPredicate isNull(Serializable operand);
      public static UnaryPredicate notNull(Serializable operand);
    }
    
    ### 3. IN and NOT IN
    public class InPredicate extends Predicate {
    
      public enum Operator {
        /**
         * IN and NOT IN operators for set membership check
         */
        IN("in"),
        NOT_IN("not in");
      }
    
      public InPredicate(Operator operator, Serializable operand, List<Serializable> set);
    
      public static InPredicate in(Serializable operand, List<Serializable> set);
    
      public static InPredicate notIn(Serializable operand, List<Serializable> set);
    }
    
    // 4. Column names
    public class Attribute extends Predicate {
    
      public Attribute(Object value);
        
      public static Attribute of(Object value);
    }
    
    // 5. Constants
    public class Constant extends Predicate {
    
      public Constant(Object value);
    
      public static Constant of(Object value);
    }
    
    // 6. Compound operations
    public class CompoundPredicate extends Predicate {
    
      public enum Operator {
        /**
         * Compound predicate operators
         */
        AND("and"),
        OR("or"),
        NOT("not");
      }
    
      public CompoundPredicate(Operator logicalOperator, List<Predicate> predicates);
    
      public static CompoundPredicate and(Predicate... predicates);
      
      public static CompoundPredicate or(Predicate... predicates);
    
      public static CompoundPredicate not(Predicate predicates);
    
      public void addPredicate(Predicate predicate);
    }
    
    // 7. Raw predicates (RawPredicate)
    // If existing methods do not meet requirements, assemble predicates based on SQL syntax
      public class RawPredicate extends Predicate {
          public RawPredicate(String rawExpr);
          public static RawPredicate of(String rawExpr);
      }

  • Exemplos

    // 1. c1 > 20000 and c2 < 100000
    BinaryPredicate c1 = new BinaryPredicate(BinaryPredicate.Operator.GREATER_THAN, Attribute.of("c1"), Constant.of(20000));
    BinaryPredicate c2 = new BinaryPredicate(BinaryPredicate.Operator.LESS_THAN, Attribute.of("c2"), Constant.of(100000));
    CompoundPredicate predicate =
            new CompoundPredicate(CompoundPredicate.Operator.AND, ImmutableList.of(c1, c2));
    
    // 2. c1 is not null
    Predicate predicate = new UnaryPredicate(UnaryPredicate.Operator.NOT_NULL,  Attribute.of("c1"));
    
      
    // 3. c1 in (1, 10001)
    Predicate predicate =
            new InPredicate(InPredicate.Operator.IN,  Attribute.of("c1"), ImmutableList.of(Constant.of(1), Constant.of(10001)));
    
    // 4. Use RawPredicate to assemble predicates (supports all types)
      Predicate predicate = RawPredicate.of("c1 > 20000 and c2 < 100000");

  EnvironmentSettings

  EnvironmentSettings

  • Definição de parâmetros

    A interface EnvironmentSettings é definida conforme abaixo:

    public class EnvironmentSettings {
    
        public static Builder newBuilder() {
            return new Builder();
        }
    
        public static class Builder {
    
            public Builder withDefaultProject(String projectName);
    
            public Builder withDefaultSchema(String schema);
    
            public Builder withServiceEndpoint(String endPoint);
    
            public Builder withTunnelEndpoint(String tunnelEndPoint);
    
            public Builder withQuotaName(String quotaName);
    
            public Builder withCredentials(Credentials credentials);
    
            public Builder withRestOptions(RestOptions restOptions);
    
            public EnvironmentSettings build();
        }
    }

  • Descrição dos parâmetros

    • withDefaultProject(String projectName)

      Defina o nome do projeto. O parâmetro projectName é o nome do projeto MaxCompute.

      • Faça login no console do MaxCompute e alterne a região no canto superior esquerdo.

      • Escolha Manage Configurations > Projects para visualizar o nome do projeto MaxCompute.

    • withDefaultSchema(String schema)

      Defina o schema padrão. O parâmetro schema é o nome do schema do MaxCompute. Para mais informações sobre schemas, consulte Schema operations.

    • withServiceEndpoint(String endPoint)

      Configura o endpoint do service. Consulte Endpoints.

    • withTunnelEndpoint(String tunnelEndPoint)

      Configura o endpoint do túnel. Consulte Endpoints.

    • withQuotaName(String quotaName)

      Especifique o nome da cota a ser utilizada.

      O MaxCompute suporta dois tipos de recursos: grupos de recursos exclusivos do Data Transmission Service (assinatura) Obtenha o nome da cota conforme descrito abaixo:

      • Grupo de recursos exclusivo do Data Transmission Service

        Faça login no console do MaxCompute e selecione uma região no canto superior esquerdo.

        No painel de navegação à esquerda, escolha Manage Configurations > Quotas .

        Visualize as cotas disponíveis. Para mais informações, consulte Compute resources - Quota management.

      • Faça login no console do MaxCompute e selecione uma região no canto superior esquerdo.

        No painel de navegação à esquerda, escolha Manage Configurations > Tenants .

        Na aba Tenant Property, ative a chave Storage API Switch.

    • withCredentials(Credentials credentials)

      Especifique as informações de autenticação. Para mais detalhes, consulte Credentials.

  Credentials

  Credentials

  • Definição do objeto

    public class Credentials {
    
        public static Builder newBuilder() {
            return new Builder();
        }
    
        public static class Builder {
    
            public Builder withAccount(Account account);
    
            public Builder withAppAccount(AppAccount appAccount);
    
            public Builder withAppStsAccount(AppStsAccount appStsAccount);
    
            public Credentials build();
        }
    
    }

  • Descrição dos parâmetros

    • withAccount(Account account)

      Especifique o objeto Account do Odps.

    • withAppAccount(AppAccount appAccount)

      Especifique o objeto appAccount do Odps.

    • withAppStsAccount(AppStsAccount appStsAccount)

      Especifique o objeto appStsAccount do Odps.

    • withRestOptions(RestOptions restOptions)

      Defina a configuração de acesso à rede. RestOptions é definido conforme abaixo:

      public class RestOptions implements Serializable {
      
          public static Builder newBuilder() {
              return new RestOptions.Builder();
          }
      
          public static class Builder {
              public Builder witUserAgent(String userAgent);
              public Builder withConnectTimeout(int connectTimeout);
              public Builder withReadTimeout(int readTimeout);
              public RestOptions build();
          }
      }

      • witUserAgent(String userAgent): Especifique as informações de userAgent.

      • withConnectTimeout(int connectTimeout): Defina o tempo limite de conexão para estabelecer a conexão de rede subjacente. Padrão: 10 segundos.

      • withReadTimeout(int readTimeout): Defina o tempo limite de leitura para a conexão de rede subjacente. Padrão: 120 segundos.

  DataSchema

  • DataSchema é definido conforme abaixo:

    public class DataSchema implements Serializable {
        
        List<Column> getColumns();
    
        List<String> getPartitionKeys();
    
        List<String> getColumnNames();
    
        List<TypeInfo> getColumnDataTypes();
    
        Optional<Column> getColumn(int columnIndex);
    
        Optional<Column> getColumn(String columnName);
    
    }

  • Descrição dos parâmetros

    • getColumns(): Obtém informações das colunas da tabela e das partições a serem lidas.

    • getPartitionKeys(): Recupera os nomes das colunas de partição para leitura.

    • getColumnNames(): Lista os nomes das colunas da tabela e das partições a serem lidas.

    • getColumnDataTypes(): Retorna os tipos de dados das colunas da tabela e das partições a serem lidas.

    • getColumn(int columnIndex): Obtém um objeto de coluna pelo índice. Retorna vazio se o índice estiver fora do intervalo.

    • getColumn(String columnName): Obtém um objeto de coluna pelo nome. Se o nome da coluna columnName não existir na tabela, retorna vazio.columnName

  InputSplitAssigner

  • InputSplitAssigner é definido conforme abaixo:

    public interface InputSplitAssigner {
    
        int getSplitsCount();
    
        long getTotalRowCount();
    
        InputSplit getSplit(int index);
    
        InputSplit getSplitByRowOffset(long startIndex, long numRecord);
    }

  • Descrição dos parâmetros

    • getSplitsCount(): Obtém o número de partições de dados na sessão.

      Nota

      Quando SplitOptions é SplitByByteSize, este método retorna um valor maior ou igual a 0.

    • getTotalRowCount(): Obtém o número total de linhas de dados na sessão.

      Nota

      Quando SplitOptions é SplitByByteSize, este método retorna um valor maior ou igual a 0.

    • getSplit(int index): Obtém o InputSplit para a partição especificada Index. O parâmetro index varia de [0,SplitsCount-1].

    • getSplitByRowOffset(long startIndex, long numRecord): Obtém o InputSplit correspondente. Os parâmetros são os seguintes:

    • startIndex: Índice inicial da linha para leitura de dados do InputSplit. Intervalo: [0,RecordCount-1].

    • numRecord: Número de linhas de dados que o InputSplit deve ler.

  • Exemplos

    // 1. If SplitOptions is SplitByByteSize
    
    TableBatchReadSession scan = ...;
    InputSplitAssigner assigner = scan.getInputSplitAssigner();
    int splitCount = assigner.getSplitsCount();
    for (int k = 0; k < splitCount; k++) {
        InputSplit split = assigner.getSplit(k);
        ...
    }
    
    // 2. If SplitOptions is SplitByRowOffset
    TableBatchReadSession scan = ...;
    InputSplitAssigner assigner = scan.getInputSplitAssigner();
    long rowCount = assigner.getTotalRowCount();
    long recordsPerSplit = 10000;
    for (long offset = 0; offset < numRecords; offset += recordsPerSplit) {
        recordsPerSplit = Math.min(recordsPerSplit, numRecords - offset);
        InputSplit split = assigner.getSplitByRowOffset(offset, recordsPerSplit);
        ...
    }

  ReaderOptions

  • ReaderOptions é definido conforme abaixo:

    public class ReaderOptions {
        
        public static ReaderOptions.Builder newBuilder() {
            return new Builder();
        }
    
        public static class Builder {
    
            public Builder withMaxBatchRowCount(int maxBatchRowCount);
    
            public Builder withMaxBatchRawSize(long batchRawSize);
    
            public Builder withCompressionCodec(CompressionCodec codec);
    
            public Builder withBufferAllocator(BufferAllocator allocator);
    
            public Builder withReuseBatch(boolean reuseBatch);
    
            public Builder withSettings(EnvironmentSettings settings);
    
            public ReaderOptions build();
        }
    
    }

  • Descrição dos parâmetros

    • withMaxBatchRowCount(int maxBatchRowCount)

      Especifique o número máximo de linhas por lote retornado pelo servidor. O parâmetro maxBatchRowCount tem como padrão um máximo de 4096.

    • withMaxBatchRawSize(long batchRawSize)

      Defina o tamanho máximo bruto em bytes por lote retornado pelo servidor.

    • withCompressionCodec(CompressionCodec codec)

      Especifique o tipo de compressão de dados. Apenas ZSTD e LZ4_FRAME são suportados.

      Nota

      • Transferir grandes volumes de dados Arrow sem compressão diretamente pode aumentar significativamente o tempo de transferência devido aos limites de largura de banda da rede.

      • Se nenhum tipo de compressão for especificado, os dados não serão comprimidos por padrão.

    • withBufferAllocator(BufferAllocator allocator)

      Defina o alocador de memória para leitura de dados Arrow.

    • withReuseBatch(boolean reuseBatch)

      Defina se a memória do ArrowBatch pode ser reutilizada.reuseBatch Valores:

      • true (padrão): a memória do ArrowBatch pode ser reutilizada.

      • false: a memória do ArrowBatch não pode ser reutilizada.

    • withSettings(EnvironmentSettings settings)

      Especifique as informações do ambiente de execução.

  Referências

  Para mais informações sobre o open storage do MaxCompute , consulte Overview of Open Storage.