MaxCompute:Java SDK

SQLTask

SQLTask runs SQL statements in MaxCompute. Call SQLTask.run() to submit a statement — it returns an Instance object you use to poll status and retrieve results.

import java.util.List;
import com.aliyun.odps.Instance;
import com.aliyun.odps.Odps;
import com.aliyun.odps.OdpsException;
import com.aliyun.odps.account.Account;
import com.aliyun.odps.account.AliyunAccount;
import com.aliyun.odps.data.Record;
import com.aliyun.odps.task.SQLTask;

public class RunSqlExample {
    private static final String ACCESS_ID  = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_ID");
    private static final String ACCESS_KEY = System.getenv("ALIBABA_CLOUD_ACCESS_KEY_SECRET");
    private static final String ENDPOINT   = "http://service.odps.aliyun.com/api";
    private static final String PROJECT    = "<your-project>";

    public static void main(String[] args) {
        Account account = new AliyunAccount(ACCESS_ID, ACCESS_KEY);
        Odps odps = new Odps(account);
        odps.setEndpoint(ENDPOINT);
        odps.setDefaultProject(PROJECT);

        String sql = "select category from iris;";
        try {
            // Submit the SQL statement and wait for it to complete
            Instance instance = SQLTask.run(odps, sql);
            instance.waitForSuccess();

            // Retrieve and print results
            List<Record> records = SQLTask.getResult(instance);
            for (Record r : records) {
                System.out.println(r.get(0).toString());
            }
        } catch (OdpsException e) {
            e.printStackTrace();
        }
    }
}

Usage notes:

• Submit only one SQL statement per SQLTask.run() call.

• To create a table programmatically, pass a CREATE TABLE statement to SQLTask.run(). The Table class does not support table creation. For the CREATE TABLE syntax, see Table operations.

Instances and Instance

Instances is the collection of all instances in the project. Instance represents a single instance and exposes status, timing, and task summary information.

// Iterate over all instances
for (Instance i : odps.instances()) {
    // process each instance
}

// Get a specific instance and inspect its status
Instance instance = odps.instances().get("instance_id");
Date startTime = instance.getStartTime();
Date endTime   = instance.getEndTime();

Status instanceStatus = instance.getStatus();
String statusStr;
if (instanceStatus == Status.TERMINATED) {
    statusStr = TaskStatus.Status.SUCCESS.toString();
    Map<String, TaskStatus> taskStatus = instance.getTaskStatus();
    for (Entry<String, TaskStatus> entry : taskStatus.entrySet()) {
        if (entry.getValue().getStatus() != TaskStatus.Status.SUCCESS) {
            statusStr = entry.getValue().getStatus().toString();
            break;
        }
    }
} else {
    statusStr = instanceStatus.toString();
}

// Get the task summary
TaskSummary summary = instance.getTaskSummary("task_name");
String summaryText  = summary.getSummaryText();

Projects and Project

Projects is the collection of all MaxCompute projects accessible with your credentials. Project holds the metadata for a single project.

// Get a specific project
Project p = odps.projects().get("project_name");
p.reload();

Tables and Table

Tables is the collection of all tables in the default project. Use Table to inspect a table's schema and partitions.

// Iterate over all tables
for (Table t : odps.tables()) {
    // process each table
}

// Get a table and iterate over its columns
Table table = odps.tables().get("table_name");
for (Column c : table.getSchema().getColumns()) {
    String   name = c.getName();
    TypeInfo type = c.getTypeInfo();
}

// Access a specific partition
Table t = odps.tables().get("table_name");
t.reload();
Partition part = t.getPartition(new PartitionSpec("partition_col=partition_col_value"));
part.reload();

Resources and Resource

Resources is the collection of all resources in the project. Resources include files and table references used by UDFs and MapReduce jobs.

// Iterate over all resources
for (Resource r : odps.resources()) {
    // process each resource
}

// Get a resource and check its type
Resource r = odps.resources().get("resource_name");
r.reload();
if (r.getType() == Resource.Type.TABLE) {
    TableResource tr = new TableResource(r);
    String tableSource = tr.getSourceTable().getProject() + "."
        + tr.getSourceTable().getName();
    if (tr.getSourceTablePartition() != null) {
        tableSource += " partition(" + tr.getSourceTablePartition().toString() + ")";
    }
}

Create a file resource:

String projectName = "my_project";
String source      = "my_local_file.txt";
File file          = new File(source);
InputStream is     = new FileInputStream(file);

FileResource resource = new FileResource();
resource.setName(file.getName());
odps.resources().create(projectName, resource, is);

Create a table resource:

TableResource resource = new TableResource(tableName, tablePrj, partitionSpec);
resource.setName("table_resource_name");
odps.resources().update(projectName, resource);

Functions and Function

Functions is the collection of all functions in the project. Use Function to read or create UDFs registered in MaxCompute.

// Iterate over all functions
for (Function f : odps.functions()) {
    // process each function
}

// Get a function and list its associated resources
Function f = odps.functions().get("function_name");
List<Resource> resources = f.getResources();

Create a function:

String classType = "com.aliyun.odps.mapred.open.example.WordCount";
ArrayList<String> resourceList = new ArrayList<>();
for (String r : "resource1:resource2".split(":")) {
    resourceList.add(r);
}

Function func = new Function();
func.setName("function_name");
func.setClassType(classType);
func.setResources(resourceList);
odps.functions().create(projectName, func);