MaxCompute:Exemples du SDK Open Storage - Java SDK

SplitOptions

• Définition des paramètres

  Les paramètres de l'objet SplitOptions sont définis comme suit :

  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();
      }
  }

• Description des paramètres

  • SplitByByteSize(long splitByteSize)

    Fractionne les données en fonction du paramètre splitByteSize spécifié. La taille de chaque partition de données retournée par le serveur ne dépasse pas splitByteSize (en octets).

    • La taille de fractionnement personnalisée doit être d'au moins 10 × 1024 × 1024 (10 Mo).

    • Si SplitByByteSize(long splitByteSize) n'est pas utilisé pour personnaliser la taille de fractionnement, le système utilise la valeur par défaut de 256 × 1024 × 1024 (256 Mo).

  • SplitByRowOffset()

    Fractionne les données par ligne, ce qui permet au client de lire les données à partir d'un index spécifié.

  • withCrossPartition(boolean crossPartition)

    Spécifie si un seul fragment de données peut inclure plusieurs partitions. Le paramètre crossPartition accepte les valeurs suivantes :

    • true (par défaut) : autorise un seul fragment de données à contenir plusieurs partitions.

    • false : ne l'autorise pas.

  • withMaxFileNum(int splitMaxFileNum)

    Lorsqu'une table contient de nombreux fichiers, spécifiez le nombre maximal de fichiers physiques dans une seule partition de données afin de générer davantage de partitions.

    Par défaut, il n'y a aucune limite au nombre de fichiers physiques dans une seule partition de données.

  • build() : crée un objet SplitOptions.

• Exemples

  // 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

• Définition des paramètres

  Les paramètres de l'objet ArrowOptions sont définis comme suit :

  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;
      }
  }

• Description des paramètres

  • TimestampUnit

    Spécifie l'unité pour les types de données Timestamp et Datetime. Valeurs valides :

    • SECOND : secondes (s)

    • MILLI : millisecondes (ms)

    • MICRO : microsecondes (μs)

    • NANO : nanosecondes (ns)

  • withTimestampUnit(TimestampUnit unit)

    Définit l'unité pour le type de données Timestamp. Valeur par défaut : NANO.

  • withDatetimeUnit(TimestampUnit unit)

    Définit l'unité pour le type de données Datetime. Valeur par défaut : MILLI.

• Exemples

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

Predicate

• Définition des paramètres

  Les paramètres de l'objet Predicate sont définis comme suit :

  // 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);
    }

• Exemples

  // 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

• Définition des paramètres

  L'interface EnvironmentSettings est définie comme suit :

  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();
      }
  }

• Description des paramètres

  • withDefaultProject(String projectName)

    Définit le nom du projet. Le paramètre projectName correspond au nom du projet MaxCompute.

    • Connectez-vous à la console MaxCompute, puis changez de région dans le coin supérieur gauche.

    • Choisissez Manage Configurations > Projects pour afficher le nom du projet MaxCompute.

  • withDefaultSchema(String schema)

    Définit le schéma par défaut. Le paramètre schema correspond au nom du schéma MaxCompute. Pour plus d'informations sur les schémas, consultez Opérations sur les schémas.

  • withServiceEndpoint(String endPoint)

    Définit l'endpoint du service. Endpoint.

  • withTunnelEndpoint(String tunnelEndPoint)

    Définit l'endpoint du tunnel. Endpoint.

  • withQuotaName(String quotaName)

    Spécifie le nom du quota à utiliser.

    MaxCompute prend en charge deux types de ressources : les groupes de ressources exclusifs Data Transmission Service (abonnement) Obtenez le nom du quota comme suit :

    • Groupe de ressources exclusif Data Transmission Service

      Connectez-vous à la console MaxCompute et sélectionnez une région dans le coin supérieur gauche.

      Dans le volet de navigation de gauche, choisissez Manage Configurations > Quotas .

      Consultez les quotas disponibles. Pour plus d'informations, consultez Ressources de calcul - Gestion des quotas.

    • Connectez-vous à la console MaxCompute et sélectionnez une région dans le coin supérieur gauche.

      Dans le volet de navigation de gauche, choisissez Manage Configurations > Tenants .

      Dans l'onglet Tenant Property, activez le commutateur Storage API Switch.

  • withCredentials(Credentials credentials)

    Spécifie les informations d'authentification. Pour plus d'informations, consultez Credentials.

Credentials

• Définition de l'objet

  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();
      }
  
  }

• Description des paramètres

  • withAccount(Account account)

    Spécifie l'objet Account Odps.

  • withAppAccount(AppAccount appAccount)

    Spécifie l'objet appAccount Odps.

  • withAppStsAccount(AppStsAccount appStsAccount)

    Spécifie l'objet appStsAccount Odps.

  • withRestOptions(RestOptions restOptions)

    Spécifie la configuration d'accès réseau. RestOptions est défini comme suit :

    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) : spécifie les informations userAgent.

    • withConnectTimeout(int connectTimeout) : définit le délai d'attente de connexion pour établir la connexion réseau sous-jacente. Valeur par défaut : 10 secondes.

    • withReadTimeout(int readTimeout) : définit le délai d'attente de lecture pour la connexion réseau sous-jacente. Valeur par défaut : 120 secondes.

• DataSchema est défini comme suit :

  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);
  
  }

• Description des paramètres

  • getColumns() : retourne les informations de colonne pour la table et les partitions à lire.

  • getPartitionKeys() : retourne les noms des colonnes de partition à lire.

  • getColumnNames() : retourne les noms de colonne pour la table et les partitions à lire.

  • getColumnDataTypes() : retourne les types de données de colonne pour la table et les partitions à lire.

  • getColumn(int columnIndex) : retourne un objet colonne par index. Retourne vide si l'index est hors limites.

  • getColumn(String columnName) : retourne un objet colonne par nom. Si le nom de colonne columnName n'existe pas dans la table, retourne vide.columnName

• InputSplitAssigner est défini comme suit :

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

• Description des paramètres

  • getSplitsCount() : retourne le nombre de partitions de données dans la session.

    Remarque

    Lorsque SplitOptions est défini sur SplitByByteSize, cette méthode retourne une valeur supérieure ou égale à 0.

  • getTotalRowCount() : retourne le nombre total de lignes de données dans la session.

    Remarque

    Lorsque SplitOptions est défini sur SplitByByteSize, cette méthode retourne une valeur supérieure ou égale à 0.

  • getSplit(int index) : retourne l'InputSplit pour la partition spécifiée Index. Le paramètre index varie de [0,SplitsCount-1].

  • getSplitByRowOffset(long startIndex, long numRecord) : retourne l'InputSplit correspondant. Les paramètres sont les suivants :

  • startIndex : index de ligne de départ pour la lecture des données InputSplit. Plage : [0,RecordCount-1].

  • numRecord : nombre de lignes de données à lire par InputSplit.

• Exemples

  // 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 est défini comme suit :

  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();
      }
  
  }

• Description des paramètres

  • withMaxBatchRowCount(int maxBatchRowCount)

    Spécifie le nombre maximal de lignes par lot retourné par le serveur. Le paramètre maxBatchRowCount est limité à 4096 par défaut.

  • withMaxBatchRawSize(long batchRawSize)

    Spécifie la taille brute maximale en octets par lot retourné par le serveur.

  • withCompressionCodec(CompressionCodec codec)

    Spécifie le type de compression des données. Seuls ZSTD et LZ4_FRAME sont pris en charge.

    Remarque

    • Le transfert direct de grandes quantités de données Arrow non compressées peut augmenter considérablement le temps de transfert en raison des limites de bande passante réseau.

    • Si aucun type de compression n'est spécifié, les données ne sont pas compressées par défaut.

  • withBufferAllocator(BufferAllocator allocator)

    Spécifie l'allocateur de mémoire pour la lecture des données Arrow.

  • withReuseBatch(boolean reuseBatch)

    Indique si la mémoire ArrowBatch peut être réutilisée. Valeurs de reuseBatch :

    • true (par défaut) : la mémoire ArrowBatch peut être réutilisée.

    • false : la mémoire ArrowBatch ne peut pas être réutilisée.

  • withSettings(EnvironmentSettings settings)

    Spécifie les informations sur l'environnement d'exécution.