MaxCompute:Use the Go SDK

Execute SELECT and get results (fewer than 10,000 rows)

package main

import (
"fmt"
"io"
"log"

"github.com/aliyun/aliyun-odps-go-sdk/odps"
"github.com/aliyun/aliyun-odps-go-sdk/odps/account"
)

func main() {
// Specify the configuration file path
configPath := "./config.ini"
conf, err := odps.NewConfigFromIni(configPath)
if err != nil {
	log.Fatalf("%+v", err)
}

aliAccount := account.NewAliyunAccount(conf.AccessId, conf.AccessKey)
odpsIns := odps.NewOdps(aliAccount, conf.Endpoint)
// Set the default MaxCompute project
odpsIns.SetDefaultProjectName(conf.ProjectName)

sql := "select * from all_types_demo where p1>0 or p2 > '';"

// SQL engine parameters, for example, odps.sql.skewjoin
var hints map[string]string = nil

sqlTask := odps.NewSqlTask("select_demo", sql, hints)
ins, err := sqlTask.Run(odpsIns, odpsIns.DefaultProjectName())
if err != nil {
	log.Fatalf("%+v", err)
}

err = ins.WaitForSuccess()
if err != nil {
	log.Fatalf("%+v", err)
}

csvReader, err := sqlTask.GetSelectResultAsCsv(ins, true)
if err != nil {
	log.Fatalf("%+v", err)
}

for {
	record, err := csvReader.Read()
	if err == io.EOF {
		break
	}
	if err != nil {
		log.Fatalf("%+v", err)
	}
	fmt.Printf("%v\n", record)
}
}

Execute SELECT and download results via Tunnel (more than 10,000 rows)

For large result sets, create a Tunnel download session against the instance ID after the job completes.

package main

import (
"fmt"
"github.com/aliyun/aliyun-odps-go-sdk/odps"
"github.com/aliyun/aliyun-odps-go-sdk/odps/account"
"github.com/aliyun/aliyun-odps-go-sdk/odps/data"
"github.com/aliyun/aliyun-odps-go-sdk/odps/tunnel"
"log"
)

func main() {
// Configuration file path
configPath := "./config.ini"
conf, err := odps.NewConfigFromIni(configPath)
if err != nil {
    log.Fatalf("%+v", err)
}

aliAccount := account.NewAliyunAccount(conf.AccessId, conf.AccessKey)
odpsIns := odps.NewOdps(aliAccount, conf.Endpoint)
// Set the default MaxCompute project
odpsIns.SetDefaultProjectName(conf.ProjectName)

sql := "select * from all_types_demo where p1 = 20 and p2 = 'hangzhou';"

// SQL engine parameters, for example, odps.sql.skewjoin
var hints map[string]string = nil

sqlTask := odps.NewSqlTask("select_demo", sql, hints)

// Run SQL using the quota associated with the project
projectName := odpsIns.DefaultProjectName()

ins, err := sqlTask.Run(odpsIns, projectName)
if err != nil {
	log.Fatalf("%+v", err)
}

err = ins.WaitForSuccess()
if err != nil {
	log.Fatalf("%+v", err)
}

// Generate a LogView URL for detailed job information
lv := odpsIns.LogView()
lvUrl, err := lv.GenerateLogView(ins, 10)
if err != nil {
	log.Fatalf("%+v", err)
}

println(lvUrl)

project := odpsIns.DefaultProject()
tunnelEndpoint, err := project.GetTunnelEndpoint()
if err != nil {
	log.Fatalf("%+v", err)
}

// Create a Tunnel instance
tunnelIns := tunnel.NewTunnel(odpsIns, tunnelEndpoint)
session, err := tunnelIns.CreateInstanceResultDownloadSession(project.Name(), ins.Id())
if err != nil {
	log.Fatalf("%+v", err)
}

start := 0
step := 200000
recordCount := session.RecordCount()
schema := session.Schema()
total := 0

for start < recordCount {
	reader, err := session.OpenRecordReader(start, step, 0, nil)
	if err != nil {
		log.Fatalf("%+v", err)
	}

	count := 0
	err = reader.Iterator(func(record data.Record, _err error) {
		count += 1

		if _err != nil {
			return
		}

		for i, d := range record {
			if d == nil {
				fmt.Printf("%s=null", schema.Columns[i].Name)
			} else {
				fmt.Printf("%s=%s", schema.Columns[i].Name, d.Sql())
			}

			if i < record.Len()-1 {
				fmt.Printf(", ")
			} else {
				fmt.Println()
			}
		}
	})

	if err != nil {
		log.Fatalf("%+v", err)
	}

	start += count
	total += count
	log.Println(count)
	if err = reader.Close(); err != nil {
		log.Fatalf("%+v", err)
	}
}

println("total count ", total)
}

Execute a CREATE TABLE statement

The DSN format is http://<endpoint>?project=<project>&<hints>. Set your AccessKey in the ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECURITY environment variables.

package main

import (
"database/sql"
"log"
)

func main() {
// Configure AccessKey in environment variables: ALIBABA_CLOUD_ACCESS_KEY_ID and ALIBABA_CLOUD_ACCESS_KEY_SECURITY
dsn := "http://<endpoint>?project=<project>&odps.sql.type.system.odps2=true&odps.sql.decimal.odps2=true"

db, err := sql.Open("odps", dsn)
if err != nil {
	log.Fatalf("%+v", err)
}

sqlStr := "create table table_with_date (date_col DATE);"
_, err = db.Exec(sqlStr)
if err != nil {
	log.Fatalf("%+v", err)
}
}

Execute a SELECT statement and read results

This example reads the DSN from a config.ini file and uses named parameters to bind query values.

package main

import (
"database/sql"
"fmt"
"github.com/aliyun/aliyun-odps-go-sdk/sqldriver"
"log"
"reflect"
)

func main() {
config, err := sqldriver.NewConfigFromIni("./config.ini")
if err != nil {
	log.Fatalf("%+v", err)
}

dsn := config.FormatDsn()
// or dsn := "http://<accessId>:<accessKey>@<endpoint>?project=<project>"

db, err := sql.Open("odps", dsn)
if err != nil {
	log.Fatalf("%+v", err)
}

selectSql := "select * from all_types_demo where bigint_type=@bigint_type and p1=@p1 and p2='@p2';"

rows, err := db.Query(
	selectSql,
	sql.Named("bigint_type", 100000000000),
	sql.Named("p1", 20),
	sql.Named("p2", "hangzhou"),
)
if err != nil {
	log.Fatalf("%+v", err)
}

columnTypes, err := rows.ColumnTypes()
if err != nil {
	log.Fatalf("%+v", err)
}

record := make([]interface{}, len(columnTypes))

for i, columnType := range columnTypes {
	record[i] = reflect.New(columnType.ScanType()).Interface()
	t := reflect.TypeOf(record[i])

	fmt.Printf("kind=%s, name=%s\n", t.Kind(), t.String())
}

columns, err := rows.Columns()
if err != nil {
	log.Fatalf("%+v", err)
}

for rows.Next() {
	err = rows.Scan(record...)
	if err != nil {
		log.Fatalf("%+v", err)
	}

	for i, r := range record {
		rr := r.(sqldriver.NullAble)

		if rr.IsNull() {
			fmt.Printf("%s=NULL", columns[i])
		} else {
			switch r.(type) {
			case *sqldriver.NullInt8:
				fmt.Printf("%s=%d", columns[i], r.(*sqldriver.NullInt8).Int8)
			case *sqldriver.NullInt16:
				fmt.Printf("%s=%d", columns[i], r.(*sqldriver.NullInt16).Int16)
			case *sqldriver.NullInt32:
				fmt.Printf("%s=%d", columns[i], r.(*sqldriver.NullInt32).Int32)
			case *sqldriver.NullInt64:
				fmt.Printf("%s=%d", columns[i], r.(*sqldriver.NullInt64).Int64)
			case *sqldriver.Binary:
				fmt.Printf("%s=%s", columns[i], r)
			case *sqldriver.NullFloat32:
				fmt.Printf("%s=%f", columns[i], r.(*sqldriver.NullFloat32).Float32)
			case *sqldriver.NullFloat64:
				fmt.Printf("%s=%f", columns[i], r.(*sqldriver.NullFloat64).Float64)
			case *sqldriver.Decimal:
				fmt.Printf("%s=%s", columns[i], r)
			case *sqldriver.NullString:
				fmt.Printf("%s=%s", columns[i], r.(*sqldriver.NullString).String)
			case *sqldriver.NullDate:
				fmt.Printf("%s=%s", columns[i], r)
			case *sqldriver.NullDateTime:
				fmt.Printf("%s=%s", columns[i], r)
			case *sqldriver.NullTimeStamp:
				fmt.Printf("%s=%s", columns[i], r)
			case *sqldriver.NullBool:
				fmt.Printf("%s=%v", columns[i], r.(*sqldriver.NullBool).Bool)
			case *sqldriver.Map:
				fmt.Printf("%s=%s", columns[i], r)
			case *sqldriver.Array:
				fmt.Printf("%s=%s", columns[i], r)
			case *sqldriver.Struct:
				fmt.Printf("%s=%s", columns[i], r)
			case *sqldriver.Json:
				fmt.Printf("%s=%s", columns[i], r)
			}
		}

		if i < len(record)-1 {
			fmt.Printf(", ")
		} else {
			fmt.Print("\n\n")
		}
	}
}
}

Create a regular table

The following example creates a partitioned table named all_types_demo with columns covering all supported MaxCompute data types.

package main

import (
"github.com/aliyun/aliyun-odps-go-sdk/odps"
"github.com/aliyun/aliyun-odps-go-sdk/odps/account"
"github.com/aliyun/aliyun-odps-go-sdk/odps/datatype"
"github.com/aliyun/aliyun-odps-go-sdk/odps/tableschema"
"log"
)

func main() {
conf, err := odps.NewConfigFromIni("./config.ini")
if err != nil {
	log.Fatalf("%+v", err)
}

aliAccount := account.NewAliyunAccount(conf.AccessId, conf.AccessKey)
odpsIns := odps.NewOdps(aliAccount, conf.Endpoint)
odpsIns.SetDefaultProjectName(conf.ProjectName)

c1 := tableschema.Column{
	Name: "tiny_int_type",
	Type: datatype.TinyIntType,
}

c2 := tableschema.Column{
	Name: "small_int_type",
	Type: datatype.SmallIntType,
}

c3 := tableschema.Column{
	Name: "int_type",
	Type: datatype.IntType,
}

c4 := tableschema.Column{
	Name: "bigint_type",
	Type: datatype.BigIntType,
}

c5 := tableschema.Column{
	Name: "binary_type",
	Type: datatype.BinaryType,
}

c6 := tableschema.Column{
	Name: "float_type",
	Type: datatype.FloatType,
}

c7 := tableschema.Column{
	Name: "double_type",
	Type: datatype.DoubleType,
}

c8 := tableschema.Column{
	Name: "decimal_type",
	Type: datatype.NewDecimalType(10, 8),
}

c9 := tableschema.Column{
	Name: "varchar_type",
	Type: datatype.NewVarcharType(500),
}

c10 := tableschema.Column{
	Name: "char_type",
	Type: datatype.NewCharType(254),
}

c11 := tableschema.Column{
	Name: "string_type",
	Type: datatype.StringType,
}

c12 := tableschema.Column{
	Name: "date_type",
	Type: datatype.DateType,
}

c13 := tableschema.Column{
	Name: "datetime_type",
	Type: datatype.DateTimeType,
}

c14 := tableschema.Column{
	Name: "timestamp_type",
	Type: datatype.TimestampType,
}

c15 := tableschema.Column{
	Name: "timestamp_ntz_type",
	Type: datatype.TimestampNtzType,
}

c16 := tableschema.Column{
	Name: "boolean_type",
	Type: datatype.BooleanType,
}

mapType := datatype.NewMapType(datatype.StringType, datatype.BigIntType)
arrayType := datatype.NewArrayType(datatype.StringType)
structType := datatype.NewStructType(
	datatype.NewStructFieldType("arr", arrayType),
	datatype.NewStructFieldType("name", datatype.StringType),
)
jsonType := datatype.NewJsonType()

c17 := tableschema.Column{
	Name: "map_type",
	Type: mapType,
}

c18 := tableschema.Column{
	Name: "array_type",
	Type: arrayType,
}

c19 := tableschema.Column{
	Name: "struct_type",
	Type: structType,
}

c20 := tableschema.Column{
	Name: "json_type",
	Type: jsonType,
}

p1 := tableschema.Column{
	Name: "p1",
	Type: datatype.BigIntType,
}

p2 := tableschema.Column{
	Name: "p2",
	Type: datatype.StringType,
}

schemaBuilder := tableschema.NewSchemaBuilder()
schemaBuilder.Name("all_types_demo").
	Columns(c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15, c16, c17, c18, c19, c20).
	PartitionColumns(p1, p2).
	Lifecycle(2) // Unit: day

schema := schemaBuilder.Build()
tablesIns := odpsIns.Tables()
// If the project uses data type version 1.0, enable version 2.0 via hints.
hints := make(map[string]string)
hints["odps.sql.type.system.odps2"] = "true"
hints["odps.sql.decimal.odps2"] = "true"

err = tablesIns.Create(schema, true, hints, nil)
if err != nil {
	log.Fatalf("%+v", err)
}
}

Create a hash-clustered table

For details about hash clustering, see Hash clustering.

package main

import (
"github.com/aliyun/aliyun-odps-go-sdk/odps"
"github.com/aliyun/aliyun-odps-go-sdk/odps/account"
"github.com/aliyun/aliyun-odps-go-sdk/odps/datatype"
"github.com/aliyun/aliyun-odps-go-sdk/odps/tableschema"
"log"
)

func main() {
// Specify the configuration file path
configPath := "./config.ini"
conf, err := odps.NewConfigFromIni(configPath)

if err != nil {
	log.Fatalf("%+v", err)
}

aliAccount := account.NewAliyunAccount(conf.AccessId, conf.AccessKey)
odpsIns := odps.NewOdps(aliAccount, conf.Endpoint)
// Set the default MaxCompute project
odpsIns.SetDefaultProjectName(conf.ProjectName)

// Create a table equivalent to:
// CREATE TABLE test_hash_clustering (a string, b string, c bigint)
// PARTITIONED BY (dt string)
// CLUSTERED BY (c)
// SORTED by (c) INTO 1024 BUCKETS;

c1 := tableschema.Column{
	Name: "a",
	Type: datatype.StringType,
}

c2 := tableschema.Column{
	Name: "b",
	Type: datatype.StringType,
}

c3 := tableschema.Column{
	Name: "c",
	Type: datatype.BigIntType,
}

// Partition column
pc := tableschema.Column{
	Name: "dt",
	Type: datatype.StringType,
}

sb := tableschema.NewSchemaBuilder()

sb.Name("test_hash_clustering"). // table name
				Columns(c1, c2, c3).                        // columns
				PartitionColumns(pc).                       // partition columns
				ClusterType(tableschema.CLUSTER_TYPE.Hash). // hash clustering
				ClusterColumns([]string{c3.Name}).          // cluster key
	// Sort key (optional). In most cases, keep it consistent with the cluster key for best optimization results.
	ClusterSortColumns([]tableschema.SortColumn{{Name: c3.Name, Order: tableschema.SORT_ORDER.ASC}}).
	ClusterBucketNum(1024) // bucket count (optional)

tablesIns := odpsIns.Tables()

schema := sb.Build()

println(schema.ToSQLString("test_cluster", "", true))

err = tablesIns.Create(schema, true, nil, nil)
if err != nil {
	log.Fatalf("%+v", err)
}

}

Create a range-clustered table

For details about range clustering, see Range clustering.

package main

import (
"github.com/aliyun/aliyun-odps-go-sdk/odps"
"github.com/aliyun/aliyun-odps-go-sdk/odps/account"
"github.com/aliyun/aliyun-odps-go-sdk/odps/datatype"
"github.com/aliyun/aliyun-odps-go-sdk/odps/tableschema"
"log"
)

func main() {
// Specify the configuration file path
configPath := "./config.ini"
conf, err := odps.NewConfigFromIni(configPath)

if err != nil {
	log.Fatalf("%+v", err)
}

aliAccount := account.NewAliyunAccount(conf.AccessId, conf.AccessKey)
odpsIns := odps.NewOdps(aliAccount, conf.Endpoint)
// Set the default MaxCompute project
odpsIns.SetDefaultProjectName(conf.ProjectName)

// Create a table equivalent to:
// CREATE TABLE test_range_clustering (a string, b string, c int)
// PARTITIONED BY (dt int)
// RANGE CLUSTERED BY (c)
// SORTED by (c)
// INTO 1024 BUCKETS;

c1 := tableschema.Column{
	Name: "a",
	Type: datatype.StringType,
}

c2 := tableschema.Column{
	Name: "b",
	Type: datatype.StringType,
}

c3 := tableschema.Column{
	Name: "c",
	Type: datatype.BigIntType,
}

// Partition column
pc := tableschema.Column{
	Name: "dt",
	Type: datatype.StringType,
}

sb := tableschema.NewSchemaBuilder()

sb.Name("test_range_clustering"). // table name
				Columns(c1, c2, c3).                         // columns
				PartitionColumns(pc).                        // partition columns
				ClusterType(tableschema.CLUSTER_TYPE.Range). // range clustering
				ClusterColumns([]string{c3.Name}).           // range cluster key
	// Sort key (optional). In most cases, keep it consistent with the cluster key for best optimization results.
	ClusterSortColumns([]tableschema.SortColumn{{Name: c3.Name, Order: tableschema.SORT_ORDER.ASC}}).
	ClusterBucketNum(1024) // bucket count (optional)

tablesIns := odpsIns.Tables()

schema := sb.Build()

println(schema.ToSQLString("test_cluster", "", true))

err = tablesIns.Create(schema, true, nil, nil)
if err != nil {
	log.Fatalf("%+v", err)
}

}

Create an OSS external table

For details about external tables, see Create an OSS external table.

package main

import (
"github.com/aliyun/aliyun-odps-go-sdk/odps"
"github.com/aliyun/aliyun-odps-go-sdk/odps/account"
"github.com/aliyun/aliyun-odps-go-sdk/odps/datatype"
"github.com/aliyun/aliyun-odps-go-sdk/odps/tableschema"
"log"
)

func main() {
// Specify the configuration file path
configPath := "./config.ini"
conf, err := odps.NewConfigFromIni(configPath)
        if err != nil {
	log.Fatalf("%+v", err)
}

aliAccount := account.NewAliyunAccount(conf.AccessId, conf.AccessKey)
odpsIns := odps.NewOdps(aliAccount, conf.Endpoint)
// Set the default MaxCompute project
odpsIns.SetDefaultProjectName(conf.ProjectName)

// create external table if not exists go_sdk_regression_testing.`testCreateExternalTableWithUserDefinedStorageHandler` (
//    `a` STRING ,
//    `b` STRING ,
//    `c` BIGINT
//)
//	comment 'External table using user defined TextStorageHandler'
//	partitioned by (`dt` STRING)
//	stored by 'com.aliyun.odps.udf.example.text.TextStorageHandler'
//	with serdeproperties('odps.text.option.delimiter'='|', 'my.own.option'='value')
//	location 'MOCKoss://full/uri/path/to/oss/directory/'
//	lifecycle 10;

tableName := "testCreateExternalTableWithUserDefinedStorageHandler"

c1 := tableschema.Column{
	Name: "a",
	Type: datatype.StringType,
}

c2 := tableschema.Column{
	Name: "b",
	Type: datatype.StringType,
}

c3 := tableschema.Column{
	Name: "c",
	Type: datatype.BigIntType,
}

// Partition column
pc := tableschema.Column{
	Name: "dt",
	Type: datatype.StringType,
}

sb := tableschema.NewSchemaBuilder()

sb.Name(tableName). // table name
	Columns(c1, c2, c3). // columns
	PartitionColumns(pc). // partition columns
	Location("oss://full/uri/path/to/oss/directory/").
	StorageHandler("com.aliyun.odps.udf.example.text.TextStorageHandler").
	Comment("External table using user defined TextStorageHandler").
	Lifecycle(10)

tablesIns := odpsIns.Tables()

schema := sb.Build()

// Define the SerDe properties
serDeProperties := map[string]string{
	"odps.text.option.delimiter": "|",
	"my.own.option":              "value",
}

// Define the hints
hints := map[string]string{
	"odps.sql.preparse.odps2":       "lot",
	"odps.sql.planner.mode":         "lot",
	"odps.sql.planner.parser.odps2": "true",
	"odps.sql.ddl.odps2":            "true",
	"odps.compiler.output.format":   "lot,pot",
}

sql, err := schema.ToExternalSQLString(odpsIns.DefaultProjectName(), "", true, serDeProperties, nil)
print(sql)

err = tablesIns.CreateExternal(schema, true, serDeProperties, nil, hints, nil)

if err != nil {
	log.Fatalf("%+v", err)
}
}

Check whether a table exists

package main

import (
"github.com/aliyun/aliyun-odps-go-sdk/odps"
"github.com/aliyun/aliyun-odps-go-sdk/odps/account"
"log"
)

func main() {
// Specify the configuration file path
configPath := "./config.ini"
conf, err := odps.NewConfigFromIni(configPath)
if err != nil {
	log.Fatalf("%+v", err)
}

aliAccount := account.NewAliyunAccount(conf.AccessId, conf.AccessKey)
odpsIns := odps.NewOdps(aliAccount, conf.Endpoint)
// Set the default MaxCompute project
odpsIns.SetDefaultProjectName(conf.ProjectName)

project := odpsIns.Project(conf.ProjectName)
tables := project.Tables()
table := tables.Get("all_types_demo")

ok, err := table.Exists()
if err != nil {
	log.Fatalf("%+v", err)
}

println(ok)
}

Get table size and row count

package main

import (
"github.com/aliyun/aliyun-odps-go-sdk/odps"
"github.com/aliyun/aliyun-odps-go-sdk/odps/account"
"log"
)

func main() {
// Specify the configuration file path
configPath := "./config.ini"
conf, err := odps.NewConfigFromIni(configPath)
if err != nil {
	log.Fatalf("%+v", err)
}

aliAccount := account.NewAliyunAccount(conf.AccessId, conf.AccessKey)
odpsIns := odps.NewOdps(aliAccount, conf.Endpoint)
// Set the default MaxCompute project
odpsIns.SetDefaultProjectName(conf.ProjectName)

project := odpsIns.Project(conf.ProjectName)
tables := project.Tables()
table := tables.Get("all_types_demo")

err = table.Load()
if err != nil {
	log.Fatalf("%+v", err)
}

// Get table size (in bytes)
size := table.Size()
println("size = ", size)

// Get table row count
rowCount := table.RecordNum()
println("rowCount = ", rowCount)
}

Get table timestamps

package main

import (
"github.com/aliyun/aliyun-odps-go-sdk/odps"
"github.com/aliyun/aliyun-odps-go-sdk/odps/account"
"log"
)

func main() {
configPath := "./config.ini"
conf, err := odps.NewConfigFromIni(configPath)
if err != nil {
	log.Fatalf("%+v", err)
}

aliAccount := account.NewAliyunAccount(conf.AccessId, conf.AccessKey)
odpsIns := odps.NewOdps(aliAccount, conf.Endpoint)
odpsIns.SetDefaultProjectName(conf.ProjectName)

project := odpsIns.Project(conf.ProjectName)
tables := project.Tables()
table := tables.Get("all_types_demo")

err = table.Load()
if err != nil {
	log.Fatalf("%+v", err)
}

// Get table creation time
createTime := table.CreatedTime()
println("create time = ", createTime)

// Get the time of the last DDL operation
lastDDLTime := table.LastDDLTime()
println("last ddl time = ", lastDDLTime)

// Get the last modification time of the table
lastModifiedTime := table.LastModifiedTime()
println("last modified time = ", lastModifiedTime)
}

Get table owner

package main

import (
"github.com/aliyun/aliyun-odps-go-sdk/odps"
"github.com/aliyun/aliyun-odps-go-sdk/odps/account"
"log"
)

func main() {
configPath := "./config.ini"
conf, err := odps.NewConfigFromIni(configPath)
if err != nil {
	log.Fatalf("%+v", err)
}

aliAccount := account.NewAliyunAccount(conf.AccessId, conf.AccessKey)
odpsIns := odps.NewOdps(aliAccount, conf.Endpoint)
odpsIns.SetDefaultProjectName(conf.ProjectName)

project := odpsIns.Project(conf.ProjectName)
tables := project.Tables()
table := tables.Get("all_types_demo")

err = table.Load()
if err != nil {
	log.Fatalf("%+v", err)
}

// Get table owner
owner := table.Owner()
println("owner is ", owner)
}

Get table type

package main

import (
"github.com/aliyun/aliyun-odps-go-sdk/odps"
"github.com/aliyun/aliyun-odps-go-sdk/odps/account"
"log"
)

func main() {
configPath := "./config.ini"
conf, err := odps.NewConfigFromIni(configPath)
if err != nil {
	log.Fatalf("%+v", err)
}

aliAccount := account.NewAliyunAccount(conf.AccessId, conf.AccessKey)
odpsIns := odps.NewOdps(aliAccount, conf.Endpoint)
odpsIns.SetDefaultProjectName(conf.ProjectName)

project := odpsIns.Project(conf.ProjectName)
tables := project.Tables()
table := tables.Get("all_types_demo")

err = table.Load()
if err != nil {
	log.Fatalf("%+v", err)
}

// Get table type
t := table.Type()
println("type is ", t)
}

Get table structure

package main

import (
"fmt"
"github.com/aliyun/aliyun-odps-go-sdk/odps"
"github.com/aliyun/aliyun-odps-go-sdk/odps/account"
"log"
"strings"
)

func main() {
configPath := "./config.ini"
conf, err := odps.NewConfigFromIni(configPath)
if err != nil {
	log.Fatalf("%+v", err)
}

aliAccount := account.NewAliyunAccount(conf.AccessId, conf.AccessKey)
odpsIns := odps.NewOdps(aliAccount, conf.Endpoint)
odpsIns.SetDefaultProjectName(conf.ProjectName)

project := odpsIns.Project(conf.ProjectName)
tables := project.Tables()
table := tables.Get("test_cluster_table")

err = table.Load()
if err != nil {
	log.Fatalf("%+v", err)
}

// Get the table schema
schema := table.Schema()

println("table name = ", schema.TableName)
if table.LifeCycle() > 0 {
	println("table lifecycle = ", table.LifeCycle())
}

// Get columns
for _, c := range schema.Columns {
	fmt.Printf("column %s %s comment '%s'\n", c.Name, c.Type, c.Comment)
}

// Get partition columns
for _, c := range schema.PartitionColumns {
	fmt.Printf("partition column %s %s comment '%s'\n", c.Name, c.Type, c.Comment)
}

// Get cluster information
if schema.ClusterInfo.ClusterType != "" {
	ci := schema.ClusterInfo
	println("cluster type = ", ci.ClusterType)
	println("cluster columns = ", strings.Join(ci.ClusterCols, ", "))
	println("cluster bucket num = ", ci.BucketNum)
}
}

Get basic partition information

package main

import (
"fmt"
"github.com/aliyun/aliyun-odps-go-sdk/odps"
"github.com/aliyun/aliyun-odps-go-sdk/odps/account"
"log"
)

func main() {
// Specify the configuration file path
configPath := "./config.ini"
conf, err := odps.NewConfigFromIni(configPath)
if err != nil {
	log.Fatalf("%+v", err)
}

aliAccount := account.NewAliyunAccount(conf.AccessId, conf.AccessKey)
odpsIns := odps.NewOdps(aliAccount, conf.Endpoint)
// Set the default MaxCompute project
odpsIns.SetDefaultProjectName(conf.ProjectName)

project := odpsIns.Project(conf.ProjectName)
tables := project.Tables()
table := tables.Get("all_types_demo")

p, err := table.GetPartition("p1=20/p2=hangzhou")
if err != nil {
	log.Fatalf("%+v", err)
}

fmt.Printf(
	"value=%s, createTime=%s, lastDDLTime=%s, lastModifiedTime=%s, size=%d\n",
	p.Value(), p.CreatedTime(), p.LastDDLTime(), p.LastModifiedTime(), p.Size(),
)
}

Get extended partition information

Call LoadExtended() to retrieve additional fields: archive status, lifecycle, and physical size.

package main

import (
"fmt"
"github.com/aliyun/aliyun-odps-go-sdk/odps"
"github.com/aliyun/aliyun-odps-go-sdk/odps/account"
"log"
)

func main() {
configPath := "./config.ini"
conf, err := odps.NewConfigFromIni(configPath)
if err != nil {
	log.Fatalf("%+v", err)
}

aliAccount := account.NewAliyunAccount(conf.AccessId, conf.AccessKey)
odpsIns := odps.NewOdps(aliAccount, conf.Endpoint)
odpsIns.SetDefaultProjectName(conf.ProjectName)

project := odpsIns.Project(conf.ProjectName)
tables := project.Tables()
table := tables.Get("all_types_demo")

p, err := table.GetPartition("p1=20/p2=hangzhou")
if err != nil {
	log.Fatalf("%+v", err)
}

// Get basic partition information
fmt.Printf(
	"value=%s, createTime=%s, lastDDLTime=%s, lastModifiedTime=%s, size=%d\n",
	p.Value(), p.CreatedTime(), p.LastDDLTime(), p.LastModifiedTime(), p.Size(),
)

// Get extended partition information
err = p.LoadExtended()
if err != nil {
	log.Fatalf("%+v", err)
}

fmt.Printf(
	"isArchived=%t, lifeCycle=%d, physicalSize=%d",
	p.IsArchivedEx(), p.LifeCycleEx(), p.PhysicalSizeEx(),
)
}